Future/tekno_uttv2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

release

Browse Source
This commit is contained in:
1 1
2020-12-31 15:35:46 +03:00
commit cd5ffe60a5
161 changed files with 20185 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
Release/TeknoMW3C.dll Normal file
View File

Binary file not shown.

BIN
Release/ultimateteknotool.v2.dll Normal file
View File

Binary file not shown.

BIN
Release/ultimateteknotool.v2.iobj Normal file
View File

Binary file not shown.

BIN
Release/ultimateteknotool.v2.ipdb Normal file
View File

Binary file not shown.

BIN
Release/ultimateteknotool.v2.pdb Normal file
View File

Binary file not shown.

103
libtom/libtomcrypt/include/tomcrypt.h Normal file
View File

@ -0,0 +1,103 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis
*
* LibTomCrypt is a library that provides various cryptographic
* algorithms in a highly modular and flexible manner.
*
* The library is free for all purposes without any express
* guarantee it works.
*/
#ifndef TOMCRYPT_H_
#define TOMCRYPT_H_
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stddef.h>
#include <time.h>
#include <ctype.h>
#include <limits.h>
/* use configuration data */
#include <tomcrypt_custom.h>
#ifdef __cplusplus
extern "C" {
#endif
/* version */
#define CRYPT 0x0118
#define SCRYPT "1.18.0"
/* max size of either a cipher/hash block or symmetric key [largest of the two] */
#define MAXBLOCKSIZE 128
/* descriptor table size */
#define TAB_SIZE 32
/* error codes [will be expanded in future releases] */
enum {
CRYPT_OK=0, /* Result OK */
CRYPT_ERROR, /* Generic Error */
CRYPT_NOP, /* Not a failure but no operation was performed */
CRYPT_INVALID_KEYSIZE, /* Invalid key size given */
CRYPT_INVALID_ROUNDS, /* Invalid number of rounds */
CRYPT_FAIL_TESTVECTOR, /* Algorithm failed test vectors */
CRYPT_BUFFER_OVERFLOW, /* Not enough space for output */
CRYPT_INVALID_PACKET, /* Invalid input packet given */
CRYPT_INVALID_PRNGSIZE, /* Invalid number of bits for a PRNG */
CRYPT_ERROR_READPRNG, /* Could not read enough from PRNG */
CRYPT_INVALID_CIPHER, /* Invalid cipher specified */
CRYPT_INVALID_HASH, /* Invalid hash specified */
CRYPT_INVALID_PRNG, /* Invalid PRNG specified */
CRYPT_MEM, /* Out of memory */
CRYPT_PK_TYPE_MISMATCH, /* Not equivalent types of PK keys */
CRYPT_PK_NOT_PRIVATE, /* Requires a private PK key */
CRYPT_INVALID_ARG, /* Generic invalid argument */
CRYPT_FILE_NOTFOUND, /* File Not Found */
CRYPT_PK_INVALID_TYPE, /* Invalid type of PK key */
CRYPT_OVERFLOW, /* An overflow of a value was detected/prevented */
CRYPT_UNUSED1, /* UNUSED1 */
CRYPT_INPUT_TOO_LONG, /* The input was longer than expected. */
CRYPT_PK_INVALID_SIZE, /* Invalid size input for PK parameters */
CRYPT_INVALID_PRIME_SIZE,/* Invalid size of prime requested */
CRYPT_PK_INVALID_PADDING, /* Invalid padding on input */
CRYPT_HASH_OVERFLOW /* Hash applied to too many bits */
};
#include <tomcrypt_cfg.h>
#include <tomcrypt_macros.h>
#include <tomcrypt_cipher.h>
#include <tomcrypt_hash.h>
#include <tomcrypt_mac.h>
#include <tomcrypt_prng.h>
#include <tomcrypt_pk.h>
#include <tomcrypt_math.h>
#include <tomcrypt_misc.h>
#include <tomcrypt_argchk.h>
#include <tomcrypt_pkcs.h>
#ifdef __cplusplus
}
#endif
#endif /* TOMCRYPT_H_ */
/* ref: HEAD -> master, tag: v1.18.0 */
/* git commit: 0676c9aec7299f5c398d96cbbb64f7e38f67d73f */
/* commit time: 2017-10-10 15:51:36 +0200 */

53
libtom/libtomcrypt/include/tomcrypt_argchk.h Normal file
View File

@ -0,0 +1,53 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis
*
* LibTomCrypt is a library that provides various cryptographic
* algorithms in a highly modular and flexible manner.
*
* The library is free for all purposes without any express
* guarantee it works.
*/
/* Defines the LTC_ARGCHK macro used within the library */
/* ARGTYPE is defined in tomcrypt_cfg.h */
#if ARGTYPE == 0
#include <signal.h>
/* this is the default LibTomCrypt macro */
#if defined(__clang__) || defined(__GNUC_MINOR__)
#define NORETURN __attribute__ ((noreturn))
#else
#define NORETURN
#endif
void crypt_argchk(const char *v, const char *s, int d) NORETURN;
#define LTC_ARGCHK(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0)
#define LTC_ARGCHKVD(x) do { if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } }while(0)
#elif ARGTYPE == 1
/* fatal type of error */
#define LTC_ARGCHK(x) assert((x))
#define LTC_ARGCHKVD(x) LTC_ARGCHK(x)
#elif ARGTYPE == 2
#define LTC_ARGCHK(x) if (!(x)) { fprintf(stderr, "\nwarning: ARGCHK failed at %s:%d\n", __FILE__, __LINE__); }
#define LTC_ARGCHKVD(x) LTC_ARGCHK(x)
#elif ARGTYPE == 3
#define LTC_ARGCHK(x)
#define LTC_ARGCHKVD(x) LTC_ARGCHK(x)
#elif ARGTYPE == 4
#define LTC_ARGCHK(x) if (!(x)) return CRYPT_INVALID_ARG;
#define LTC_ARGCHKVD(x) if (!(x)) return;
#endif
/* ref: HEAD -> master, tag: v1.18.0 */
/* git commit: 0676c9aec7299f5c398d96cbbb64f7e38f67d73f */
/* commit time: 2017-10-10 15:51:36 +0200 */

283
libtom/libtomcrypt/include/tomcrypt_cfg.h Normal file
View File

@ -0,0 +1,283 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis
*
* LibTomCrypt is a library that provides various cryptographic
* algorithms in a highly modular and flexible manner.
*
* The library is free for all purposes without any express
* guarantee it works.
*/
/* This is the build config file.
*
* With this you can setup what to inlcude/exclude automatically during any build. Just comment
* out the line that #define's the word for the thing you want to remove. phew!
*/
#ifndef TOMCRYPT_CFG_H
#define TOMCRYPT_CFG_H
#if defined(_WIN32) || defined(_MSC_VER)
#define LTC_CALL __cdecl
#elif !defined(LTC_CALL)
#define LTC_CALL
#endif
#ifndef LTC_EXPORT
#define LTC_EXPORT
#endif
/* certain platforms use macros for these, making the prototypes broken */
#ifndef LTC_NO_PROTOTYPES
/* you can change how memory allocation works ... */
LTC_EXPORT void * LTC_CALL XMALLOC(size_t n);
LTC_EXPORT void * LTC_CALL XREALLOC(void *p, size_t n);
LTC_EXPORT void * LTC_CALL XCALLOC(size_t n, size_t s);
LTC_EXPORT void LTC_CALL XFREE(void *p);
LTC_EXPORT void LTC_CALL XQSORT(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));
/* change the clock function too */
LTC_EXPORT clock_t LTC_CALL XCLOCK(void);
/* various other functions */
LTC_EXPORT void * LTC_CALL XMEMCPY(void *dest, const void *src, size_t n);
LTC_EXPORT int LTC_CALL XMEMCMP(const void *s1, const void *s2, size_t n);
LTC_EXPORT void * LTC_CALL XMEMSET(void *s, int c, size_t n);
LTC_EXPORT int LTC_CALL XSTRCMP(const char *s1, const char *s2);
#endif
/* some compilers do not like "inline" (or maybe "static inline"), namely: HP cc, IBM xlc */
#if defined(__HP_cc) || defined(__xlc__)
#define LTC_INLINE
#elif defined(_MSC_VER)
#define LTC_INLINE __inline
#else
#define LTC_INLINE inline
#endif
/* type of argument checking, 0=default, 1=fatal and 2=error+continue, 3=nothing */
#ifndef ARGTYPE
#define ARGTYPE 0
#endif
#undef LTC_ENCRYPT
#define LTC_ENCRYPT 0
#undef LTC_DECRYPT
#define LTC_DECRYPT 1
/* Controls endianess and size of registers. Leave uncommented to get platform neutral [slower] code
*
* Note: in order to use the optimized macros your platform must support unaligned 32 and 64 bit read/writes.
* The x86 platforms allow this but some others [ARM for instance] do not. On those platforms you **MUST**
* use the portable [slower] macros.
*/
/* detect x86/i386 32bit */
#if defined(__i386__) || defined(__i386) || defined(_M_IX86)
#define ENDIAN_LITTLE
#define ENDIAN_32BITWORD
#define LTC_FAST
#endif
/* detect amd64/x64 */
#if defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64)
#define ENDIAN_LITTLE
#define ENDIAN_64BITWORD
#define LTC_FAST
#endif
/* detect PPC32 */
#if defined(LTC_PPC32)
#define ENDIAN_BIG
#define ENDIAN_32BITWORD
#define LTC_FAST
#endif
/* detects MIPS R5900 processors (PS2) */
#if (defined(__R5900) || defined(R5900) || defined(__R5900__)) && (defined(_mips) || defined(__mips__) || defined(mips))
#define ENDIAN_64BITWORD
#if defined(_MIPSEB) || defined(__MIPSEB) || defined(__MIPSEB__)
#define ENDIAN_BIG
#endif
#define ENDIAN_LITTLE
#endif
#endif
/* detect AIX */
#if defined(_AIX) && defined(_BIG_ENDIAN)
#define ENDIAN_BIG
#if defined(__LP64__) || defined(_ARCH_PPC64)
#define ENDIAN_64BITWORD
#else
#define ENDIAN_32BITWORD
#endif
#endif
/* detect HP-UX */
#if defined(__hpux) || defined(__hpux__)
#define ENDIAN_BIG
#if defined(__ia64) || defined(__ia64__) || defined(__LP64__)
#define ENDIAN_64BITWORD
#else
#define ENDIAN_32BITWORD
#endif
#endif
/* detect Apple OS X */
#if defined(__APPLE__) && defined(__MACH__)
#if defined(__LITTLE_ENDIAN__) || defined(__x86_64__)
#define ENDIAN_LITTLE
#else
#define ENDIAN_BIG
#endif
#if defined(__LP64__) || defined(__x86_64__)
#define ENDIAN_64BITWORD
#else
#define ENDIAN_32BITWORD
#endif
#endif
/* detect SPARC and SPARC64 */
#if defined(__sparc__) || defined(__sparc)
#define ENDIAN_BIG
#if defined(__arch64__) || defined(__sparcv9) || defined(__sparc_v9__)
#define ENDIAN_64BITWORD
#else
#define ENDIAN_32BITWORD
#endif
#endif
/* detect IBM S390(x) */
#if defined(__s390x__) || defined(__s390__)
#define ENDIAN_BIG
#if defined(__s390x__)
#define ENDIAN_64BITWORD
#else
#define ENDIAN_32BITWORD
#endif
#endif
/* detect PPC64 */
#if defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__)
#define ENDIAN_64BITWORD
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#define ENDIAN_BIG
#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define ENDIAN_LITTLE
#endif
#define LTC_FAST
#endif
/* endianness fallback */
#if !defined(ENDIAN_BIG) && !defined(ENDIAN_LITTLE)
#if defined(_BYTE_ORDER) && _BYTE_ORDER == _BIG_ENDIAN || \
defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN || \
defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ || \
defined(__BIG_ENDIAN__) || \
defined(__ARMEB__) || defined(__THUMBEB__) || defined(__AARCH64EB__) || \
defined(_MIPSEB) || defined(__MIPSEB) || defined(__MIPSEB__)
#define ENDIAN_BIG
#elif defined(_BYTE_ORDER) && _BYTE_ORDER == _LITTLE_ENDIAN || \
defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN || \
defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ || \
defined(__LITTLE_ENDIAN__) || \
defined(__ARMEL__) || defined(__THUMBEL__) || defined(__AARCH64EL__) || \
defined(_MIPSEL) || defined(__MIPSEL) || defined(__MIPSEL__)
#define ENDIAN_LITTLE
#else
#error Cannot detect endianness
#endif
#endif
/* ulong64: 64-bit data type */
#ifdef _MSC_VER
#define CONST64(n) n ## ui64
typedef unsigned __int64 ulong64;
#else
#define CONST64(n) n ## ULL
typedef unsigned long long ulong64;
#endif
/* ulong32: "32-bit at least" data type */
#if defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64) || \
defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__) || \
defined(__s390x__) || defined(__arch64__) || defined(__aarch64__) || \
defined(__sparcv9) || defined(__sparc_v9__) || defined(__sparc64__) || \
defined(__ia64) || defined(__ia64__) || defined(__itanium__) || defined(_M_IA64) || \
defined(__LP64__) || defined(_LP64) || defined(__64BIT__)
typedef unsigned ulong32;
#if !defined(ENDIAN_64BITWORD) && !defined(ENDIAN_32BITWORD)
#define ENDIAN_64BITWORD
#endif
#else
typedef unsigned long ulong32;
#if !defined(ENDIAN_64BITWORD) && !defined(ENDIAN_32BITWORD)
#define ENDIAN_32BITWORD
#endif
#endif
#if defined(ENDIAN_64BITWORD) && !defined(_MSC_VER)
typedef unsigned long long ltc_mp_digit;
#else
typedef unsigned long ltc_mp_digit;
#endif
/* No asm is a quick way to disable anything "not portable" */
#ifdef LTC_NO_ASM
#define ENDIAN_NEUTRAL
#undef ENDIAN_32BITWORD
#undef ENDIAN_64BITWORD
#undef LTC_FAST
#define LTC_NO_ROLC
#define LTC_NO_BSWAP
#endif
/* No LTC_FAST if: explicitly disabled OR non-gcc/non-clang compiler OR old gcc OR using -ansi -std=c99 */
#if defined(LTC_NO_FAST) || (__GNUC__ < 4) || defined(__STRICT_ANSI__)
#undef LTC_FAST
#endif
#ifdef LTC_FAST
#define LTC_FAST_TYPE_PTR_CAST(x) ((LTC_FAST_TYPE*)(void*)(x))
#ifdef ENDIAN_64BITWORD
typedef ulong64 __attribute__((__may_alias__)) LTC_FAST_TYPE;
#else
typedef ulong32 __attribute__((__may_alias__)) LTC_FAST_TYPE;
#endif
#endif
#if !defined(ENDIAN_NEUTRAL) && (defined(ENDIAN_BIG) || defined(ENDIAN_LITTLE)) && !(defined(ENDIAN_32BITWORD) || defined(ENDIAN_64BITWORD))
#error You must specify a word size as well as endianess in tomcrypt_cfg.h
#endif
#if !(defined(ENDIAN_BIG) || defined(ENDIAN_LITTLE))
#define ENDIAN_NEUTRAL
#endif
#if (defined(ENDIAN_32BITWORD) && defined(ENDIAN_64BITWORD))
#error Cannot be 32 and 64 bit words...
#endif
/* gcc 4.3 and up has a bswap builtin; detect it by gcc version.
* clang also supports the bswap builtin, and although clang pretends
* to be gcc (macro-wise, anyway), clang pretends to be a version
* prior to gcc 4.3, so we can't detect bswap that way. Instead,
* clang has a __has_builtin mechanism that can be used to check
* for builtins:
* http://clang.llvm.org/docs/LanguageExtensions.html#feature_check */
#ifndef __has_builtin
#define __has_builtin(x) 0
#endif
#if !defined(LTC_NO_BSWAP) && defined(__GNUC__) && \
((__GNUC__ * 100 + __GNUC_MINOR__ >= 403) || \
(__has_builtin(__builtin_bswap32) && __has_builtin(__builtin_bswap64)))
#define LTC_HAVE_BSWAP_BUILTIN
#endif
/* ref: HEAD -> master, tag: v1.18.0 */
/* git commit: 0676c9aec7299f5c398d96cbbb64f7e38f67d73f */
/* commit time: 2017-10-10 15:51:36 +0200 */

1008
libtom/libtomcrypt/include/tomcrypt_cipher.h Normal file
View File

File diff suppressed because it is too large Load Diff

585
libtom/libtomcrypt/include/tomcrypt_custom.h Normal file
View File

@ -0,0 +1,585 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis
*
* LibTomCrypt is a library that provides various cryptographic
* algorithms in a highly modular and flexible manner.
*
* The library is free for all purposes without any express
* guarantee it works.
*/
#ifndef TOMCRYPT_CUSTOM_H_
#define TOMCRYPT_CUSTOM_H_
#define LTM_DESC
/* macros for various libc functions you can change for embedded targets */
#ifndef XMALLOC
#define XMALLOC malloc
#endif
#ifndef XREALLOC
#define XREALLOC realloc
#endif
#ifndef XCALLOC
#define XCALLOC calloc
#endif
#ifndef XFREE
#define XFREE free
#endif
#ifndef XMEMSET
#define XMEMSET memset
#endif
#ifndef XMEMCPY
#define XMEMCPY memcpy
#endif
#ifndef XMEMMOVE
#define XMEMMOVE memmove
#endif
#ifndef XMEMCMP
#define XMEMCMP memcmp
#endif
/* A memory compare function that has to run in constant time,
* c.f. mem_neq() API summary.
*/
#ifndef XMEM_NEQ
#define XMEM_NEQ mem_neq
#endif
#ifndef XSTRCMP
#define XSTRCMP strcmp
#endif
#ifndef XCLOCK
#define XCLOCK clock
#endif
#ifndef XQSORT
#define XQSORT qsort
#endif
/*#if ( defined(malloc) || defined(realloc) || defined(calloc) || defined(free) || \
defined(memset) || defined(memcpy) || defined(memcmp) || defined(strcmp) || \
defined(clock) || defined(qsort) ) && !defined(LTC_NO_PROTOTYPES)
#define LTC_NO_PROTOTYPES
#endif*/
#define LTC_NO_PROTOTYPES
/* shortcut to disable automatic inclusion */
#if defined LTC_NOTHING && !defined LTC_EASY
#define LTC_NO_CIPHERS
#define LTC_NO_MODES
#define LTC_NO_HASHES
#define LTC_NO_MACS
#define LTC_NO_PRNGS
#define LTC_NO_PK
#define LTC_NO_PKCS
#define LTC_NO_MISC
#endif /* LTC_NOTHING */
/* Easy button? */
#ifdef LTC_EASY
#define LTC_NO_CIPHERS
#define LTC_RIJNDAEL
#define LTC_BLOWFISH
#define LTC_DES
#define LTC_CAST5
#define LTC_NO_MODES
#define LTC_ECB_MODE
#define LTC_CBC_MODE
#define LTC_CTR_MODE
#define LTC_NO_HASHES
#define LTC_SHA1
#define LTC_SHA3
#define LTC_SHA512
#define LTC_SHA384
#define LTC_SHA256
#define LTC_SHA224
#define LTC_HASH_HELPERS
#define LTC_NO_MACS
#define LTC_HMAC
#define LTC_OMAC
#define LTC_CCM_MODE
#define LTC_NO_PRNGS
#define LTC_SPRNG
#define LTC_YARROW
#define LTC_DEVRANDOM
#define LTC_TRY_URANDOM_FIRST
#define LTC_RNG_GET_BYTES
#define LTC_RNG_MAKE_PRNG
#define LTC_NO_PK
#define LTC_MRSA
#define LTC_MECC
#define LTC_NO_MISC
#define LTC_BASE64
#endif
/* The minimal set of functionality to run the tests */
#ifdef LTC_MINIMAL
#define LTC_RIJNDAEL
#define LTC_SHA256
#define LTC_YARROW
#define LTC_CTR_MODE
#define LTC_RNG_MAKE_PRNG
#define LTC_RNG_GET_BYTES
#define LTC_DEVRANDOM
#define LTC_TRY_URANDOM_FIRST
#undef LTC_NO_FILE
#endif
/* Enable self-test test vector checking */
#ifndef LTC_NO_TEST
#define LTC_TEST
#endif
/* Enable extended self-tests */
/* #define LTC_TEST_EXT */
/* Use small code where possible */
/* #define LTC_SMALL_CODE */
/* clean the stack of functions which put private information on stack */
/* #define LTC_CLEAN_STACK */
/* disable all file related functions */
/* #define LTC_NO_FILE */
/* disable all forms of ASM */
/* #define LTC_NO_ASM */
/* disable FAST mode */
/* #define LTC_NO_FAST */
/* disable BSWAP on x86 */
/* #define LTC_NO_BSWAP */
/* ---> math provider? <--- */
#ifndef LTC_NO_MATH
/* LibTomMath */
/* #define LTM_DESC */
/* TomsFastMath */
/* #define TFM_DESC */
/* GNU Multiple Precision Arithmetic Library */
/* #define GMP_DESC */
#endif /* LTC_NO_MATH */
/* ---> Symmetric Block Ciphers <--- */
#ifndef LTC_NO_CIPHERS
#define LTC_BLOWFISH
#define LTC_RC2
#define LTC_RC5
#define LTC_RC6
#define LTC_SAFERP
#define LTC_RIJNDAEL
#define LTC_XTEA
/* _TABLES tells it to use tables during setup, _SMALL means to use the smaller scheduled key format
* (saves 4KB of ram), _ALL_TABLES enables all tables during setup */
#define LTC_TWOFISH
#ifndef LTC_NO_TABLES
#define LTC_TWOFISH_TABLES
/* #define LTC_TWOFISH_ALL_TABLES */
#else
#define LTC_TWOFISH_SMALL
#endif
/* #define LTC_TWOFISH_SMALL */
/* LTC_DES includes EDE triple-DES */
#define LTC_DES
#define LTC_CAST5
#define LTC_NOEKEON
#define LTC_SKIPJACK
#define LTC_SAFER
#define LTC_KHAZAD
#define LTC_ANUBIS
#define LTC_ANUBIS_TWEAK
#define LTC_KSEED
#define LTC_KASUMI
#define LTC_MULTI2
#define LTC_CAMELLIA
/* stream ciphers */
#define LTC_CHACHA
#define LTC_RC4_STREAM
#define LTC_SOBER128_STREAM
#endif /* LTC_NO_CIPHERS */
/* ---> Block Cipher Modes of Operation <--- */
#ifndef LTC_NO_MODES
#define LTC_CFB_MODE
#define LTC_OFB_MODE
#define LTC_ECB_MODE
#define LTC_CBC_MODE
#define LTC_CTR_MODE
/* F8 chaining mode */
#define LTC_F8_MODE
/* LRW mode */
#define LTC_LRW_MODE
#ifndef LTC_NO_TABLES
/* like GCM mode this will enable 16 8x128 tables [64KB] that make
* seeking very fast.
*/
#define LTC_LRW_TABLES
#endif
/* XTS mode */
#define LTC_XTS_MODE
#endif /* LTC_NO_MODES */
/* ---> One-Way Hash Functions <--- */
#ifndef LTC_NO_HASHES
#define LTC_CHC_HASH
#define LTC_WHIRLPOOL
#define LTC_SHA3
#define LTC_SHA512
#define LTC_SHA512_256
#define LTC_SHA512_224
#define LTC_SHA384
#define LTC_SHA256
#define LTC_SHA224
#define LTC_TIGER
#define LTC_SHA1
#define LTC_MD5
#define LTC_MD4
#define LTC_MD2
#define LTC_RIPEMD128
#define LTC_RIPEMD160
#define LTC_RIPEMD256
#define LTC_RIPEMD320
#define LTC_BLAKE2S
#define LTC_BLAKE2B
#define LTC_HASH_HELPERS
#endif /* LTC_NO_HASHES */
/* ---> MAC functions <--- */
#ifndef LTC_NO_MACS
#define LTC_HMAC
#define LTC_OMAC
#define LTC_PMAC
#define LTC_XCBC
#define LTC_F9_MODE
#define LTC_PELICAN
#define LTC_POLY1305
#define LTC_BLAKE2SMAC
#define LTC_BLAKE2BMAC
/* ---> Encrypt + Authenticate Modes <--- */
#define LTC_EAX_MODE
#define LTC_OCB_MODE
#define LTC_OCB3_MODE
#define LTC_CCM_MODE
#define LTC_GCM_MODE
#define LTC_CHACHA20POLY1305_MODE
/* Use 64KiB tables */
#ifndef LTC_NO_TABLES
#define LTC_GCM_TABLES
#endif
/* USE SSE2? requires GCC works on x86_32 and x86_64*/
#ifdef LTC_GCM_TABLES
/* #define LTC_GCM_TABLES_SSE2 */
#endif
#endif /* LTC_NO_MACS */
/* --> Pseudo Random Number Generators <--- */
#ifndef LTC_NO_PRNGS
/* Yarrow */
#define LTC_YARROW
/* a PRNG that simply reads from an available system source */
#define LTC_SPRNG
/* The RC4 stream cipher based PRNG */
#define LTC_RC4
/* The ChaCha20 stream cipher based PRNG */
#define LTC_CHACHA20_PRNG
/* Fortuna PRNG */
#define LTC_FORTUNA
/* Greg's SOBER128 stream cipher based PRNG */
#define LTC_SOBER128
/* the *nix style /dev/random device */
#define LTC_DEVRANDOM
/* try /dev/urandom before trying /dev/random
* are you sure you want to disable this? http://www.2uo.de/myths-about-urandom/ */
#define LTC_TRY_URANDOM_FIRST
/* rng_get_bytes() */
#define LTC_RNG_GET_BYTES
/* rng_make_prng() */
#define LTC_RNG_MAKE_PRNG
/* enable the ltc_rng hook to integrate e.g. embedded hardware RNG's easily */
/* #define LTC_PRNG_ENABLE_LTC_RNG */
#endif /* LTC_NO_PRNGS */
#ifdef LTC_YARROW
/* which descriptor of AES to use? */
/* 0 = rijndael_enc 1 = aes_enc, 2 = rijndael [full], 3 = aes [full] */
#ifdef ENCRYPT_ONLY
#define LTC_YARROW_AES 0
#else
#define LTC_YARROW_AES 2
#endif
#endif
#ifdef LTC_FORTUNA
#ifndef LTC_FORTUNA_WD
/* reseed every N calls to the read function */
#define LTC_FORTUNA_WD 10
#endif
#ifndef LTC_FORTUNA_POOLS
/* number of pools (4..32) can save a bit of ram by lowering the count */
#define LTC_FORTUNA_POOLS 32
#endif
#endif /* LTC_FORTUNA */
/* ---> Public Key Crypto <--- */
#ifndef LTC_NO_PK
/* Include RSA support */
#define LTC_MRSA
/* Include Diffie-Hellman support */
/* is_prime fails for GMP */
#define LTC_MDH
/* Supported Key Sizes */
#define LTC_DH768
#define LTC_DH1024
#define LTC_DH1536
#define LTC_DH2048
#ifndef TFM_DESC
/* tfm has a problem in fp_isprime for larger key sizes */
#define LTC_DH3072
#define LTC_DH4096
#define LTC_DH6144
#define LTC_DH8192
#endif
/* Include Katja (a Rabin variant like RSA) */
/* #define LTC_MKAT */
/* Digital Signature Algorithm */
#define LTC_MDSA
/* ECC */
#define LTC_MECC
/* use Shamir's trick for point mul (speeds up signature verification) */
#define LTC_ECC_SHAMIR
#if defined(TFM_DESC) && defined(LTC_MECC)
#define LTC_MECC_ACCEL
#endif
/* do we want fixed point ECC */
/* #define LTC_MECC_FP */
#endif /* LTC_NO_PK */
#if defined(LTC_MRSA) && !defined(LTC_NO_RSA_BLINDING)
/* Enable RSA blinding when doing private key operations by default */
#define LTC_RSA_BLINDING
#endif /* LTC_NO_RSA_BLINDING */
#if defined(LTC_MRSA) && !defined(LTC_NO_RSA_CRT_HARDENING)
/* Enable RSA CRT hardening when doing private key operations by default */
#define LTC_RSA_CRT_HARDENING
#endif /* LTC_NO_RSA_CRT_HARDENING */
#if defined(LTC_MECC) && !defined(LTC_NO_ECC_TIMING_RESISTANT)
/* Enable ECC timing resistant version by default */
#define LTC_ECC_TIMING_RESISTANT
#endif
/* PKCS #1 (RSA) and #5 (Password Handling) stuff */
#ifndef LTC_NO_PKCS
#define LTC_PKCS_1
#define LTC_PKCS_5
/* Include ASN.1 DER (required by DSA/RSA) */
#define LTC_DER
#endif /* LTC_NO_PKCS */
/* misc stuff */
#ifndef LTC_NO_MISC
/* Various tidbits of modern neatoness */
#define LTC_BASE64
/* ... and it's URL safe version */
#define LTC_BASE64_URL
/* Keep LTC_NO_HKDF for compatibility reasons
* superseeded by LTC_NO_MISC*/
#ifndef LTC_NO_HKDF
/* HKDF Key Derivation/Expansion stuff */
#define LTC_HKDF
#endif /* LTC_NO_HKDF */
#define LTC_ADLER32
#define LTC_CRC32
#endif /* LTC_NO_MISC */
/* cleanup */
#ifdef LTC_MECC
/* Supported ECC Key Sizes */
#ifndef LTC_NO_CURVES
#define LTC_ECC112
#define LTC_ECC128
#define LTC_ECC160
#define LTC_ECC192
#define LTC_ECC224
#define LTC_ECC256
#define LTC_ECC384
#define LTC_ECC521
#endif
#endif
#if defined(LTC_MECC) || defined(LTC_MRSA) || defined(LTC_MDSA) || defined(LTC_MKAT)
/* Include the MPI functionality? (required by the PK algorithms) */
#define LTC_MPI
#ifndef LTC_PK_MAX_RETRIES
/* iterations limit for retry-loops */
#define LTC_PK_MAX_RETRIES 20
#endif
#endif
#ifdef LTC_MRSA
#define LTC_PKCS_1
#endif
#if defined(LTC_PELICAN) && !defined(LTC_RIJNDAEL)
#error Pelican-MAC requires LTC_RIJNDAEL
#endif
#if defined(LTC_EAX_MODE) && !(defined(LTC_CTR_MODE) && defined(LTC_OMAC))
#error LTC_EAX_MODE requires CTR and LTC_OMAC mode
#endif
#if defined(LTC_YARROW) && !defined(LTC_CTR_MODE)
#error LTC_YARROW requires LTC_CTR_MODE chaining mode to be defined!
#endif
#if defined(LTC_DER) && !defined(LTC_MPI)
#error ASN.1 DER requires MPI functionality
#endif
#if (defined(LTC_MDSA) || defined(LTC_MRSA) || defined(LTC_MECC) || defined(LTC_MKAT)) && !defined(LTC_DER)
#error PK requires ASN.1 DER functionality, make sure LTC_DER is enabled
#endif
#if defined(LTC_CHACHA20POLY1305_MODE) && (!defined(LTC_CHACHA) || !defined(LTC_POLY1305))
#error LTC_CHACHA20POLY1305_MODE requires LTC_CHACHA + LTC_POLY1305
#endif
#if defined(LTC_CHACHA20_PRNG) && !defined(LTC_CHACHA)
#error LTC_CHACHA20_PRNG requires LTC_CHACHA
#endif
#if defined(LTC_RC4) && !defined(LTC_RC4_STREAM)
#error LTC_RC4 requires LTC_RC4_STREAM
#endif
#if defined(LTC_SOBER128) && !defined(LTC_SOBER128_STREAM)
#error LTC_SOBER128 requires LTC_SOBER128_STREAM
#endif
#if defined(LTC_BLAKE2SMAC) && !defined(LTC_BLAKE2S)
#error LTC_BLAKE2SMAC requires LTC_BLAKE2S
#endif
#if defined(LTC_BLAKE2BMAC) && !defined(LTC_BLAKE2B)
#error LTC_BLAKE2BMAC requires LTC_BLAKE2B
#endif
#if defined(LTC_SPRNG) && !defined(LTC_RNG_GET_BYTES)
#error LTC_SPRNG requires LTC_RNG_GET_BYTES
#endif
#if defined(LTC_NO_MATH) && (defined(LTM_DESC) || defined(TFM_DESC) || defined(GMP_DESC))
#error LTC_NO_MATH defined, but also a math descriptor
#endif
/* THREAD management */
#ifdef LTC_PTHREAD
#include <pthread.h>
#define LTC_MUTEX_GLOBAL(x) pthread_mutex_t x = PTHREAD_MUTEX_INITIALIZER;
#define LTC_MUTEX_PROTO(x) extern pthread_mutex_t x;
#define LTC_MUTEX_TYPE(x) pthread_mutex_t x;
#define LTC_MUTEX_INIT(x) LTC_ARGCHK(pthread_mutex_init(x, NULL) == 0);
#define LTC_MUTEX_LOCK(x) LTC_ARGCHK(pthread_mutex_lock(x) == 0);
#define LTC_MUTEX_UNLOCK(x) LTC_ARGCHK(pthread_mutex_unlock(x) == 0);
#else
/* default no functions */
#define LTC_MUTEX_GLOBAL(x)
#define LTC_MUTEX_PROTO(x)
#define LTC_MUTEX_TYPE(x)
#define LTC_MUTEX_INIT(x)
#define LTC_MUTEX_LOCK(x)
#define LTC_MUTEX_UNLOCK(x)
#endif
/* Debuggers */
/* define this if you use Valgrind, note: it CHANGES the way SOBER-128 and RC4 work (see the code) */
/* #define LTC_VALGRIND */
#endif
#ifndef LTC_NO_FILE
/* buffer size for reading from a file via fread(..) */
#ifndef LTC_FILE_READ_BUFSIZE
#define LTC_FILE_READ_BUFSIZE 8192
#endif
#endif
/* ref: HEAD -> master, tag: v1.18.0 */
/* git commit: 0676c9aec7299f5c398d96cbbb64f7e38f67d73f */
/* commit time: 2017-10-10 15:51:36 +0200 */

531
libtom/libtomcrypt/include/tomcrypt_hash.h Normal file
View File

@ -0,0 +1,531 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis
*
* LibTomCrypt is a library that provides various cryptographic
* algorithms in a highly modular and flexible manner.
*
* The library is free for all purposes without any express
* guarantee it works.
*/
/* ---- HASH FUNCTIONS ---- */
#ifdef LTC_SHA3
struct sha3_state {
ulong64 saved; /* the portion of the input message that we didn't consume yet */
ulong64 s[25];
unsigned char sb[25 * 8]; /* used for storing `ulong64 s[25]` as little-endian bytes */
unsigned short byte_index; /* 0..7--the next byte after the set one (starts from 0; 0--none are buffered) */
unsigned short word_index; /* 0..24--the next word to integrate input (starts from 0) */
unsigned short capacity_words; /* the double size of the hash output in words (e.g. 16 for Keccak 512) */
unsigned short xof_flag;
};
#endif
#ifdef LTC_SHA512
struct sha512_state {
ulong64 length, state[8];
unsigned long curlen;
unsigned char buf[128];
};
#endif
#ifdef LTC_SHA256
struct sha256_state {
ulong64 length;
ulong32 state[8], curlen;
unsigned char buf[64];
};
#endif
#ifdef LTC_SHA1
struct sha1_state {
ulong64 length;
ulong32 state[5], curlen;
unsigned char buf[64];
};
#endif
#ifdef LTC_MD5
struct md5_state {
ulong64 length;
ulong32 state[4], curlen;
unsigned char buf[64];
};
#endif
#ifdef LTC_MD4
struct md4_state {
ulong64 length;
ulong32 state[4], curlen;
unsigned char buf[64];
};
#endif
#ifdef LTC_TIGER
struct tiger_state {
ulong64 state[3], length;
unsigned long curlen;
unsigned char buf[64];
};
#endif
#ifdef LTC_MD2
struct md2_state {
unsigned char chksum[16], X[48], buf[16];
unsigned long curlen;
};
#endif
#ifdef LTC_RIPEMD128
struct rmd128_state {
ulong64 length;
unsigned char buf[64];
ulong32 curlen, state[4];
};
#endif
#ifdef LTC_RIPEMD160
struct rmd160_state {
ulong64 length;
unsigned char buf[64];
ulong32 curlen, state[5];
};
#endif
#ifdef LTC_RIPEMD256
struct rmd256_state {
ulong64 length;
unsigned char buf[64];
ulong32 curlen, state[8];
};
#endif
#ifdef LTC_RIPEMD320
struct rmd320_state {
ulong64 length;
unsigned char buf[64];
ulong32 curlen, state[10];
};
#endif
#ifdef LTC_WHIRLPOOL
struct whirlpool_state {
ulong64 length, state[8];
unsigned char buf[64];
ulong32 curlen;
};
#endif
#ifdef LTC_CHC_HASH
struct chc_state {
ulong64 length;
unsigned char state[MAXBLOCKSIZE], buf[MAXBLOCKSIZE];
ulong32 curlen;
};
#endif
#ifdef LTC_BLAKE2S
struct blake2s_state {
ulong32 h[8];
ulong32 t[2];
ulong32 f[2];
unsigned char buf[64];
unsigned long curlen;
unsigned long outlen;
unsigned char last_node;
};
#endif
#ifdef LTC_BLAKE2B
struct blake2b_state {
ulong64 h[8];
ulong64 t[2];
ulong64 f[2];
unsigned char buf[128];
unsigned long curlen;
unsigned long outlen;
unsigned char last_node;
};
#endif
typedef union Hash_state {
char dummy[1];
#ifdef LTC_CHC_HASH
struct chc_state chc;
#endif
#ifdef LTC_WHIRLPOOL
struct whirlpool_state whirlpool;
#endif
#ifdef LTC_SHA3
struct sha3_state sha3;
#endif
#ifdef LTC_SHA512
struct sha512_state sha512;
#endif
#ifdef LTC_SHA256
struct sha256_state sha256;
#endif
#ifdef LTC_SHA1
struct sha1_state sha1;
#endif
#ifdef LTC_MD5
struct md5_state md5;
#endif
#ifdef LTC_MD4
struct md4_state md4;
#endif
#ifdef LTC_MD2
struct md2_state md2;
#endif
#ifdef LTC_TIGER
struct tiger_state tiger;
#endif
#ifdef LTC_RIPEMD128
struct rmd128_state rmd128;
#endif
#ifdef LTC_RIPEMD160
struct rmd160_state rmd160;
#endif
#ifdef LTC_RIPEMD256
struct rmd256_state rmd256;
#endif
#ifdef LTC_RIPEMD320
struct rmd320_state rmd320;
#endif
#ifdef LTC_BLAKE2S
struct blake2s_state blake2s;
#endif
#ifdef LTC_BLAKE2B
struct blake2b_state blake2b;
#endif
void *data;
} hash_state;
/** hash descriptor */
extern struct ltc_hash_descriptor {
/** name of hash */
const char *name;
/** internal ID */
unsigned char ID;
/** Size of digest in octets */
unsigned long hashsize;
/** Input block size in octets */
unsigned long blocksize;
/** ASN.1 OID */
unsigned long OID[16];
/** Length of DER encoding */
unsigned long OIDlen;
/** Init a hash state
@param hash The hash to initialize
@return CRYPT_OK if successful
*/
int (*init)(hash_state *hash);
/** Process a block of data
@param hash The hash state
@param in The data to hash
@param inlen The length of the data (octets)
@return CRYPT_OK if successful
*/
int (*process)(hash_state *hash, const unsigned char *in, unsigned long inlen);
/** Produce the digest and store it
@param hash The hash state
@param out [out] The destination of the digest
@return CRYPT_OK if successful
*/
int (*done)(hash_state *hash, unsigned char *out);
/** Self-test
@return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
*/
int (*test)(void);
/* accelerated hmac callback: if you need to-do multiple packets just use the generic hmac_memory and provide a hash callback */
int (*hmac_block)(const unsigned char *key, unsigned long keylen,
const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
} hash_descriptor[];
#ifdef LTC_CHC_HASH
int chc_register(int cipher);
int chc_init(hash_state * md);
int chc_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int chc_done(hash_state * md, unsigned char *hash);
int chc_test(void);
extern const struct ltc_hash_descriptor chc_desc;
#endif
#ifdef LTC_WHIRLPOOL
int whirlpool_init(hash_state * md);
int whirlpool_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int whirlpool_done(hash_state * md, unsigned char *hash);
int whirlpool_test(void);
extern const struct ltc_hash_descriptor whirlpool_desc;
#endif
#ifdef LTC_SHA3
int sha3_512_init(hash_state * md);
int sha3_512_test(void);
extern const struct ltc_hash_descriptor sha3_512_desc;
int sha3_384_init(hash_state * md);
int sha3_384_test(void);
extern const struct ltc_hash_descriptor sha3_384_desc;
int sha3_256_init(hash_state * md);
int sha3_256_test(void);
extern const struct ltc_hash_descriptor sha3_256_desc;
int sha3_224_init(hash_state * md);
int sha3_224_test(void);
extern const struct ltc_hash_descriptor sha3_224_desc;
/* process + done are the same for all variants */
int sha3_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int sha3_done(hash_state *md, unsigned char *hash);
/* SHAKE128 + SHAKE256 */
int sha3_shake_init(hash_state *md, int num);
#define sha3_shake_process(a,b,c) sha3_process(a,b,c)
int sha3_shake_done(hash_state *md, unsigned char *out, unsigned long outlen);
int sha3_shake_test(void);
int sha3_shake_memory(int num, const unsigned char *in, unsigned long inlen, unsigned char *out, unsigned long *outlen);
#endif
#ifdef LTC_SHA512
int sha512_init(hash_state * md);
int sha512_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int sha512_done(hash_state * md, unsigned char *hash);
int sha512_test(void);
extern const struct ltc_hash_descriptor sha512_desc;
#endif
#ifdef LTC_SHA384
#ifndef LTC_SHA512
#error LTC_SHA512 is required for LTC_SHA384
#endif
int sha384_init(hash_state * md);
#define sha384_process sha512_process
int sha384_done(hash_state * md, unsigned char *hash);
int sha384_test(void);
extern const struct ltc_hash_descriptor sha384_desc;
#endif
#ifdef LTC_SHA512_256
#ifndef LTC_SHA512
#error LTC_SHA512 is required for LTC_SHA512_256
#endif
int sha512_256_init(hash_state * md);
#define sha512_256_process sha512_process
int sha512_256_done(hash_state * md, unsigned char *hash);
int sha512_256_test(void);
extern const struct ltc_hash_descriptor sha512_256_desc;
#endif
#ifdef LTC_SHA512_224
#ifndef LTC_SHA512
#error LTC_SHA512 is required for LTC_SHA512_224
#endif
int sha512_224_init(hash_state * md);
#define sha512_224_process sha512_process
int sha512_224_done(hash_state * md, unsigned char *hash);
int sha512_224_test(void);
extern const struct ltc_hash_descriptor sha512_224_desc;
#endif
#ifdef LTC_SHA256
int sha256_init(hash_state * md);
int sha256_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int sha256_done(hash_state * md, unsigned char *hash);
int sha256_test(void);
extern const struct ltc_hash_descriptor sha256_desc;
#ifdef LTC_SHA224
#ifndef LTC_SHA256
#error LTC_SHA256 is required for LTC_SHA224
#endif
int sha224_init(hash_state * md);
#define sha224_process sha256_process
int sha224_done(hash_state * md, unsigned char *hash);
int sha224_test(void);
extern const struct ltc_hash_descriptor sha224_desc;
#endif
#endif
#ifdef LTC_SHA1
int sha1_init(hash_state * md);
int sha1_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int sha1_done(hash_state * md, unsigned char *hash);
int sha1_test(void);
extern const struct ltc_hash_descriptor sha1_desc;
#endif
#ifdef LTC_BLAKE2S
extern const struct ltc_hash_descriptor blake2s_256_desc;
int blake2s_256_init(hash_state * md);
int blake2s_256_test(void);
extern const struct ltc_hash_descriptor blake2s_224_desc;
int blake2s_224_init(hash_state * md);
int blake2s_224_test(void);
extern const struct ltc_hash_descriptor blake2s_160_desc;
int blake2s_160_init(hash_state * md);
int blake2s_160_test(void);
extern const struct ltc_hash_descriptor blake2s_128_desc;
int blake2s_128_init(hash_state * md);
int blake2s_128_test(void);
int blake2s_init(hash_state * md, unsigned long outlen, const unsigned char *key, unsigned long keylen);
int blake2s_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int blake2s_done(hash_state * md, unsigned char *hash);
#endif
#ifdef LTC_BLAKE2B
extern const struct ltc_hash_descriptor blake2b_512_desc;
int blake2b_512_init(hash_state * md);
int blake2b_512_test(void);
extern const struct ltc_hash_descriptor blake2b_384_desc;
int blake2b_384_init(hash_state * md);
int blake2b_384_test(void);
extern const struct ltc_hash_descriptor blake2b_256_desc;
int blake2b_256_init(hash_state * md);
int blake2b_256_test(void);
extern const struct ltc_hash_descriptor blake2b_160_desc;
int blake2b_160_init(hash_state * md);
int blake2b_160_test(void);
int blake2b_init(hash_state * md, unsigned long outlen, const unsigned char *key, unsigned long keylen);
int blake2b_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int blake2b_done(hash_state * md, unsigned char *hash);
#endif
#ifdef LTC_MD5
int md5_init(hash_state * md);
int md5_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int md5_done(hash_state * md, unsigned char *hash);
int md5_test(void);
extern const struct ltc_hash_descriptor md5_desc;
#endif
#ifdef LTC_MD4
int md4_init(hash_state * md);
int md4_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int md4_done(hash_state * md, unsigned char *hash);
int md4_test(void);
extern const struct ltc_hash_descriptor md4_desc;
#endif
#ifdef LTC_MD2
int md2_init(hash_state * md);
int md2_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int md2_done(hash_state * md, unsigned char *hash);
int md2_test(void);
extern const struct ltc_hash_descriptor md2_desc;
#endif
#ifdef LTC_TIGER
int tiger_init(hash_state * md);
int tiger_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int tiger_done(hash_state * md, unsigned char *hash);
int tiger_test(void);
extern const struct ltc_hash_descriptor tiger_desc;
#endif
#ifdef LTC_RIPEMD128
int rmd128_init(hash_state * md);
int rmd128_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int rmd128_done(hash_state * md, unsigned char *hash);
int rmd128_test(void);
extern const struct ltc_hash_descriptor rmd128_desc;
#endif
#ifdef LTC_RIPEMD160
int rmd160_init(hash_state * md);
int rmd160_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int rmd160_done(hash_state * md, unsigned char *hash);
int rmd160_test(void);
extern const struct ltc_hash_descriptor rmd160_desc;
#endif
#ifdef LTC_RIPEMD256
int rmd256_init(hash_state * md);
int rmd256_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int rmd256_done(hash_state * md, unsigned char *hash);
int rmd256_test(void);
extern const struct ltc_hash_descriptor rmd256_desc;
#endif
#ifdef LTC_RIPEMD320
int rmd320_init(hash_state * md);
int rmd320_process(hash_state * md, const unsigned char *in, unsigned long inlen);
int rmd320_done(hash_state * md, unsigned char *hash);
int rmd320_test(void);
extern const struct ltc_hash_descriptor rmd320_desc;
#endif
int find_hash(const char *name);
int find_hash_id(unsigned char ID);
int find_hash_oid(const unsigned long *ID, unsigned long IDlen);
int find_hash_any(const char *name, int digestlen);
int register_hash(const struct ltc_hash_descriptor *hash);
int unregister_hash(const struct ltc_hash_descriptor *hash);
int register_all_hashes(void);
int hash_is_valid(int idx);
LTC_MUTEX_PROTO(ltc_hash_mutex)
int hash_memory(int hash,
const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int hash_memory_multi(int hash, unsigned char *out, unsigned long *outlen,
const unsigned char *in, unsigned long inlen, ...);
#ifndef LTC_NO_FILE
int hash_filehandle(int hash, FILE *in, unsigned char *out, unsigned long *outlen);
int hash_file(int hash, const char *fname, unsigned char *out, unsigned long *outlen);
#endif
/* a simple macro for making hash "process" functions */
#define HASH_PROCESS(func_name, compress_name, state_var, block_size) \
int func_name (hash_state * md, const unsigned char *in, unsigned long inlen) \
{ \
unsigned long n; \
int err; \
LTC_ARGCHK(md != NULL); \
LTC_ARGCHK(in != NULL); \
if (md-> state_var .curlen > sizeof(md-> state_var .buf)) { \
return CRYPT_INVALID_ARG; \
} \
if ((md-> state_var .length + inlen) < md-> state_var .length) { \
return CRYPT_HASH_OVERFLOW; \
} \
while (inlen > 0) { \
if (md-> state_var .curlen == 0 && inlen >= block_size) { \
if ((err = compress_name (md, (unsigned char *)in)) != CRYPT_OK) { \
return err; \
} \
md-> state_var .length += block_size * 8; \
in += block_size; \
inlen -= block_size; \
} else { \
n = MIN(inlen, (block_size - md-> state_var .curlen)); \
XMEMCPY(md-> state_var .buf + md-> state_var.curlen, in, (size_t)n); \
md-> state_var .curlen += n; \
in += n; \
inlen -= n; \
if (md-> state_var .curlen == block_size) { \
if ((err = compress_name (md, md-> state_var .buf)) != CRYPT_OK) { \
return err; \
} \
md-> state_var .length += 8*block_size; \
md-> state_var .curlen = 0; \
} \
} \
} \
return CRYPT_OK; \
}
/* ref: HEAD -> master, tag: v1.18.0 */
/* git commit: 0676c9aec7299f5c398d96cbbb64f7e38f67d73f */
/* commit time: 2017-10-10 15:51:36 +0200 */

568
libtom/libtomcrypt/include/tomcrypt_mac.h Normal file
View File

@ -0,0 +1,568 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis
*
* LibTomCrypt is a library that provides various cryptographic
* algorithms in a highly modular and flexible manner.
*
* The library is free for all purposes without any express
* guarantee it works.
*/
#ifdef LTC_HMAC
typedef struct Hmac_state {
hash_state md;
int hash;
hash_state hashstate;
unsigned char *key;
} hmac_state;
int hmac_init(hmac_state *hmac, int hash, const unsigned char *key, unsigned long keylen);
int hmac_process(hmac_state *hmac, const unsigned char *in, unsigned long inlen);
int hmac_done(hmac_state *hmac, unsigned char *out, unsigned long *outlen);
int hmac_test(void);
int hmac_memory(int hash,
const unsigned char *key, unsigned long keylen,
const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int hmac_memory_multi(int hash,
const unsigned char *key, unsigned long keylen,
unsigned char *out, unsigned long *outlen,
const unsigned char *in, unsigned long inlen, ...);
int hmac_file(int hash, const char *fname, const unsigned char *key,
unsigned long keylen,
unsigned char *dst, unsigned long *dstlen);
#endif
#ifdef LTC_OMAC
typedef struct {
int cipher_idx,
buflen,
blklen;
unsigned char block[MAXBLOCKSIZE],
prev[MAXBLOCKSIZE],
Lu[2][MAXBLOCKSIZE];
symmetric_key key;
} omac_state;
int omac_init(omac_state *omac, int cipher, const unsigned char *key, unsigned long keylen);
int omac_process(omac_state *omac, const unsigned char *in, unsigned long inlen);
int omac_done(omac_state *omac, unsigned char *out, unsigned long *outlen);
int omac_memory(int cipher,
const unsigned char *key, unsigned long keylen,
const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int omac_memory_multi(int cipher,
const unsigned char *key, unsigned long keylen,
unsigned char *out, unsigned long *outlen,
const unsigned char *in, unsigned long inlen, ...);
int omac_file(int cipher,
const unsigned char *key, unsigned long keylen,
const char *filename,
unsigned char *out, unsigned long *outlen);
int omac_test(void);
#endif /* LTC_OMAC */
#ifdef LTC_PMAC
typedef struct {
unsigned char Ls[32][MAXBLOCKSIZE], /* L shifted by i bits to the left */
Li[MAXBLOCKSIZE], /* value of Li [current value, we calc from previous recall] */
Lr[MAXBLOCKSIZE], /* L * x^-1 */
block[MAXBLOCKSIZE], /* currently accumulated block */
checksum[MAXBLOCKSIZE]; /* current checksum */
symmetric_key key; /* scheduled key for cipher */
unsigned long block_index; /* index # for current block */
int cipher_idx, /* cipher idx */
block_len, /* length of block */
buflen; /* number of bytes in the buffer */
} pmac_state;
int pmac_init(pmac_state *pmac, int cipher, const unsigned char *key, unsigned long keylen);
int pmac_process(pmac_state *pmac, const unsigned char *in, unsigned long inlen);
int pmac_done(pmac_state *pmac, unsigned char *out, unsigned long *outlen);
int pmac_memory(int cipher,
const unsigned char *key, unsigned long keylen,
const unsigned char *msg, unsigned long msglen,
unsigned char *out, unsigned long *outlen);
int pmac_memory_multi(int cipher,
const unsigned char *key, unsigned long keylen,
unsigned char *out, unsigned long *outlen,
const unsigned char *in, unsigned long inlen, ...);
int pmac_file(int cipher,
const unsigned char *key, unsigned long keylen,
const char *filename,
unsigned char *out, unsigned long *outlen);
int pmac_test(void);
/* internal functions */
int pmac_ntz(unsigned long x);
void pmac_shift_xor(pmac_state *pmac);
#endif /* PMAC */
#ifdef LTC_POLY1305
typedef struct {
ulong32 r[5];
ulong32 h[5];
ulong32 pad[4];
unsigned long leftover;
unsigned char buffer[16];
int final;
} poly1305_state;
int poly1305_init(poly1305_state *st, const unsigned char *key, unsigned long keylen);
int poly1305_process(poly1305_state *st, const unsigned char *in, unsigned long inlen);
int poly1305_done(poly1305_state *st, unsigned char *mac, unsigned long *maclen);
int poly1305_test(void);
int poly1305_memory(const unsigned char *key, unsigned long keylen, const unsigned char *in, unsigned long inlen, unsigned char *mac, unsigned long *maclen);
int poly1305_memory_multi(const unsigned char *key, unsigned long keylen, unsigned char *mac, unsigned long *maclen, const unsigned char *in, unsigned long inlen, ...);
int poly1305_file(const char *fname, const unsigned char *key, unsigned long keylen, unsigned char *mac, unsigned long *maclen);
int poly1305_test(void);
#endif /* LTC_POLY1305 */
#ifdef LTC_BLAKE2SMAC
typedef hash_state blake2smac_state;
int blake2smac_init(blake2smac_state *st, unsigned long outlen, const unsigned char *key, unsigned long keylen);
int blake2smac_process(blake2smac_state *st, const unsigned char *in, unsigned long inlen);
int blake2smac_done(blake2smac_state *st, unsigned char *mac, unsigned long *maclen);
int blake2smac_test(void);
int blake2smac_memory(const unsigned char *key, unsigned long keylen, const unsigned char *in, unsigned long inlen, unsigned char *mac, unsigned long *maclen);
int blake2smac_memory_multi(const unsigned char *key, unsigned long keylen, unsigned char *mac, unsigned long *maclen, const unsigned char *in, unsigned long inlen, ...);
int blake2smac_file(const char *fname, const unsigned char *key, unsigned long keylen, unsigned char *mac, unsigned long *maclen);
int blake2smac_test(void);
#endif /* LTC_BLAKE2SMAC */
#ifdef LTC_BLAKE2BMAC
typedef hash_state blake2bmac_state;
int blake2bmac_init(blake2bmac_state *st, unsigned long outlen, const unsigned char *key, unsigned long keylen);
int blake2bmac_process(blake2bmac_state *st, const unsigned char *in, unsigned long inlen);
int blake2bmac_done(blake2bmac_state *st, unsigned char *mac, unsigned long *maclen);
int blake2bmac_test(void);
int blake2bmac_memory(const unsigned char *key, unsigned long keylen, const unsigned char *in, unsigned long inlen, unsigned char *mac, unsigned long *maclen);
int blake2bmac_memory_multi(const unsigned char *key, unsigned long keylen, unsigned char *mac, unsigned long *maclen, const unsigned char *in, unsigned long inlen, ...);
int blake2bmac_file(const char *fname, const unsigned char *key, unsigned long keylen, unsigned char *mac, unsigned long *maclen);
int blake2bmac_test(void);
#endif /* LTC_BLAKE2BMAC */
#ifdef LTC_EAX_MODE
#if !(defined(LTC_OMAC) && defined(LTC_CTR_MODE))
#error LTC_EAX_MODE requires LTC_OMAC and CTR
#endif
typedef struct {
unsigned char N[MAXBLOCKSIZE];
symmetric_CTR ctr;
omac_state headeromac, ctomac;
} eax_state;
int eax_init(eax_state *eax, int cipher, const unsigned char *key, unsigned long keylen,
const unsigned char *nonce, unsigned long noncelen,
const unsigned char *header, unsigned long headerlen);
int eax_encrypt(eax_state *eax, const unsigned char *pt, unsigned char *ct, unsigned long length);
int eax_decrypt(eax_state *eax, const unsigned char *ct, unsigned char *pt, unsigned long length);
int eax_addheader(eax_state *eax, const unsigned char *header, unsigned long length);
int eax_done(eax_state *eax, unsigned char *tag, unsigned long *taglen);
int eax_encrypt_authenticate_memory(int cipher,
const unsigned char *key, unsigned long keylen,
const unsigned char *nonce, unsigned long noncelen,
const unsigned char *header, unsigned long headerlen,
const unsigned char *pt, unsigned long ptlen,
unsigned char *ct,
unsigned char *tag, unsigned long *taglen);
int eax_decrypt_verify_memory(int cipher,
const unsigned char *key, unsigned long keylen,
const unsigned char *nonce, unsigned long noncelen,
const unsigned char *header, unsigned long headerlen,
const unsigned char *ct, unsigned long ctlen,
unsigned char *pt,
unsigned char *tag, unsigned long taglen,
int *stat);
int eax_test(void);
#endif /* EAX MODE */
#ifdef LTC_OCB_MODE
typedef struct {
unsigned char L[MAXBLOCKSIZE], /* L value */
Ls[32][MAXBLOCKSIZE], /* L shifted by i bits to the left */
Li[MAXBLOCKSIZE], /* value of Li [current value, we calc from previous recall] */
Lr[MAXBLOCKSIZE], /* L * x^-1 */
R[MAXBLOCKSIZE], /* R value */
checksum[MAXBLOCKSIZE]; /* current checksum */
symmetric_key key; /* scheduled key for cipher */
unsigned long block_index; /* index # for current block */
int cipher, /* cipher idx */
block_len; /* length of block */
} ocb_state;
int ocb_init(ocb_state *ocb, int cipher,
const unsigned char *key, unsigned long keylen, const unsigned char *nonce);
int ocb_encrypt(ocb_state *ocb, const unsigned char *pt, unsigned char *ct);
int ocb_decrypt(ocb_state *ocb, const unsigned char *ct, unsigned char *pt);
int ocb_done_encrypt(ocb_state *ocb,
const unsigned char *pt, unsigned long ptlen,
unsigned char *ct,
unsigned char *tag, unsigned long *taglen);
int ocb_done_decrypt(ocb_state *ocb,
const unsigned char *ct, unsigned long ctlen,
unsigned char *pt,
const unsigned char *tag, unsigned long taglen, int *stat);
int ocb_encrypt_authenticate_memory(int cipher,
const unsigned char *key, unsigned long keylen,
const unsigned char *nonce,
const unsigned char *pt, unsigned long ptlen,
unsigned char *ct,
unsigned char *tag, unsigned long *taglen);
int ocb_decrypt_verify_memory(int cipher,
const unsigned char *key, unsigned long keylen,
const unsigned char *nonce,
const unsigned char *ct, unsigned long ctlen,
unsigned char *pt,
const unsigned char *tag, unsigned long taglen,
int *stat);
int ocb_test(void);
/* internal functions */
void ocb_shift_xor(ocb_state *ocb, unsigned char *Z);
int ocb_ntz(unsigned long x);
int s_ocb_done(ocb_state *ocb, const unsigned char *pt, unsigned long ptlen,
unsigned char *ct, unsigned char *tag, unsigned long *taglen, int mode);
#endif /* LTC_OCB_MODE */
#ifdef LTC_OCB3_MODE
typedef struct {
unsigned char Offset_0[MAXBLOCKSIZE], /* Offset_0 value */
Offset_current[MAXBLOCKSIZE], /* Offset_{current_block_index} value */
L_dollar[MAXBLOCKSIZE], /* L_$ value */
L_star[MAXBLOCKSIZE], /* L_* value */
L_[32][MAXBLOCKSIZE], /* L_{i} values */
tag_part[MAXBLOCKSIZE], /* intermediate result of tag calculation */
checksum[MAXBLOCKSIZE]; /* current checksum */
/* AAD related members */
unsigned char aSum_current[MAXBLOCKSIZE], /* AAD related helper variable */
aOffset_current[MAXBLOCKSIZE], /* AAD related helper variable */
adata_buffer[MAXBLOCKSIZE]; /* AAD buffer */
int adata_buffer_bytes; /* bytes in AAD buffer */
unsigned long ablock_index; /* index # for current adata (AAD) block */
symmetric_key key; /* scheduled key for cipher */
unsigned long block_index; /* index # for current data block */
int cipher, /* cipher idx */
tag_len, /* length of tag */
block_len; /* length of block */
} ocb3_state;
int ocb3_init(ocb3_state *ocb, int cipher,
const unsigned char *key, unsigned long keylen,
const unsigned char *nonce, unsigned long noncelen,
unsigned long taglen);
int ocb3_encrypt(ocb3_state *ocb, const unsigned char *pt, unsigned long ptlen, unsigned char *ct);
int ocb3_decrypt(ocb3_state *ocb, const unsigned char *ct, unsigned long ctlen, unsigned char *pt);
int ocb3_encrypt_last(ocb3_state *ocb, const unsigned char *pt, unsigned long ptlen, unsigned char *ct);
int ocb3_decrypt_last(ocb3_state *ocb, const unsigned char *ct, unsigned long ctlen, unsigned char *pt);
int ocb3_add_aad(ocb3_state *ocb, const unsigned char *aad, unsigned long aadlen);
int ocb3_done(ocb3_state *ocb, unsigned char *tag, unsigned long *taglen);
int ocb3_encrypt_authenticate_memory(int cipher,
const unsigned char *key, unsigned long keylen,
const unsigned char *nonce, unsigned long noncelen,
const unsigned char *adata, unsigned long adatalen,
const unsigned char *pt, unsigned long ptlen,
unsigned char *ct,
unsigned char *tag, unsigned long *taglen);
int ocb3_decrypt_verify_memory(int cipher,
const unsigned char *key, unsigned long keylen,
const unsigned char *nonce, unsigned long noncelen,
const unsigned char *adata, unsigned long adatalen,
const unsigned char *ct, unsigned long ctlen,
unsigned char *pt,
const unsigned char *tag, unsigned long taglen,
int *stat);
int ocb3_test(void);
#ifdef LTC_SOURCE
/* internal helper functions */
int ocb3_int_ntz(unsigned long x);
void ocb3_int_xor_blocks(unsigned char *out, const unsigned char *block_a, const unsigned char *block_b, unsigned long block_len);
#endif /* LTC_SOURCE */
#endif /* LTC_OCB3_MODE */
#ifdef LTC_CCM_MODE
#define CCM_ENCRYPT LTC_ENCRYPT
#define CCM_DECRYPT LTC_DECRYPT
typedef struct {
symmetric_key K;
int cipher, /* which cipher */
taglen, /* length of the tag */
x; /* index in PAD */
unsigned long L, /* L value */
ptlen, /* length that will be enc / dec */
current_ptlen, /* current processed length */
aadlen, /* length of the aad */
current_aadlen, /* length of the currently provided add */
noncelen; /* length of the nonce */
unsigned char PAD[16],
ctr[16],
CTRPAD[16],
CTRlen;
} ccm_state;
int ccm_init(ccm_state *ccm, int cipher,
const unsigned char *key, int keylen, int ptlen, int taglen, int aad_len);
int ccm_reset(ccm_state *ccm);
int ccm_add_nonce(ccm_state *ccm,
const unsigned char *nonce, unsigned long noncelen);
int ccm_add_aad(ccm_state *ccm,
const unsigned char *adata, unsigned long adatalen);
int ccm_process(ccm_state *ccm,
unsigned char *pt, unsigned long ptlen,
unsigned char *ct,
int direction);
int ccm_done(ccm_state *ccm,
unsigned char *tag, unsigned long *taglen);
int ccm_memory(int cipher,
const unsigned char *key, unsigned long keylen,
symmetric_key *uskey,
const unsigned char *nonce, unsigned long noncelen,
const unsigned char *header, unsigned long headerlen,
unsigned char *pt, unsigned long ptlen,
unsigned char *ct,
unsigned char *tag, unsigned long *taglen,
int direction);
int ccm_test(void);
#endif /* LTC_CCM_MODE */
#if defined(LRW_MODE) || defined(LTC_GCM_MODE)
void gcm_gf_mult(const unsigned char *a, const unsigned char *b, unsigned char *c);
#endif
/* table shared between GCM and LRW */
#if defined(LTC_GCM_TABLES) || defined(LTC_LRW_TABLES) || ((defined(LTC_GCM_MODE) || defined(LTC_GCM_MODE)) && defined(LTC_FAST))
extern const unsigned char gcm_shift_table[];
#endif
#ifdef LTC_GCM_MODE
#define GCM_ENCRYPT LTC_ENCRYPT
#define GCM_DECRYPT LTC_DECRYPT
#define LTC_GCM_MODE_IV 0
#define LTC_GCM_MODE_AAD 1
#define LTC_GCM_MODE_TEXT 2
typedef struct {
symmetric_key K;
unsigned char H[16], /* multiplier */
X[16], /* accumulator */
Y[16], /* counter */
Y_0[16], /* initial counter */
buf[16]; /* buffer for stuff */
int cipher, /* which cipher */
ivmode, /* Which mode is the IV in? */
mode, /* mode the GCM code is in */
buflen; /* length of data in buf */
ulong64 totlen, /* 64-bit counter used for IV and AAD */
pttotlen; /* 64-bit counter for the PT */
#ifdef LTC_GCM_TABLES
unsigned char PC[16][256][16] /* 16 tables of 8x128 */
#ifdef LTC_GCM_TABLES_SSE2
__attribute__ ((aligned (16)))
#endif
;
#endif
} gcm_state;
void gcm_mult_h(gcm_state *gcm, unsigned char *I);
int gcm_init(gcm_state *gcm, int cipher,
const unsigned char *key, int keylen);
int gcm_reset(gcm_state *gcm);
int gcm_add_iv(gcm_state *gcm,
const unsigned char *IV, unsigned long IVlen);
int gcm_add_aad(gcm_state *gcm,
const unsigned char *adata, unsigned long adatalen);
int gcm_process(gcm_state *gcm,
unsigned char *pt, unsigned long ptlen,
unsigned char *ct,
int direction);
int gcm_done(gcm_state *gcm,
unsigned char *tag, unsigned long *taglen);
int gcm_memory( int cipher,
const unsigned char *key, unsigned long keylen,
const unsigned char *IV, unsigned long IVlen,
const unsigned char *adata, unsigned long adatalen,
unsigned char *pt, unsigned long ptlen,
unsigned char *ct,
unsigned char *tag, unsigned long *taglen,
int direction);
int gcm_test(void);
#endif /* LTC_GCM_MODE */
#ifdef LTC_PELICAN
typedef struct pelican_state
{
symmetric_key K;
unsigned char state[16];
int buflen;
} pelican_state;
int pelican_init(pelican_state *pelmac, const unsigned char *key, unsigned long keylen);
int pelican_process(pelican_state *pelmac, const unsigned char *in, unsigned long inlen);
int pelican_done(pelican_state *pelmac, unsigned char *out);
int pelican_test(void);
int pelican_memory(const unsigned char *key, unsigned long keylen,
const unsigned char *in, unsigned long inlen,
unsigned char *out);
#endif
#ifdef LTC_XCBC
/* add this to "keylen" to xcbc_init to use a pure three-key XCBC MAC */
#define LTC_XCBC_PURE 0x8000UL
typedef struct {
unsigned char K[3][MAXBLOCKSIZE],
IV[MAXBLOCKSIZE];
symmetric_key key;
int cipher,
buflen,
blocksize;
} xcbc_state;
int xcbc_init(xcbc_state *xcbc, int cipher, const unsigned char *key, unsigned long keylen);
int xcbc_process(xcbc_state *xcbc, const unsigned char *in, unsigned long inlen);
int xcbc_done(xcbc_state *xcbc, unsigned char *out, unsigned long *outlen);
int xcbc_memory(int cipher,
const unsigned char *key, unsigned long keylen,
const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int xcbc_memory_multi(int cipher,
const unsigned char *key, unsigned long keylen,
unsigned char *out, unsigned long *outlen,
const unsigned char *in, unsigned long inlen, ...);
int xcbc_file(int cipher,
const unsigned char *key, unsigned long keylen,
const char *filename,
unsigned char *out, unsigned long *outlen);
int xcbc_test(void);
#endif
#ifdef LTC_F9_MODE
typedef struct {
unsigned char akey[MAXBLOCKSIZE],
ACC[MAXBLOCKSIZE],
IV[MAXBLOCKSIZE];
symmetric_key key;
int cipher,
buflen,
keylen,
blocksize;
} f9_state;
int f9_init(f9_state *f9, int cipher, const unsigned char *key, unsigned long keylen);
int f9_process(f9_state *f9, const unsigned char *in, unsigned long inlen);
int f9_done(f9_state *f9, unsigned char *out, unsigned long *outlen);
int f9_memory(int cipher,
const unsigned char *key, unsigned long keylen,
const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int f9_memory_multi(int cipher,
const unsigned char *key, unsigned long keylen,
unsigned char *out, unsigned long *outlen,
const unsigned char *in, unsigned long inlen, ...);
int f9_file(int cipher,
const unsigned char *key, unsigned long keylen,
const char *filename,
unsigned char *out, unsigned long *outlen);
int f9_test(void);
#endif
#ifdef LTC_CHACHA20POLY1305_MODE
typedef struct {
poly1305_state poly;
chacha_state chacha;
ulong64 aadlen;
ulong64 ctlen;
int aadflg;
} chacha20poly1305_state;
#define CHCHA20POLY1305_ENCRYPT LTC_ENCRYPT
#define CHCHA20POLY1305_DECRYPT LTC_DECRYPT
int chacha20poly1305_init(chacha20poly1305_state *st, const unsigned char *key, unsigned long keylen);
int chacha20poly1305_setiv(chacha20poly1305_state *st, const unsigned char *iv, unsigned long ivlen);
int chacha20poly1305_setiv_rfc7905(chacha20poly1305_state *st, const unsigned char *iv, unsigned long ivlen, ulong64 sequence_number);
int chacha20poly1305_add_aad(chacha20poly1305_state *st, const unsigned char *in, unsigned long inlen);
int chacha20poly1305_encrypt(chacha20poly1305_state *st, const unsigned char *in, unsigned long inlen, unsigned char *out);
int chacha20poly1305_decrypt(chacha20poly1305_state *st, const unsigned char *in, unsigned long inlen, unsigned char *out);
int chacha20poly1305_done(chacha20poly1305_state *st, unsigned char *tag, unsigned long *taglen);
int chacha20poly1305_memory(const unsigned char *key, unsigned long keylen,
const unsigned char *iv, unsigned long ivlen,
const unsigned char *aad, unsigned long aadlen,
const unsigned char *in, unsigned long inlen,
unsigned char *out,
unsigned char *tag, unsigned long *taglen,
int direction);
int chacha20poly1305_test(void);
#endif /* LTC_CHACHA20POLY1305_MODE */
/* ref: HEAD -> master, tag: v1.18.0 */
/* git commit: 0676c9aec7299f5c398d96cbbb64f7e38f67d73f */
/* commit time: 2017-10-10 15:51:36 +0200 */

446
libtom/libtomcrypt/include/tomcrypt_macros.h Normal file
View File

@ -0,0 +1,446 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis
*
* LibTomCrypt is a library that provides various cryptographic
* algorithms in a highly modular and flexible manner.
*
* The library is free for all purposes without any express
* guarantee it works.
*/
/* ---- HELPER MACROS ---- */
#ifdef ENDIAN_NEUTRAL
#define STORE32L(x, y) \
do { (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
(y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0)
#define LOAD32L(x, y) \
do { x = ((ulong32)((y)[3] & 255)<<24) | \
((ulong32)((y)[2] & 255)<<16) | \
((ulong32)((y)[1] & 255)<<8) | \
((ulong32)((y)[0] & 255)); } while(0)
#define STORE64L(x, y) \
do { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \
(y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \
(y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
(y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0)
#define LOAD64L(x, y) \
do { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48)| \
(((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32)| \
(((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16)| \
(((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); } while(0)
#define STORE32H(x, y) \
do { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255); \
(y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); } while(0)
#define LOAD32H(x, y) \
do { x = ((ulong32)((y)[0] & 255)<<24) | \
((ulong32)((y)[1] & 255)<<16) | \
((ulong32)((y)[2] & 255)<<8) | \
((ulong32)((y)[3] & 255)); } while(0)
#define STORE64H(x, y) \
do { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \
(y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \
(y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \
(y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); } while(0)
#define LOAD64H(x, y) \
do { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48) | \
(((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32) | \
(((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16) | \
(((ulong64)((y)[6] & 255))<<8)|(((ulong64)((y)[7] & 255))); } while(0)
#elif defined(ENDIAN_LITTLE)
#ifdef LTC_HAVE_BSWAP_BUILTIN
#define STORE32H(x, y) \
do { ulong32 __t = __builtin_bswap32 ((x)); \
XMEMCPY ((y), &__t, 4); } while(0)
#define LOAD32H(x, y) \
do { XMEMCPY (&(x), (y), 4); \
(x) = __builtin_bswap32 ((x)); } while(0)
#elif !defined(LTC_NO_BSWAP) && (defined(INTEL_CC) || (defined(__GNUC__) && (defined(__DJGPP__) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__i386__) || defined(__x86_64__))))
#define STORE32H(x, y) \
asm __volatile__ ( \
"bswapl %0 \n\t" \
"movl %0,(%1)\n\t" \
"bswapl %0 \n\t" \
::"r"(x), "r"(y));
#define LOAD32H(x, y) \
asm __volatile__ ( \
"movl (%1),%0\n\t" \
"bswapl %0\n\t" \
:"=r"(x): "r"(y));
#else
#define STORE32H(x, y) \
do { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255); \
(y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); } while(0)
#define LOAD32H(x, y) \
do { x = ((ulong32)((y)[0] & 255)<<24) | \
((ulong32)((y)[1] & 255)<<16) | \
((ulong32)((y)[2] & 255)<<8) | \
((ulong32)((y)[3] & 255)); } while(0)
#endif
#ifdef LTC_HAVE_BSWAP_BUILTIN
#define STORE64H(x, y) \
do { ulong64 __t = __builtin_bswap64 ((x)); \
XMEMCPY ((y), &__t, 8); } while(0)
#define LOAD64H(x, y) \
do { XMEMCPY (&(x), (y), 8); \
(x) = __builtin_bswap64 ((x)); } while(0)
/* x86_64 processor */
#elif !defined(LTC_NO_BSWAP) && (defined(__GNUC__) && defined(__x86_64__))
#define STORE64H(x, y) \
asm __volatile__ ( \
"bswapq %0 \n\t" \
"movq %0,(%1)\n\t" \
"bswapq %0 \n\t" \
::"r"(x), "r"(y): "memory");
#define LOAD64H(x, y) \
asm __volatile__ ( \
"movq (%1),%0\n\t" \
"bswapq %0\n\t" \
:"=r"(x): "r"(y): "memory");
#else
#define STORE64H(x, y) \
do { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \
(y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \
(y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \
(y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); } while(0)
#define LOAD64H(x, y) \
do { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48) | \
(((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32) | \
(((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16) | \
(((ulong64)((y)[6] & 255))<<8)|(((ulong64)((y)[7] & 255))); } while(0)
#endif
#ifdef ENDIAN_32BITWORD
#define STORE32L(x, y) \
do { ulong32 __t = (x); XMEMCPY(y, &__t, 4); } while(0)
#define LOAD32L(x, y) \
do { XMEMCPY(&(x), y, 4); } while(0)
#define STORE64L(x, y) \
do { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \
(y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \
(y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
(y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0)
#define LOAD64L(x, y) \
do { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48)| \
(((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32)| \
(((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16)| \
(((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); } while(0)
#else /* 64-bit words then */
#define STORE32L(x, y) \
do { ulong32 __t = (x); XMEMCPY(y, &__t, 4); } while(0)
#define LOAD32L(x, y) \
do { XMEMCPY(&(x), y, 4); x &= 0xFFFFFFFF; } while(0)
#define STORE64L(x, y) \
do { ulong64 __t = (x); XMEMCPY(y, &__t, 8); } while(0)
#define LOAD64L(x, y) \
do { XMEMCPY(&(x), y, 8); } while(0)
#endif /* ENDIAN_64BITWORD */
#elif defined(ENDIAN_BIG)
#define STORE32L(x, y) \
do { (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
(y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0)
#define LOAD32L(x, y) \
do { x = ((ulong32)((y)[3] & 255)<<24) | \
((ulong32)((y)[2] & 255)<<16) | \
((ulong32)((y)[1] & 255)<<8) | \
((ulong32)((y)[0] & 255)); } while(0)
#define STORE64L(x, y) \
do { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \
(y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \
(y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \
(y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0)
#define LOAD64L(x, y) \
do { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48) | \
(((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32) | \
(((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16) | \
(((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); } while(0)
#ifdef ENDIAN_32BITWORD
#define STORE32H(x, y) \
do { ulong32 __t = (x); XMEMCPY(y, &__t, 4); } while(0)
#define LOAD32H(x, y) \
do { XMEMCPY(&(x), y, 4); } while(0)
#define STORE64H(x, y) \
do { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \
(y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \
(y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \
(y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); } while(0)
#define LOAD64H(x, y) \
do { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48)| \
(((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32)| \
(((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16)| \
(((ulong64)((y)[6] & 255))<<8)| (((ulong64)((y)[7] & 255))); } while(0)
#else /* 64-bit words then */
#define STORE32H(x, y) \
do { ulong32 __t = (x); XMEMCPY(y, &__t, 4); } while(0)
#define LOAD32H(x, y) \
do { XMEMCPY(&(x), y, 4); x &= 0xFFFFFFFF; } while(0)
#define STORE64H(x, y) \
do { ulong64 __t = (x); XMEMCPY(y, &__t, 8); } while(0)
#define LOAD64H(x, y) \
do { XMEMCPY(&(x), y, 8); } while(0)
#endif /* ENDIAN_64BITWORD */
#endif /* ENDIAN_BIG */
#define BSWAP(x) ( ((x>>24)&0x000000FFUL) | ((x<<24)&0xFF000000UL) | \
((x>>8)&0x0000FF00UL) | ((x<<8)&0x00FF0000UL) )
/* 32-bit Rotates */
#if defined(_MSC_VER)
#define LTC_ROx_ASM
/* instrinsic rotate */
#include <stdlib.h>
#pragma intrinsic(_lrotr,_lrotl)
#define ROR(x,n) _lrotr(x,n)
#define ROL(x,n) _lrotl(x,n)
#define RORc(x,n) _lrotr(x,n)
#define ROLc(x,n) _lrotl(x,n)
#elif !defined(__STRICT_ANSI__) && defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) && !defined(INTEL_CC) && !defined(LTC_NO_ASM)
#define LTC_ROx_ASM
static inline ulong32 ROL(ulong32 word, int i)
{
asm ("roll %%cl,%0"
:"=r" (word)
:"0" (word),"c" (i));
return word;
}
static inline ulong32 ROR(ulong32 word, int i)
{
asm ("rorl %%cl,%0"
:"=r" (word)
:"0" (word),"c" (i));
return word;
}
#ifndef LTC_NO_ROLC
#define ROLc(word,i) ({ \
ulong32 __ROLc_tmp = (word); \
__asm__ ("roll %2, %0" : \
"=r" (__ROLc_tmp) : \
"0" (__ROLc_tmp), \
"I" (i)); \
__ROLc_tmp; \
})
#define RORc(word,i) ({ \
ulong32 __RORc_tmp = (word); \
__asm__ ("rorl %2, %0" : \
"=r" (__RORc_tmp) : \
"0" (__RORc_tmp), \
"I" (i)); \
__RORc_tmp; \
})
#else
#define ROLc ROL
#define RORc ROR
#endif
#elif !defined(__STRICT_ANSI__) && defined(LTC_PPC32)
#define LTC_ROx_ASM
static inline ulong32 ROL(ulong32 word, int i)
{
asm ("rotlw %0,%0,%2"
:"=r" (word)
:"0" (word),"r" (i));
return word;
}
static inline ulong32 ROR(ulong32 word, int i)
{
asm ("rotlw %0,%0,%2"
:"=r" (word)
:"0" (word),"r" (32-i));
return word;
}
#ifndef LTC_NO_ROLC
static inline ulong32 ROLc(ulong32 word, const int i)
{
asm ("rotlwi %0,%0,%2"
:"=r" (word)
:"0" (word),"I" (i));
return word;
}
static inline ulong32 RORc(ulong32 word, const int i)
{
asm ("rotrwi %0,%0,%2"
:"=r" (word)
:"0" (word),"I" (i));
return word;
}
#else
#define ROLc ROL
#define RORc ROR
#endif
#else
/* rotates the hard way */
#define ROL(x, y) ( (((ulong32)(x)<<(ulong32)((y)&31)) | (((ulong32)(x)&0xFFFFFFFFUL)>>(ulong32)((32-((y)&31))&31))) & 0xFFFFFFFFUL)
#define ROR(x, y) ( ((((ulong32)(x)&0xFFFFFFFFUL)>>(ulong32)((y)&31)) | ((ulong32)(x)<<(ulong32)((32-((y)&31))&31))) & 0xFFFFFFFFUL)
#define ROLc(x, y) ( (((ulong32)(x)<<(ulong32)((y)&31)) | (((ulong32)(x)&0xFFFFFFFFUL)>>(ulong32)((32-((y)&31))&31))) & 0xFFFFFFFFUL)
#define RORc(x, y) ( ((((ulong32)(x)&0xFFFFFFFFUL)>>(ulong32)((y)&31)) | ((ulong32)(x)<<(ulong32)((32-((y)&31))&31))) & 0xFFFFFFFFUL)
#endif
/* 64-bit Rotates */
#if !defined(__STRICT_ANSI__) && defined(__GNUC__) && defined(__x86_64__) && !defined(_WIN64) && !defined(LTC_NO_ASM)
static inline ulong64 ROL64(ulong64 word, int i)
{
asm("rolq %%cl,%0"
:"=r" (word)
:"0" (word),"c" (i));
return word;
}
static inline ulong64 ROR64(ulong64 word, int i)
{
asm("rorq %%cl,%0"
:"=r" (word)
:"0" (word),"c" (i));
return word;
}
#ifndef LTC_NO_ROLC
#define ROL64c(word,i) ({ \
ulong64 __ROL64c_tmp = word; \
__asm__ ("rolq %2, %0" : \
"=r" (__ROL64c_tmp) : \
"0" (__ROL64c_tmp), \
"J" (i)); \
__ROL64c_tmp; \
})
#define ROR64c(word,i) ({ \
ulong64 __ROR64c_tmp = word; \
__asm__ ("rorq %2, %0" : \
"=r" (__ROR64c_tmp) : \
"0" (__ROR64c_tmp), \
"J" (i)); \
__ROR64c_tmp; \
})
#else /* LTC_NO_ROLC */
#define ROL64c ROL64
#define ROR64c ROR64
#endif
#else /* Not x86_64 */
#define ROL64(x, y) \
( (((x)<<((ulong64)(y)&63)) | \
(((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>(((ulong64)64-((y)&63))&63))) & CONST64(0xFFFFFFFFFFFFFFFF))
#define ROR64(x, y) \
( ((((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)(y)&CONST64(63))) | \
((x)<<(((ulong64)64-((y)&63))&63))) & CONST64(0xFFFFFFFFFFFFFFFF))
#define ROL64c(x, y) \
( (((x)<<((ulong64)(y)&63)) | \
(((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>(((ulong64)64-((y)&63))&63))) & CONST64(0xFFFFFFFFFFFFFFFF))
#define ROR64c(x, y) \
( ((((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)(y)&CONST64(63))) | \
((x)<<(((ulong64)64-((y)&63))&63))) & CONST64(0xFFFFFFFFFFFFFFFF))
#endif
#ifndef MAX
#define MAX(x, y) ( ((x)>(y))?(x):(y) )
#endif
#ifndef MIN
#define MIN(x, y) ( ((x)<(y))?(x):(y) )
#endif
#ifndef LTC_UNUSED_PARAM
#define LTC_UNUSED_PARAM(x) (void)(x)
#endif
/* extract a byte portably */
#ifdef _MSC_VER
#define byte(x, n) ((unsigned char)((x) >> (8 * (n))))
#else
#define byte(x, n) (((x) >> (8 * (n))) & 255)
#endif
/* there is no snprintf before Visual C++ 2015 */
#if defined(_MSC_VER) && _MSC_VER < 1900
#define snprintf _snprintf
#endif
/* ref: HEAD -> master, tag: v1.18.0 */
/* git commit: 0676c9aec7299f5c398d96cbbb64f7e38f67d73f */
/* commit time: 2017-10-10 15:51:36 +0200 */

585
libtom/libtomcrypt/include/tomcrypt_math.h Normal file
View File

@ -0,0 +1,585 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis
*
* LibTomCrypt is a library that provides various cryptographic
* algorithms in a highly modular and flexible manner.
*
* The library is free for all purposes without any express
* guarantee it works.
*/
/** math functions **/
#pragma comment (lib, "tomcrypt.lib")
#define LTC_MP_LT -1
#define LTC_MP_EQ 0
#define LTC_MP_GT 1
#define LTC_MP_NO 0
#define LTC_MP_YES 1
#ifndef LTC_MECC
typedef void ecc_point;
#endif
#ifndef LTC_MRSA
typedef void rsa_key;
#endif
#ifndef LTC_MILLER_RABIN_REPS
/* Number of rounds of the Miller-Rabin test
* "Reasonable values of reps are between 15 and 50." c.f. gmp doc of mpz_probab_prime_p()
* As of https://security.stackexchange.com/a/4546 we should use 40 rounds */
#define LTC_MILLER_RABIN_REPS 40
#endif
int radix_to_bin(const void *in, int radix, void *out, unsigned long *len);
/** math descriptor */
typedef struct {
/** Name of the math provider */
const char *name;
/** Bits per digit, amount of bits must fit in an unsigned long */
int bits_per_digit;
/* ---- init/deinit functions ---- */
/** initialize a bignum
@param a The number to initialize
@return CRYPT_OK on success
*/
int (*init)(void **a);
/** init copy
@param dst The number to initialize and write to
@param src The number to copy from
@return CRYPT_OK on success
*/
int (*init_copy)(void **dst, void *src);
/** deinit
@param a The number to free
@return CRYPT_OK on success
*/
void (*deinit)(void *a);
/* ---- data movement ---- */
/** negate
@param src The number to negate
@param dst The destination
@return CRYPT_OK on success
*/
int (*neg)(void *src, void *dst);
/** copy
@param src The number to copy from
@param dst The number to write to
@return CRYPT_OK on success
*/
int (*copy)(void *src, void *dst);
/* ---- trivial low level functions ---- */
/** set small constant
@param a Number to write to
@param n Source upto bits_per_digit (actually meant for very small constants)
@return CRYPT_OK on success
*/
int (*set_int)(void *a, ltc_mp_digit n);
/** get small constant
@param a Small number to read,
only fetches up to bits_per_digit from the number
@return The lower bits_per_digit of the integer (unsigned)
*/
unsigned long (*get_int)(void *a);
/** get digit n
@param a The number to read from
@param n The number of the digit to fetch
@return The bits_per_digit sized n'th digit of a
*/
ltc_mp_digit (*get_digit)(void *a, int n);
/** Get the number of digits that represent the number
@param a The number to count
@return The number of digits used to represent the number
*/
int (*get_digit_count)(void *a);
/** compare two integers
@param a The left side integer
@param b The right side integer
@return LTC_MP_LT if a < b,
LTC_MP_GT if a > b and
LTC_MP_EQ otherwise. (signed comparison)
*/
int (*compare)(void *a, void *b);
/** compare against int
@param a The left side integer
@param b The right side integer (upto bits_per_digit)
@return LTC_MP_LT if a < b,
LTC_MP_GT if a > b and
LTC_MP_EQ otherwise. (signed comparison)
*/
int (*compare_d)(void *a, ltc_mp_digit n);
/** Count the number of bits used to represent the integer
@param a The integer to count
@return The number of bits required to represent the integer
*/
int (*count_bits)(void * a);
/** Count the number of LSB bits which are zero
@param a The integer to count
@return The number of contiguous zero LSB bits
*/
int (*count_lsb_bits)(void *a);
/** Compute a power of two
@param a The integer to store the power in
@param n The power of two you want to store (a = 2^n)
@return CRYPT_OK on success
*/
int (*twoexpt)(void *a , int n);
/* ---- radix conversions ---- */
/** read ascii string
@param a The integer to store into
@param str The string to read
@param radix The radix the integer has been represented in (2-64)
@return CRYPT_OK on success
*/
int (*read_radix)(void *a, const char *str, int radix);
/** write number to string
@param a The integer to store
@param str The destination for the string
@param radix The radix the integer is to be represented in (2-64)
@return CRYPT_OK on success
*/
int (*write_radix)(void *a, char *str, int radix);
/** get size as unsigned char string
@param a The integer to get the size (when stored in array of octets)
@return The length of the integer in octets
*/
unsigned long (*unsigned_size)(void *a);
/** store an integer as an array of octets
@param src The integer to store
@param dst The buffer to store the integer in
@return CRYPT_OK on success
*/
int (*unsigned_write)(void *src, unsigned char *dst);
/** read an array of octets and store as integer
@param dst The integer to load
@param src The array of octets
@param len The number of octets
@return CRYPT_OK on success
*/
int (*unsigned_read)( void *dst,
unsigned char *src,
unsigned long len);
/* ---- basic math ---- */
/** add two integers
@param a The first source integer
@param b The second source integer
@param c The destination of "a + b"
@return CRYPT_OK on success
*/
int (*add)(void *a, void *b, void *c);
/** add two integers
@param a The first source integer
@param b The second source integer
(single digit of upto bits_per_digit in length)
@param c The destination of "a + b"
@return CRYPT_OK on success
*/
int (*addi)(void *a, ltc_mp_digit b, void *c);
/** subtract two integers
@param a The first source integer
@param b The second source integer
@param c The destination of "a - b"
@return CRYPT_OK on success
*/
int (*sub)(void *a, void *b, void *c);
/** subtract two integers
@param a The first source integer
@param b The second source integer
(single digit of upto bits_per_digit in length)
@param c The destination of "a - b"
@return CRYPT_OK on success
*/
int (*subi)(void *a, ltc_mp_digit b, void *c);
/** multiply two integers
@param a The first source integer
@param b The second source integer
(single digit of upto bits_per_digit in length)
@param c The destination of "a * b"
@return CRYPT_OK on success
*/
int (*mul)(void *a, void *b, void *c);
/** multiply two integers
@param a The first source integer
@param b The second source integer
(single digit of upto bits_per_digit in length)
@param c The destination of "a * b"
@return CRYPT_OK on success
*/
int (*muli)(void *a, ltc_mp_digit b, void *c);
/** Square an integer
@param a The integer to square
@param b The destination
@return CRYPT_OK on success
*/
int (*sqr)(void *a, void *b);
/** Divide an integer
@param a The dividend
@param b The divisor
@param c The quotient (can be NULL to signify don't care)
@param d The remainder (can be NULL to signify don't care)
@return CRYPT_OK on success
*/
int (*mpdiv)(void *a, void *b, void *c, void *d);
/** divide by two
@param a The integer to divide (shift right)
@param b The destination
@return CRYPT_OK on success
*/
int (*div_2)(void *a, void *b);
/** Get remainder (small value)
@param a The integer to reduce
@param b The modulus (upto bits_per_digit in length)
@param c The destination for the residue
@return CRYPT_OK on success
*/
int (*modi)(void *a, ltc_mp_digit b, ltc_mp_digit *c);
/** gcd
@param a The first integer
@param b The second integer
@param c The destination for (a, b)
@return CRYPT_OK on success
*/
int (*gcd)(void *a, void *b, void *c);
/** lcm
@param a The first integer
@param b The second integer
@param c The destination for [a, b]
@return CRYPT_OK on success
*/
int (*lcm)(void *a, void *b, void *c);
/** Modular multiplication
@param a The first source
@param b The second source
@param c The modulus
@param d The destination (a*b mod c)
@return CRYPT_OK on success
*/
int (*mulmod)(void *a, void *b, void *c, void *d);
/** Modular squaring
@param a The first source
@param b The modulus
@param c The destination (a*a mod b)
@return CRYPT_OK on success
*/
int (*sqrmod)(void *a, void *b, void *c);
/** Modular inversion
@param a The value to invert
@param b The modulus
@param c The destination (1/a mod b)
@return CRYPT_OK on success
*/
int (*invmod)(void *, void *, void *);
/* ---- reduction ---- */
/** setup Montgomery
@param a The modulus
@param b The destination for the reduction digit
@return CRYPT_OK on success
*/
int (*montgomery_setup)(void *a, void **b);
/** get normalization value
@param a The destination for the normalization value
@param b The modulus
@return CRYPT_OK on success
*/
int (*montgomery_normalization)(void *a, void *b);
/** reduce a number
@param a The number [and dest] to reduce
@param b The modulus
@param c The value "b" from montgomery_setup()
@return CRYPT_OK on success
*/
int (*montgomery_reduce)(void *a, void *b, void *c);
/** clean up (frees memory)
@param a The value "b" from montgomery_setup()
@return CRYPT_OK on success
*/
void (*montgomery_deinit)(void *a);
/* ---- exponentiation ---- */
/** Modular exponentiation
@param a The base integer
@param b The power (can be negative) integer
@param c The modulus integer
@param d The destination
@return CRYPT_OK on success
*/
int (*exptmod)(void *a, void *b, void *c, void *d);
/** Primality testing
@param a The integer to test
@param b The number of Miller-Rabin tests that shall be executed
@param c The destination of the result (FP_YES if prime)
@return CRYPT_OK on success
*/
int (*isprime)(void *a, int b, int *c);
/* ---- (optional) ecc point math ---- */
/** ECC GF(p) point multiplication (from the NIST curves)
@param k The integer to multiply the point by
@param G The point to multiply
@param R The destination for kG
@param modulus The modulus for the field
@param map Boolean indicated whether to map back to affine or not
(can be ignored if you work in affine only)
@return CRYPT_OK on success
*/
int (*ecc_ptmul)( void *k,
ecc_point *G,
ecc_point *R,
void *modulus,
int map);
/** ECC GF(p) point addition
@param P The first point
@param Q The second point
@param R The destination of P + Q
@param modulus The modulus
@param mp The "b" value from montgomery_setup()
@return CRYPT_OK on success
*/
int (*ecc_ptadd)(ecc_point *P,
ecc_point *Q,
ecc_point *R,
void *modulus,
void *mp);
/** ECC GF(p) point double
@param P The first point
@param R The destination of 2P
@param modulus The modulus
@param mp The "b" value from montgomery_setup()
@return CRYPT_OK on success
*/
int (*ecc_ptdbl)(ecc_point *P,
ecc_point *R,
void *modulus,
void *mp);
/** ECC mapping from projective to affine,
currently uses (x,y,z) => (x/z^2, y/z^3, 1)
@param P The point to map
@param modulus The modulus
@param mp The "b" value from montgomery_setup()
@return CRYPT_OK on success
@remark The mapping can be different but keep in mind a
ecc_point only has three integers (x,y,z) so if
you use a different mapping you have to make it fit.
*/
int (*ecc_map)(ecc_point *P, void *modulus, void *mp);
/** Computes kA*A + kB*B = C using Shamir's Trick
@param A First point to multiply
@param kA What to multiple A by
@param B Second point to multiply
@param kB What to multiple B by
@param C [out] Destination point (can overlap with A or B)
@param modulus Modulus for curve
@return CRYPT_OK on success
*/
int (*ecc_mul2add)(ecc_point *A, void *kA,
ecc_point *B, void *kB,
ecc_point *C,
void *modulus);
/* ---- (optional) rsa optimized math (for internal CRT) ---- */
/** RSA Key Generation
@param prng An active PRNG state
@param wprng The index of the PRNG desired
@param size The size of the key in octets
@param e The "e" value (public key).
e==65537 is a good choice
@param key [out] Destination of a newly created private key pair
@return CRYPT_OK if successful, upon error all allocated ram is freed
*/
int (*rsa_keygen)(prng_state *prng,
int wprng,
int size,
long e,
rsa_key *key);
/** RSA exponentiation
@param in The octet array representing the base
@param inlen The length of the input
@param out The destination (to be stored in an octet array format)
@param outlen The length of the output buffer and the resulting size
(zero padded to the size of the modulus)
@param which PK_PUBLIC for public RSA and PK_PRIVATE for private RSA
@param key The RSA key to use
@return CRYPT_OK on success
*/
int (*rsa_me)(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen, int which,
rsa_key *key);
/* ---- basic math continued ---- */
/** Modular addition
@param a The first source
@param b The second source
@param c The modulus
@param d The destination (a + b mod c)
@return CRYPT_OK on success
*/
int (*addmod)(void *a, void *b, void *c, void *d);
/** Modular substraction
@param a The first source
@param b The second source
@param c The modulus
@param d The destination (a - b mod c)
@return CRYPT_OK on success
*/
int (*submod)(void *a, void *b, void *c, void *d);
/* ---- misc stuff ---- */
/** Make a pseudo-random mpi
@param a The mpi to make random
@param size The desired length
@return CRYPT_OK on success
*/
int (*rand)(void *a, int size);
} ltc_math_descriptor;
extern ltc_math_descriptor ltc_mp;
int ltc_init_multi(void **a, ...);
void ltc_deinit_multi(void *a, ...);
void ltc_cleanup_multi(void **a, ...);
#ifdef LTM_DESC
extern const ltc_math_descriptor ltm_desc;
#endif
#ifdef TFM_DESC
extern const ltc_math_descriptor tfm_desc;
#endif
#ifdef GMP_DESC
extern const ltc_math_descriptor gmp_desc;
#endif
#if !defined(DESC_DEF_ONLY) && defined(LTC_SOURCE)
#define MP_DIGIT_BIT ltc_mp.bits_per_digit
/* some handy macros */
#define mp_init(a) ltc_mp.init(a)
#define mp_init_multi ltc_init_multi
#define mp_clear(a) ltc_mp.deinit(a)
#define mp_clear_multi ltc_deinit_multi
#define mp_cleanup_multi ltc_cleanup_multi
#define mp_init_copy(a, b) ltc_mp.init_copy(a, b)
#define mp_neg(a, b) ltc_mp.neg(a, b)
#define mp_copy(a, b) ltc_mp.copy(a, b)
#define mp_set(a, b) ltc_mp.set_int(a, b)
#define mp_set_int(a, b) ltc_mp.set_int(a, b)
#define mp_get_int(a) ltc_mp.get_int(a)
#define mp_get_digit(a, n) ltc_mp.get_digit(a, n)
#define mp_get_digit_count(a) ltc_mp.get_digit_count(a)
#define mp_cmp(a, b) ltc_mp.compare(a, b)
#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b)
#define mp_count_bits(a) ltc_mp.count_bits(a)
#define mp_cnt_lsb(a) ltc_mp.count_lsb_bits(a)
#define mp_2expt(a, b) ltc_mp.twoexpt(a, b)
#define mp_read_radix(a, b, c) ltc_mp.read_radix(a, b, c)
#define mp_toradix(a, b, c) ltc_mp.write_radix(a, b, c)
#define mp_unsigned_bin_size(a) ltc_mp.unsigned_size(a)
#define mp_to_unsigned_bin(a, b) ltc_mp.unsigned_write(a, b)
#define mp_read_unsigned_bin(a, b, c) ltc_mp.unsigned_read(a, b, c)
#define mp_add(a, b, c) ltc_mp.add(a, b, c)
#define mp_add_d(a, b, c) ltc_mp.addi(a, b, c)
#define mp_sub(a, b, c) ltc_mp.sub(a, b, c)
#define mp_sub_d(a, b, c) ltc_mp.subi(a, b, c)
#define mp_mul(a, b, c) ltc_mp.mul(a, b, c)
#define mp_mul_d(a, b, c) ltc_mp.muli(a, b, c)
#define mp_sqr(a, b) ltc_mp.sqr(a, b)
#define mp_div(a, b, c, d) ltc_mp.mpdiv(a, b, c, d)
#define mp_div_2(a, b) ltc_mp.div_2(a, b)
#define mp_mod(a, b, c) ltc_mp.mpdiv(a, b, NULL, c)
#define mp_mod_d(a, b, c) ltc_mp.modi(a, b, c)
#define mp_gcd(a, b, c) ltc_mp.gcd(a, b, c)
#define mp_lcm(a, b, c) ltc_mp.lcm(a, b, c)
#define mp_addmod(a, b, c, d) ltc_mp.addmod(a, b, c, d)
#define mp_submod(a, b, c, d) ltc_mp.submod(a, b, c, d)
#define mp_mulmod(a, b, c, d) ltc_mp.mulmod(a, b, c, d)
#define mp_sqrmod(a, b, c) ltc_mp.sqrmod(a, b, c)
#define mp_invmod(a, b, c) ltc_mp.invmod(a, b, c)
#define mp_montgomery_setup(a, b) ltc_mp.montgomery_setup(a, b)
#define mp_montgomery_normalization(a, b) ltc_mp.montgomery_normalization(a, b)
#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c)
#define mp_montgomery_free(a) ltc_mp.montgomery_deinit(a)
#define mp_exptmod(a,b,c,d) ltc_mp.exptmod(a,b,c,d)
#define mp_prime_is_prime(a, b, c) ltc_mp.isprime(a, b, c)
#define mp_iszero(a) (mp_cmp_d(a, 0) == LTC_MP_EQ ? LTC_MP_YES : LTC_MP_NO)
#define mp_isodd(a) (mp_get_digit_count(a) > 0 ? (mp_get_digit(a, 0) & 1 ? LTC_MP_YES : LTC_MP_NO) : LTC_MP_NO)
#define mp_exch(a, b) do { void *ABC__tmp = a; a = b; b = ABC__tmp; } while(0)
#define mp_tohex(a, b) mp_toradix(a, b, 16)
#define mp_rand(a, b) ltc_mp.rand(a, b)
#endif
/* ref: HEAD -> master, tag: v1.18.0 */
/* git commit: 0676c9aec7299f5c398d96cbbb64f7e38f67d73f */
/* commit time: 2017-10-10 15:51:36 +0200 */

113
libtom/libtomcrypt/include/tomcrypt_misc.h Normal file
View File

@ -0,0 +1,113 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis
*
* LibTomCrypt is a library that provides various cryptographic
* algorithms in a highly modular and flexible manner.
*
* The library is free for all purposes without any express
* guarantee it works.
*/
/* ---- LTC_BASE64 Routines ---- */
#ifdef LTC_BASE64
int base64_encode(const unsigned char *in, unsigned long len,
unsigned char *out, unsigned long *outlen);
int base64_decode(const unsigned char *in, unsigned long len,
unsigned char *out, unsigned long *outlen);
int base64_strict_decode(const unsigned char *in, unsigned long len,
unsigned char *out, unsigned long *outlen);
#endif
#ifdef LTC_BASE64_URL
int base64url_encode(const unsigned char *in, unsigned long len,
unsigned char *out, unsigned long *outlen);
int base64url_strict_encode(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int base64url_decode(const unsigned char *in, unsigned long len,
unsigned char *out, unsigned long *outlen);
int base64url_strict_decode(const unsigned char *in, unsigned long len,
unsigned char *out, unsigned long *outlen);
#endif
/* ===> LTC_HKDF -- RFC5869 HMAC-based Key Derivation Function <=== */
#ifdef LTC_HKDF
int hkdf_test(void);
int hkdf_extract(int hash_idx,
const unsigned char *salt, unsigned long saltlen,
const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int hkdf_expand(int hash_idx,
const unsigned char *info, unsigned long infolen,
const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long outlen);
int hkdf(int hash_idx,
const unsigned char *salt, unsigned long saltlen,
const unsigned char *info, unsigned long infolen,
const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long outlen);
#endif /* LTC_HKDF */
/* ---- MEM routines ---- */
int mem_neq(const void *a, const void *b, size_t len);
void zeromem(volatile void *dst, size_t len);
void burn_stack(unsigned long len);
const char *error_to_string(int err);
extern const char *crypt_build_settings;
/* ---- HMM ---- */
int crypt_fsa(void *mp, ...);
/* ---- Dynamic language support ---- */
int crypt_get_constant(const char* namein, int *valueout);
int crypt_list_all_constants(char *names_list, unsigned int *names_list_size);
int crypt_get_size(const char* namein, unsigned int *sizeout);
int crypt_list_all_sizes(char *names_list, unsigned int *names_list_size);
#ifdef LTM_DESC
void init_LTM(void);
#endif
#ifdef TFM_DESC
void init_TFM(void);
#endif
#ifdef GMP_DESC
void init_GMP(void);
#endif
#ifdef LTC_ADLER32
typedef struct adler32_state_s
{
unsigned short s[2];
} adler32_state;
void adler32_init(adler32_state *ctx);
void adler32_update(adler32_state *ctx, const unsigned char *input, unsigned long length);
void adler32_finish(adler32_state *ctx, void *hash, unsigned long size);
int adler32_test(void);
#endif
#ifdef LTC_CRC32
typedef struct crc32_state_s
{
ulong32 crc;
} crc32_state;
void crc32_init(crc32_state *ctx);
void crc32_update(crc32_state *ctx, const unsigned char *input, unsigned long length);
void crc32_finish(crc32_state *ctx, void *hash, unsigned long size);
int crc32_test(void);
#endif
int compare_testvector(const void* is, const unsigned long is_len, const void* should, const unsigned long should_len, const char* what, int which);
/* ref: HEAD -> master, tag: v1.18.0 */
/* git commit: 0676c9aec7299f5c398d96cbbb64f7e38f67d73f */
/* commit time: 2017-10-10 15:51:36 +0200 */

747
libtom/libtomcrypt/include/tomcrypt_pk.h Normal file
View File

@ -0,0 +1,747 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis
*
* LibTomCrypt is a library that provides various cryptographic
* algorithms in a highly modular and flexible manner.
*
* The library is free for all purposes without any express
* guarantee it works.
*/
/* ---- NUMBER THEORY ---- */
enum {
PK_PUBLIC=0,
PK_PRIVATE=1
};
/* Indicates standard output formats that can be read e.g. by OpenSSL or GnuTLS */
#define PK_STD 0x1000
int rand_prime(void *N, long len, prng_state *prng, int wprng);
#ifdef LTC_SOURCE
/* internal helper functions */
int rand_bn_bits(void *N, int bits, prng_state *prng, int wprng);
int rand_bn_upto(void *N, void *limit, prng_state *prng, int wprng);
enum public_key_algorithms {
PKA_RSA,
PKA_DSA
};
typedef struct Oid {
unsigned long OID[16];
/** Length of DER encoding */
unsigned long OIDlen;
} oid_st;
int pk_get_oid(int pk, oid_st *st);
#endif /* LTC_SOURCE */
/* ---- RSA ---- */
#ifdef LTC_MRSA
/** RSA PKCS style key */
typedef struct Rsa_key {
/** Type of key, PK_PRIVATE or PK_PUBLIC */
int type;
/** The public exponent */
void *e;
/** The private exponent */
void *d;
/** The modulus */
void *N;
/** The p factor of N */
void *p;
/** The q factor of N */
void *q;
/** The 1/q mod p CRT param */
void *qP;
/** The d mod (p - 1) CRT param */
void *dP;
/** The d mod (q - 1) CRT param */
void *dQ;
} rsa_key;
int rsa_make_key(prng_state *prng, int wprng, int size, long e, rsa_key *key);
int rsa_get_size(rsa_key *key);
int rsa_exptmod(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen, int which,
rsa_key *key);
void rsa_free(rsa_key *key);
/* These use PKCS #1 v2.0 padding */
#define rsa_encrypt_key(_in, _inlen, _out, _outlen, _lparam, _lparamlen, _prng, _prng_idx, _hash_idx, _key) \
rsa_encrypt_key_ex(_in, _inlen, _out, _outlen, _lparam, _lparamlen, _prng, _prng_idx, _hash_idx, LTC_PKCS_1_OAEP, _key)
#define rsa_decrypt_key(_in, _inlen, _out, _outlen, _lparam, _lparamlen, _hash_idx, _stat, _key) \
rsa_decrypt_key_ex(_in, _inlen, _out, _outlen, _lparam, _lparamlen, _hash_idx, LTC_PKCS_1_OAEP, _stat, _key)
#define rsa_sign_hash(_in, _inlen, _out, _outlen, _prng, _prng_idx, _hash_idx, _saltlen, _key) \
rsa_sign_hash_ex(_in, _inlen, _out, _outlen, LTC_PKCS_1_PSS, _prng, _prng_idx, _hash_idx, _saltlen, _key)
#define rsa_verify_hash(_sig, _siglen, _hash, _hashlen, _hash_idx, _saltlen, _stat, _key) \
rsa_verify_hash_ex(_sig, _siglen, _hash, _hashlen, LTC_PKCS_1_PSS, _hash_idx, _saltlen, _stat, _key)
#define rsa_sign_saltlen_get_max(_hash_idx, _key) \
rsa_sign_saltlen_get_max_ex(LTC_PKCS_1_PSS, _hash_idx, _key)
/* These can be switched between PKCS #1 v2.x and PKCS #1 v1.5 paddings */
int rsa_encrypt_key_ex(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen,
const unsigned char *lparam, unsigned long lparamlen,
prng_state *prng, int prng_idx, int hash_idx, int padding, rsa_key *key);
int rsa_decrypt_key_ex(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen,
const unsigned char *lparam, unsigned long lparamlen,
int hash_idx, int padding,
int *stat, rsa_key *key);
int rsa_sign_hash_ex(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen,
int padding,
prng_state *prng, int prng_idx,
int hash_idx, unsigned long saltlen,
rsa_key *key);
int rsa_verify_hash_ex(const unsigned char *sig, unsigned long siglen,
const unsigned char *hash, unsigned long hashlen,
int padding,
int hash_idx, unsigned long saltlen,
int *stat, rsa_key *key);
int rsa_sign_saltlen_get_max_ex(int padding, int hash_idx, rsa_key *key);
/* PKCS #1 import/export */
int rsa_export(unsigned char *out, unsigned long *outlen, int type, rsa_key *key);
int rsa_import(const unsigned char *in, unsigned long inlen, rsa_key *key);
int rsa_import_x509(const unsigned char *in, unsigned long inlen, rsa_key *key);
int rsa_import_pkcs8(const unsigned char *in, unsigned long inlen,
const void *passwd, unsigned long passwdlen, rsa_key *key);
int rsa_set_key(const unsigned char *N, unsigned long Nlen,
const unsigned char *e, unsigned long elen,
const unsigned char *d, unsigned long dlen,
rsa_key *key);
int rsa_set_factors(const unsigned char *p, unsigned long plen,
const unsigned char *q, unsigned long qlen,
rsa_key *key);
int rsa_set_crt_params(const unsigned char *dP, unsigned long dPlen,
const unsigned char *dQ, unsigned long dQlen,
const unsigned char *qP, unsigned long qPlen,
rsa_key *key);
#endif
/* ---- Katja ---- */
#ifdef LTC_MKAT
/* Min and Max KAT key sizes (in bits) */
#define MIN_KAT_SIZE 1024
#define MAX_KAT_SIZE 4096
/** Katja PKCS style key */
typedef struct KAT_key {
/** Type of key, PK_PRIVATE or PK_PUBLIC */
int type;
/** The private exponent */
void *d;
/** The modulus */
void *N;
/** The p factor of N */
void *p;
/** The q factor of N */
void *q;
/** The 1/q mod p CRT param */
void *qP;
/** The d mod (p - 1) CRT param */
void *dP;
/** The d mod (q - 1) CRT param */
void *dQ;
/** The pq param */
void *pq;
} katja_key;
int katja_make_key(prng_state *prng, int wprng, int size, katja_key *key);
int katja_exptmod(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen, int which,
katja_key *key);
void katja_free(katja_key *key);
/* These use PKCS #1 v2.0 padding */
int katja_encrypt_key(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen,
const unsigned char *lparam, unsigned long lparamlen,
prng_state *prng, int prng_idx, int hash_idx, katja_key *key);
int katja_decrypt_key(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen,
const unsigned char *lparam, unsigned long lparamlen,
int hash_idx, int *stat,
katja_key *key);
/* PKCS #1 import/export */
int katja_export(unsigned char *out, unsigned long *outlen, int type, katja_key *key);
int katja_import(const unsigned char *in, unsigned long inlen, katja_key *key);
#endif
/* ---- DH Routines ---- */
#ifdef LTC_MDH
typedef struct {
int type;
void *x;
void *y;
void *base;
void *prime;
} dh_key;
int dh_get_groupsize(dh_key *key);
int dh_export(unsigned char *out, unsigned long *outlen, int type, dh_key *key);
int dh_import(const unsigned char *in, unsigned long inlen, dh_key *key);
int dh_set_pg(const unsigned char *p, unsigned long plen,
const unsigned char *g, unsigned long glen,
dh_key *key);
int dh_set_pg_dhparam(const unsigned char *dhparam, unsigned long dhparamlen, dh_key *key);
int dh_set_pg_groupsize(int groupsize, dh_key *key);
int dh_set_key(const unsigned char *in, unsigned long inlen, int type, dh_key *key);
int dh_generate_key(prng_state *prng, int wprng, dh_key *key);
int dh_shared_secret(dh_key *private_key, dh_key *public_key,
unsigned char *out, unsigned long *outlen);
void dh_free(dh_key *key);
int dh_export_key(void *out, unsigned long *outlen, int type, dh_key *key);
#ifdef LTC_SOURCE
typedef struct {
int size;
const char *name, *base, *prime;
} ltc_dh_set_type;
extern const ltc_dh_set_type ltc_dh_sets[];
/* internal helper functions */
int dh_check_pubkey(dh_key *key);
#endif
#endif /* LTC_MDH */
/* ---- ECC Routines ---- */
#ifdef LTC_MECC
/* size of our temp buffers for exported keys */
#define ECC_BUF_SIZE 256
/* max private key size */
#define ECC_MAXSIZE 66
/** Structure defines a NIST GF(p) curve */
typedef struct {
/** The size of the curve in octets */
int size;
/** name of curve */
const char *name;
/** The prime that defines the field the curve is in (encoded in hex) */
const char *prime;
/** The fields B param (hex) */
const char *B;
/** The order of the curve (hex) */
const char *order;
/** The x co-ordinate of the base point on the curve (hex) */
const char *Gx;
/** The y co-ordinate of the base point on the curve (hex) */
const char *Gy;
} ltc_ecc_set_type;
/** A point on a ECC curve, stored in Jacbobian format such that (x,y,z) => (x/z^2, y/z^3, 1) when interpretted as affine */
typedef struct {
/** The x co-ordinate */
void *x;
/** The y co-ordinate */
void *y;
/** The z co-ordinate */
void *z;
} ecc_point;
/** An ECC key */
typedef struct {
/** Type of key, PK_PRIVATE or PK_PUBLIC */
int type;
/** Index into the ltc_ecc_sets[] for the parameters of this curve; if -1, then this key is using user supplied curve in dp */
int idx;
/** pointer to domain parameters; either points to NIST curves (identified by idx >= 0) or user supplied curve */
const ltc_ecc_set_type *dp;
/** The public key */
ecc_point pubkey;
/** The private key */
void *k;
} ecc_key;
/** the ECC params provided */
extern const ltc_ecc_set_type ltc_ecc_sets[];
int ecc_test(void);
void ecc_sizes(int *low, int *high);
int ecc_get_size(ecc_key *key);
int ecc_make_key(prng_state *prng, int wprng, int keysize, ecc_key *key);
int ecc_make_key_ex(prng_state *prng, int wprng, ecc_key *key, const ltc_ecc_set_type *dp);
void ecc_free(ecc_key *key);
int ecc_export(unsigned char *out, unsigned long *outlen, int type, ecc_key *key);
int ecc_import(const unsigned char *in, unsigned long inlen, ecc_key *key);
int ecc_import_ex(const unsigned char *in, unsigned long inlen, ecc_key *key, const ltc_ecc_set_type *dp);
int ecc_ansi_x963_export(ecc_key *key, unsigned char *out, unsigned long *outlen);
int ecc_ansi_x963_import(const unsigned char *in, unsigned long inlen, ecc_key *key);
int ecc_ansi_x963_import_ex(const unsigned char *in, unsigned long inlen, ecc_key *key, ltc_ecc_set_type *dp);
int ecc_shared_secret(ecc_key *private_key, ecc_key *public_key,
unsigned char *out, unsigned long *outlen);
int ecc_encrypt_key(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen,
prng_state *prng, int wprng, int hash,
ecc_key *key);
int ecc_decrypt_key(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen,
ecc_key *key);
int ecc_sign_hash_rfc7518(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen,
prng_state *prng, int wprng, ecc_key *key);
int ecc_sign_hash(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen,
prng_state *prng, int wprng, ecc_key *key);
int ecc_verify_hash_rfc7518(const unsigned char *sig, unsigned long siglen,
const unsigned char *hash, unsigned long hashlen,
int *stat, ecc_key *key);
int ecc_verify_hash(const unsigned char *sig, unsigned long siglen,
const unsigned char *hash, unsigned long hashlen,
int *stat, ecc_key *key);
/* low level functions */
ecc_point *ltc_ecc_new_point(void);
void ltc_ecc_del_point(ecc_point *p);
int ltc_ecc_is_valid_idx(int n);
/* point ops (mp == montgomery digit) */
#if !defined(LTC_MECC_ACCEL) || defined(LTM_DESC) || defined(GMP_DESC)
/* R = 2P */
int ltc_ecc_projective_dbl_point(ecc_point *P, ecc_point *R, void *modulus, void *mp);
/* R = P + Q */
int ltc_ecc_projective_add_point(ecc_point *P, ecc_point *Q, ecc_point *R, void *modulus, void *mp);
#endif
#if defined(LTC_MECC_FP)
/* optimized point multiplication using fixed point cache (HAC algorithm 14.117) */
int ltc_ecc_fp_mulmod(void *k, ecc_point *G, ecc_point *R, void *modulus, int map);
/* functions for saving/loading/freeing/adding to fixed point cache */
int ltc_ecc_fp_save_state(unsigned char **out, unsigned long *outlen);
int ltc_ecc_fp_restore_state(unsigned char *in, unsigned long inlen);
void ltc_ecc_fp_free(void);
int ltc_ecc_fp_add_point(ecc_point *g, void *modulus, int lock);
/* lock/unlock all points currently in fixed point cache */
void ltc_ecc_fp_tablelock(int lock);
#endif
/* R = kG */
int ltc_ecc_mulmod(void *k, ecc_point *G, ecc_point *R, void *modulus, int map);
#ifdef LTC_ECC_SHAMIR
/* kA*A + kB*B = C */
int ltc_ecc_mul2add(ecc_point *A, void *kA,
ecc_point *B, void *kB,
ecc_point *C,
void *modulus);
#ifdef LTC_MECC_FP
/* Shamir's trick with optimized point multiplication using fixed point cache */
int ltc_ecc_fp_mul2add(ecc_point *A, void *kA,
ecc_point *B, void *kB,
ecc_point *C, void *modulus);
#endif
#endif
/* map P to affine from projective */
int ltc_ecc_map(ecc_point *P, void *modulus, void *mp);
#endif
#ifdef LTC_MDSA
/* Max diff between group and modulus size in bytes */
#define LTC_MDSA_DELTA 512
/* Max DSA group size in bytes (default allows 4k-bit groups) */
#define LTC_MDSA_MAX_GROUP 512
/** DSA key structure */
typedef struct {
/** The key type, PK_PRIVATE or PK_PUBLIC */
int type;
/** The order of the sub-group used in octets */
int qord;
/** The generator */
void *g;
/** The prime used to generate the sub-group */
void *q;
/** The large prime that generats the field the contains the sub-group */
void *p;
/** The private key */
void *x;
/** The public key */
void *y;
} dsa_key;
int dsa_make_key(prng_state *prng, int wprng, int group_size, int modulus_size, dsa_key *key);
int dsa_set_pqg(const unsigned char *p, unsigned long plen,
const unsigned char *q, unsigned long qlen,
const unsigned char *g, unsigned long glen,
dsa_key *key);
int dsa_set_pqg_dsaparam(const unsigned char *dsaparam, unsigned long dsaparamlen, dsa_key *key);
int dsa_generate_pqg(prng_state *prng, int wprng, int group_size, int modulus_size, dsa_key *key);
int dsa_set_key(const unsigned char *in, unsigned long inlen, int type, dsa_key *key);
int dsa_generate_key(prng_state *prng, int wprng, dsa_key *key);
void dsa_free(dsa_key *key);
int dsa_sign_hash_raw(const unsigned char *in, unsigned long inlen,
void *r, void *s,
prng_state *prng, int wprng, dsa_key *key);
int dsa_sign_hash(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen,
prng_state *prng, int wprng, dsa_key *key);
int dsa_verify_hash_raw( void *r, void *s,
const unsigned char *hash, unsigned long hashlen,
int *stat, dsa_key *key);
int dsa_verify_hash(const unsigned char *sig, unsigned long siglen,
const unsigned char *hash, unsigned long hashlen,
int *stat, dsa_key *key);
int dsa_encrypt_key(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen,
prng_state *prng, int wprng, int hash,
dsa_key *key);
int dsa_decrypt_key(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen,
dsa_key *key);
int dsa_import(const unsigned char *in, unsigned long inlen, dsa_key *key);
int dsa_export(unsigned char *out, unsigned long *outlen, int type, dsa_key *key);
int dsa_verify_key(dsa_key *key, int *stat);
#ifdef LTC_SOURCE
/* internal helper functions */
int dsa_int_validate_xy(dsa_key *key, int *stat);
int dsa_int_validate_pqg(dsa_key *key, int *stat);
int dsa_int_validate_primes(dsa_key *key, int *stat);
#endif
int dsa_shared_secret(void *private_key, void *base,
dsa_key *public_key,
unsigned char *out, unsigned long *outlen);
#endif
#ifdef LTC_DER
/* DER handling */
typedef enum ltc_asn1_type_ {
/* 0 */
LTC_ASN1_EOL,
LTC_ASN1_BOOLEAN,
LTC_ASN1_INTEGER,
LTC_ASN1_SHORT_INTEGER,
LTC_ASN1_BIT_STRING,
/* 5 */
LTC_ASN1_OCTET_STRING,
LTC_ASN1_NULL,
LTC_ASN1_OBJECT_IDENTIFIER,
LTC_ASN1_IA5_STRING,
LTC_ASN1_PRINTABLE_STRING,
/* 10 */
LTC_ASN1_UTF8_STRING,
LTC_ASN1_UTCTIME,
LTC_ASN1_CHOICE,
LTC_ASN1_SEQUENCE,
LTC_ASN1_SET,
/* 15 */
LTC_ASN1_SETOF,
LTC_ASN1_RAW_BIT_STRING,
LTC_ASN1_TELETEX_STRING,
LTC_ASN1_CONSTRUCTED,
LTC_ASN1_CONTEXT_SPECIFIC,
/* 20 */
LTC_ASN1_GENERALIZEDTIME,
} ltc_asn1_type;
/** A LTC ASN.1 list type */
typedef struct ltc_asn1_list_ {
/** The LTC ASN.1 enumerated type identifier */
ltc_asn1_type type;
/** The data to encode or place for decoding */
void *data;
/** The size of the input or resulting output */
unsigned long size;
/** The used flag, this is used by the CHOICE ASN.1 type to indicate which choice was made */
int used;
/** prev/next entry in the list */
struct ltc_asn1_list_ *prev, *next, *child, *parent;
} ltc_asn1_list;
#define LTC_SET_ASN1(list, index, Type, Data, Size) \
do { \
int LTC_MACRO_temp = (index); \
ltc_asn1_list *LTC_MACRO_list = (list); \
LTC_MACRO_list[LTC_MACRO_temp].type = (Type); \
LTC_MACRO_list[LTC_MACRO_temp].data = (void*)(Data); \
LTC_MACRO_list[LTC_MACRO_temp].size = (Size); \
LTC_MACRO_list[LTC_MACRO_temp].used = 0; \
} while (0)
/* SEQUENCE */
int der_encode_sequence_ex(ltc_asn1_list *list, unsigned long inlen,
unsigned char *out, unsigned long *outlen, int type_of);
#define der_encode_sequence(list, inlen, out, outlen) der_encode_sequence_ex(list, inlen, out, outlen, LTC_ASN1_SEQUENCE)
int der_decode_sequence_ex(const unsigned char *in, unsigned long inlen,
ltc_asn1_list *list, unsigned long outlen, int ordered);
#define der_decode_sequence(in, inlen, list, outlen) der_decode_sequence_ex(in, inlen, list, outlen, 1)
int der_length_sequence(ltc_asn1_list *list, unsigned long inlen,
unsigned long *outlen);
#ifdef LTC_SOURCE
/* internal helper functions */
int der_length_sequence_ex(ltc_asn1_list *list, unsigned long inlen,
unsigned long *outlen, unsigned long *payloadlen);
/* SUBJECT PUBLIC KEY INFO */
int der_encode_subject_public_key_info(unsigned char *out, unsigned long *outlen,
unsigned int algorithm, void* public_key, unsigned long public_key_len,
unsigned long parameters_type, void* parameters, unsigned long parameters_len);
int der_decode_subject_public_key_info(const unsigned char *in, unsigned long inlen,
unsigned int algorithm, void* public_key, unsigned long* public_key_len,
unsigned long parameters_type, ltc_asn1_list* parameters, unsigned long parameters_len);
#endif /* LTC_SOURCE */
/* SET */
#define der_decode_set(in, inlen, list, outlen) der_decode_sequence_ex(in, inlen, list, outlen, 0)
#define der_length_set der_length_sequence
int der_encode_set(ltc_asn1_list *list, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int der_encode_setof(ltc_asn1_list *list, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
/* VA list handy helpers with triplets of <type, size, data> */
int der_encode_sequence_multi(unsigned char *out, unsigned long *outlen, ...);
int der_decode_sequence_multi(const unsigned char *in, unsigned long inlen, ...);
/* FLEXI DECODER handle unknown list decoder */
int der_decode_sequence_flexi(const unsigned char *in, unsigned long *inlen, ltc_asn1_list **out);
#define der_free_sequence_flexi der_sequence_free
void der_sequence_free(ltc_asn1_list *in);
void der_sequence_shrink(ltc_asn1_list *in);
/* BOOLEAN */
int der_length_boolean(unsigned long *outlen);
int der_encode_boolean(int in,
unsigned char *out, unsigned long *outlen);
int der_decode_boolean(const unsigned char *in, unsigned long inlen,
int *out);
/* INTEGER */
int der_encode_integer(void *num, unsigned char *out, unsigned long *outlen);
int der_decode_integer(const unsigned char *in, unsigned long inlen, void *num);
int der_length_integer(void *num, unsigned long *len);
/* INTEGER -- handy for 0..2^32-1 values */
int der_decode_short_integer(const unsigned char *in, unsigned long inlen, unsigned long *num);
int der_encode_short_integer(unsigned long num, unsigned char *out, unsigned long *outlen);
int der_length_short_integer(unsigned long num, unsigned long *outlen);
/* BIT STRING */
int der_encode_bit_string(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int der_decode_bit_string(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int der_encode_raw_bit_string(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int der_decode_raw_bit_string(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int der_length_bit_string(unsigned long nbits, unsigned long *outlen);
/* OCTET STRING */
int der_encode_octet_string(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int der_decode_octet_string(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int der_length_octet_string(unsigned long noctets, unsigned long *outlen);
/* OBJECT IDENTIFIER */
int der_encode_object_identifier(unsigned long *words, unsigned long nwords,
unsigned char *out, unsigned long *outlen);
int der_decode_object_identifier(const unsigned char *in, unsigned long inlen,
unsigned long *words, unsigned long *outlen);
int der_length_object_identifier(unsigned long *words, unsigned long nwords, unsigned long *outlen);
unsigned long der_object_identifier_bits(unsigned long x);
/* IA5 STRING */
int der_encode_ia5_string(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int der_decode_ia5_string(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int der_length_ia5_string(const unsigned char *octets, unsigned long noctets, unsigned long *outlen);
int der_ia5_char_encode(int c);
int der_ia5_value_decode(int v);
/* TELETEX STRING */
int der_decode_teletex_string(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int der_length_teletex_string(const unsigned char *octets, unsigned long noctets, unsigned long *outlen);
#ifdef LTC_SOURCE
/* internal helper functions */
int der_teletex_char_encode(int c);
int der_teletex_value_decode(int v);
#endif /* LTC_SOURCE */
/* PRINTABLE STRING */
int der_encode_printable_string(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int der_decode_printable_string(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int der_length_printable_string(const unsigned char *octets, unsigned long noctets, unsigned long *outlen);
int der_printable_char_encode(int c);
int der_printable_value_decode(int v);
/* UTF-8 */
#if (defined(SIZE_MAX) || __STDC_VERSION__ >= 199901L || defined(WCHAR_MAX) || defined(__WCHAR_MAX__) || defined(_WCHAR_T) || defined(_WCHAR_T_DEFINED) || defined (__WCHAR_TYPE__)) && !defined(LTC_NO_WCHAR)
#include <wchar.h>
#if defined(__WCHAR_MAX__)
#define LTC_WCHAR_MAX __WCHAR_MAX__
#elif defined(WCHAR_MAX)
#define LTC_WCHAR_MAX WCHAR_MAX
#endif
/* please note that it might happen that LTC_WCHAR_MAX is undefined */
#else
typedef ulong32 wchar_t;
#define LTC_WCHAR_MAX 0xFFFFFFFF
#endif
int der_encode_utf8_string(const wchar_t *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int der_decode_utf8_string(const unsigned char *in, unsigned long inlen,
wchar_t *out, unsigned long *outlen);
unsigned long der_utf8_charsize(const wchar_t c);
#ifdef LTC_SOURCE
/* internal helper functions */
int der_utf8_valid_char(const wchar_t c);
#endif /* LTC_SOURCE */
int der_length_utf8_string(const wchar_t *in, unsigned long noctets, unsigned long *outlen);
/* CHOICE */
int der_decode_choice(const unsigned char *in, unsigned long *inlen,
ltc_asn1_list *list, unsigned long outlen);
/* UTCTime */
typedef struct {
unsigned YY, /* year */
MM, /* month */
DD, /* day */
hh, /* hour */
mm, /* minute */
ss, /* second */
off_dir, /* timezone offset direction 0 == +, 1 == - */
off_hh, /* timezone offset hours */
off_mm; /* timezone offset minutes */
} ltc_utctime;
int der_encode_utctime(ltc_utctime *utctime,
unsigned char *out, unsigned long *outlen);
int der_decode_utctime(const unsigned char *in, unsigned long *inlen,
ltc_utctime *out);
int der_length_utctime(ltc_utctime *utctime, unsigned long *outlen);
/* GeneralizedTime */
typedef struct {
unsigned YYYY, /* year */
MM, /* month */
DD, /* day */
hh, /* hour */
mm, /* minute */
ss, /* second */
fs, /* fractional seconds */
off_dir, /* timezone offset direction 0 == +, 1 == - */
off_hh, /* timezone offset hours */
off_mm; /* timezone offset minutes */
} ltc_generalizedtime;
int der_encode_generalizedtime(ltc_generalizedtime *gtime,
unsigned char *out, unsigned long *outlen);
int der_decode_generalizedtime(const unsigned char *in, unsigned long *inlen,
ltc_generalizedtime *out);
int der_length_generalizedtime(ltc_generalizedtime *gtime, unsigned long *outlen);
#endif
/* ref: HEAD -> master, tag: v1.18.0 */
/* git commit: 0676c9aec7299f5c398d96cbbb64f7e38f67d73f */
/* commit time: 2017-10-10 15:51:36 +0200 */

108
libtom/libtomcrypt/include/tomcrypt_pkcs.h Normal file
View File

@ -0,0 +1,108 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis
*
* LibTomCrypt is a library that provides various cryptographic
* algorithms in a highly modular and flexible manner.
*
* The library is free for all purposes without any express
* guarantee it works.
*/
/* PKCS Header Info */
/* ===> PKCS #1 -- RSA Cryptography <=== */
#ifdef LTC_PKCS_1
enum ltc_pkcs_1_v1_5_blocks
{
LTC_PKCS_1_EMSA = 1, /* Block type 1 (PKCS #1 v1.5 signature padding) */
LTC_PKCS_1_EME = 2 /* Block type 2 (PKCS #1 v1.5 encryption padding) */
};
enum ltc_pkcs_1_paddings
{
LTC_PKCS_1_V1_5 = 1, /* PKCS #1 v1.5 padding (\sa ltc_pkcs_1_v1_5_blocks) */
LTC_PKCS_1_OAEP = 2, /* PKCS #1 v2.0 encryption padding */
LTC_PKCS_1_PSS = 3, /* PKCS #1 v2.1 signature padding */
LTC_PKCS_1_V1_5_NA1 = 4 /* PKCS #1 v1.5 padding - No ASN.1 (\sa ltc_pkcs_1_v1_5_blocks) */
};
int pkcs_1_mgf1( int hash_idx,
const unsigned char *seed, unsigned long seedlen,
unsigned char *mask, unsigned long masklen);
int pkcs_1_i2osp(void *n, unsigned long modulus_len, unsigned char *out);
int pkcs_1_os2ip(void *n, unsigned char *in, unsigned long inlen);
/* *** v1.5 padding */
int pkcs_1_v1_5_encode(const unsigned char *msg,
unsigned long msglen,
int block_type,
unsigned long modulus_bitlen,
prng_state *prng,
int prng_idx,
unsigned char *out,
unsigned long *outlen);
int pkcs_1_v1_5_decode(const unsigned char *msg,
unsigned long msglen,
int block_type,
unsigned long modulus_bitlen,
unsigned char *out,
unsigned long *outlen,
int *is_valid);
/* *** v2.1 padding */
int pkcs_1_oaep_encode(const unsigned char *msg, unsigned long msglen,
const unsigned char *lparam, unsigned long lparamlen,
unsigned long modulus_bitlen, prng_state *prng,
int prng_idx, int hash_idx,
unsigned char *out, unsigned long *outlen);
int pkcs_1_oaep_decode(const unsigned char *msg, unsigned long msglen,
const unsigned char *lparam, unsigned long lparamlen,
unsigned long modulus_bitlen, int hash_idx,
unsigned char *out, unsigned long *outlen,
int *res);
int pkcs_1_pss_encode(const unsigned char *msghash, unsigned long msghashlen,
unsigned long saltlen, prng_state *prng,
int prng_idx, int hash_idx,
unsigned long modulus_bitlen,
unsigned char *out, unsigned long *outlen);
int pkcs_1_pss_decode(const unsigned char *msghash, unsigned long msghashlen,
const unsigned char *sig, unsigned long siglen,
unsigned long saltlen, int hash_idx,
unsigned long modulus_bitlen, int *res);
#endif /* LTC_PKCS_1 */
/* ===> PKCS #5 -- Password Based Cryptography <=== */
#ifdef LTC_PKCS_5
/* Algorithm #1 (PBKDF1) */
int pkcs_5_alg1(const unsigned char *password, unsigned long password_len,
const unsigned char *salt,
int iteration_count, int hash_idx,
unsigned char *out, unsigned long *outlen);
/* Algorithm #1 (PBKDF1) - OpenSSL-compatible variant for arbitrarily-long keys.
Compatible with EVP_BytesToKey() */
int pkcs_5_alg1_openssl(const unsigned char *password,
unsigned long password_len,
const unsigned char *salt,
int iteration_count, int hash_idx,
unsigned char *out, unsigned long *outlen);
/* Algorithm #2 (PBKDF2) */
int pkcs_5_alg2(const unsigned char *password, unsigned long password_len,
const unsigned char *salt, unsigned long salt_len,
int iteration_count, int hash_idx,
unsigned char *out, unsigned long *outlen);
int pkcs_5_test (void);
#endif /* LTC_PKCS_5 */
/* ref: HEAD -> master, tag: v1.18.0 */
/* git commit: 0676c9aec7299f5c398d96cbbb64f7e38f67d73f */
/* commit time: 2017-10-10 15:51:36 +0200 */

457
libtom/libtomcrypt/include/tomcrypt_private.h Normal file
View File

@ -0,0 +1,457 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis
*
* LibTomCrypt is a library that provides various cryptographic
* algorithms in a highly modular and flexible manner.
*
* The library is free for all purposes without any express
* guarantee it works.
*/
#include "tomcrypt.h"
/*
* Internal Macros
*/
#define LTC_PAD_MASK (0xF000U)
/*
* Internal Enums
*/
enum ltc_oid_id {
PKA_RSA,
PKA_DSA,
PKA_EC,
PKA_EC_PRIMEF,
PKA_X25519,
PKA_ED25519,
};
/*
* Internal Types
*/
typedef struct {
int size;
const char *name, *base, *prime;
} ltc_dh_set_type;
typedef int (*fn_kdf_t)(const unsigned char *password, unsigned long password_len,
const unsigned char *salt, unsigned long salt_len,
int iteration_count, int hash_idx,
unsigned char *out, unsigned long *outlen);
typedef struct {
/* KDF */
fn_kdf_t kdf;
/* Hash or HMAC */
const char* h;
/* cipher */
const char* c;
unsigned long keylen;
/* not used for pbkdf2 */
unsigned long blocklen;
} pbes_properties;
typedef struct
{
pbes_properties type;
const void *pwd;
unsigned long pwdlen;
ltc_asn1_list *enc_data;
ltc_asn1_list *salt;
ltc_asn1_list *iv;
unsigned long iterations;
/* only used for RC2 */
unsigned long key_bits;
} pbes_arg;
/*
* Internal functions
*/
/* tomcrypt_cipher.h */
void blowfish_enc(ulong32 *data, unsigned long blocks, const symmetric_key *skey);
int blowfish_expand(const unsigned char *key, int keylen,
const unsigned char *data, int datalen,
symmetric_key *skey);
int blowfish_setup_with_data(const unsigned char *key, int keylen,
const unsigned char *data, int datalen,
symmetric_key *skey);
/* tomcrypt_hash.h */
/* a simple macro for making hash "process" functions */
#define HASH_PROCESS(func_name, compress_name, state_var, block_size) \
int func_name (hash_state * md, const unsigned char *in, unsigned long inlen) \
{ \
unsigned long n; \
int err; \
LTC_ARGCHK(md != NULL); \
LTC_ARGCHK(in != NULL); \
if (md-> state_var .curlen > sizeof(md-> state_var .buf)) { \
return CRYPT_INVALID_ARG; \
} \
if ((md-> state_var .length + inlen) < md-> state_var .length) { \
return CRYPT_HASH_OVERFLOW; \
} \
while (inlen > 0) { \
if (md-> state_var .curlen == 0 && inlen >= block_size) { \
if ((err = compress_name (md, in)) != CRYPT_OK) { \
return err; \
} \
md-> state_var .length += block_size * 8; \
in += block_size; \
inlen -= block_size; \
} else { \
n = MIN(inlen, (block_size - md-> state_var .curlen)); \
XMEMCPY(md-> state_var .buf + md-> state_var.curlen, in, (size_t)n); \
md-> state_var .curlen += n; \
in += n; \
inlen -= n; \
if (md-> state_var .curlen == block_size) { \
if ((err = compress_name (md, md-> state_var .buf)) != CRYPT_OK) { \
return err; \
} \
md-> state_var .length += 8*block_size; \
md-> state_var .curlen = 0; \
} \
} \
} \
return CRYPT_OK; \
}
/* tomcrypt_mac.h */
int ocb3_int_ntz(unsigned long x);
void ocb3_int_xor_blocks(unsigned char *out, const unsigned char *block_a, const unsigned char *block_b, unsigned long block_len);
/* tomcrypt_math.h */
#if !defined(DESC_DEF_ONLY)
#define MP_DIGIT_BIT ltc_mp.bits_per_digit
/* some handy macros */
#define mp_init(a) ltc_mp.init(a)
#define mp_init_multi ltc_init_multi
#define mp_clear(a) ltc_mp.deinit(a)
#define mp_clear_multi ltc_deinit_multi
#define mp_cleanup_multi ltc_cleanup_multi
#define mp_init_copy(a, b) ltc_mp.init_copy(a, b)
#define mp_neg(a, b) ltc_mp.neg(a, b)
#define mp_copy(a, b) ltc_mp.copy(a, b)
#define mp_set(a, b) ltc_mp.set_int(a, b)
#define mp_set_int(a, b) ltc_mp.set_int(a, b)
#define mp_get_int(a) ltc_mp.get_int(a)
#define mp_get_digit(a, n) ltc_mp.get_digit(a, n)
#define mp_get_digit_count(a) ltc_mp.get_digit_count(a)
#define mp_cmp(a, b) ltc_mp.compare(a, b)
#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b)
#define mp_count_bits(a) ltc_mp.count_bits(a)
#define mp_cnt_lsb(a) ltc_mp.count_lsb_bits(a)
#define mp_2expt(a, b) ltc_mp.twoexpt(a, b)
#define mp_read_radix(a, b, c) ltc_mp.read_radix(a, b, c)
#define mp_toradix(a, b, c) ltc_mp.write_radix(a, b, c)
#define mp_unsigned_bin_size(a) ltc_mp.unsigned_size(a)
#define mp_to_unsigned_bin(a, b) ltc_mp.unsigned_write(a, b)
#define mp_read_unsigned_bin(a, b, c) ltc_mp.unsigned_read(a, b, c)
#define mp_add(a, b, c) ltc_mp.add(a, b, c)
#define mp_add_d(a, b, c) ltc_mp.addi(a, b, c)
#define mp_sub(a, b, c) ltc_mp.sub(a, b, c)
#define mp_sub_d(a, b, c) ltc_mp.subi(a, b, c)
#define mp_mul(a, b, c) ltc_mp.mul(a, b, c)
#define mp_mul_d(a, b, c) ltc_mp.muli(a, b, c)
#define mp_sqr(a, b) ltc_mp.sqr(a, b)
#define mp_sqrtmod_prime(a, b, c) ltc_mp.sqrtmod_prime(a, b, c)
#define mp_div(a, b, c, d) ltc_mp.mpdiv(a, b, c, d)
#define mp_div_2(a, b) ltc_mp.div_2(a, b)
#define mp_mod(a, b, c) ltc_mp.mpdiv(a, b, NULL, c)
#define mp_mod_d(a, b, c) ltc_mp.modi(a, b, c)
#define mp_gcd(a, b, c) ltc_mp.gcd(a, b, c)
#define mp_lcm(a, b, c) ltc_mp.lcm(a, b, c)
#define mp_addmod(a, b, c, d) ltc_mp.addmod(a, b, c, d)
#define mp_submod(a, b, c, d) ltc_mp.submod(a, b, c, d)
#define mp_mulmod(a, b, c, d) ltc_mp.mulmod(a, b, c, d)
#define mp_sqrmod(a, b, c) ltc_mp.sqrmod(a, b, c)
#define mp_invmod(a, b, c) ltc_mp.invmod(a, b, c)
#define mp_montgomery_setup(a, b) ltc_mp.montgomery_setup(a, b)
#define mp_montgomery_normalization(a, b) ltc_mp.montgomery_normalization(a, b)
#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c)
#define mp_montgomery_free(a) ltc_mp.montgomery_deinit(a)
#define mp_exptmod(a,b,c,d) ltc_mp.exptmod(a,b,c,d)
#define mp_prime_is_prime(a, b, c) ltc_mp.isprime(a, b, c)
#define mp_iszero(a) (mp_cmp_d(a, 0) == LTC_MP_EQ ? LTC_MP_YES : LTC_MP_NO)
#define mp_isodd(a) (mp_get_digit_count(a) > 0 ? (mp_get_digit(a, 0) & 1 ? LTC_MP_YES : LTC_MP_NO) : LTC_MP_NO)
#define mp_exch(a, b) do { void *ABC__tmp = a; a = b; b = ABC__tmp; } while(0)
#define mp_tohex(a, b) mp_toradix(a, b, 16)
#define mp_rand(a, b) ltc_mp.rand(a, b)
#endif
/* tomcrypt_misc.h */
void copy_or_zeromem(const unsigned char* src, unsigned char* dest, unsigned long len, int coz);
int pbes_decrypt(const pbes_arg *arg, unsigned char *dec_data, unsigned long *dec_size);
int pbes1_extract(const ltc_asn1_list *s, pbes_arg *res);
int pbes2_extract(const ltc_asn1_list *s, pbes_arg *res);
/* tomcrypt_pk.h */
int rand_bn_bits(void *N, int bits, prng_state *prng, int wprng);
int rand_bn_upto(void *N, void *limit, prng_state *prng, int wprng);
int pk_get_oid(enum ltc_oid_id id, const char **st);
int pk_oid_str_to_num(const char *OID, unsigned long *oid, unsigned long *oidlen);
int pk_oid_num_to_str(const unsigned long *oid, unsigned long oidlen, char *OID, unsigned long *outlen);
/* ---- DH Routines ---- */
#ifdef LTC_MRSA
int rsa_init(rsa_key *key);
void rsa_shrink_key(rsa_key *key);
#endif /* LTC_MRSA */
/* ---- DH Routines ---- */
#ifdef LTC_MDH
extern const ltc_dh_set_type ltc_dh_sets[];
int dh_check_pubkey(const dh_key *key);
#endif /* LTC_MDH */
/* ---- ECC Routines ---- */
#ifdef LTC_MECC
int ecc_set_curve_from_mpis(void *a, void *b, void *prime, void *order, void *gx, void *gy, unsigned long cofactor, ecc_key *key);
int ecc_copy_curve(const ecc_key *srckey, ecc_key *key);
int ecc_set_curve_by_size(int size, ecc_key *key);
int ecc_import_subject_public_key_info(const unsigned char *in, unsigned long inlen, ecc_key *key);
#ifdef LTC_SSH
int ecc_ssh_ecdsa_encode_name(char *buffer, unsigned long *buflen, const ecc_key *key);
#endif
/* low level functions */
ecc_point *ltc_ecc_new_point(void);
void ltc_ecc_del_point(ecc_point *p);
int ltc_ecc_set_point_xyz(ltc_mp_digit x, ltc_mp_digit y, ltc_mp_digit z, ecc_point *p);
int ltc_ecc_copy_point(const ecc_point *src, ecc_point *dst);
int ltc_ecc_is_point(const ltc_ecc_dp *dp, void *x, void *y);
int ltc_ecc_is_point_at_infinity(const ecc_point *P, void *modulus, int *retval);
int ltc_ecc_import_point(const unsigned char *in, unsigned long inlen, void *prime, void *a, void *b, void *x, void *y);
int ltc_ecc_export_point(unsigned char *out, unsigned long *outlen, void *x, void *y, unsigned long size, int compressed);
int ltc_ecc_verify_key(const ecc_key *key);
/* point ops (mp == montgomery digit) */
#if !defined(LTC_MECC_ACCEL) || defined(LTM_DESC) || defined(GMP_DESC)
/* R = 2P */
int ltc_ecc_projective_dbl_point(const ecc_point *P, ecc_point *R, void *ma, void *modulus, void *mp);
/* R = P + Q */
int ltc_ecc_projective_add_point(const ecc_point *P, const ecc_point *Q, ecc_point *R, void *ma, void *modulus, void *mp);
#endif
#if defined(LTC_MECC_FP)
/* optimized point multiplication using fixed point cache (HAC algorithm 14.117) */
int ltc_ecc_fp_mulmod(void *k, ecc_point *G, ecc_point *R, void *a, void *modulus, int map);
/* functions for saving/loading/freeing/adding to fixed point cache */
int ltc_ecc_fp_save_state(unsigned char **out, unsigned long *outlen);
int ltc_ecc_fp_restore_state(unsigned char *in, unsigned long inlen);
void ltc_ecc_fp_free(void);
int ltc_ecc_fp_add_point(ecc_point *g, void *modulus, int lock);
/* lock/unlock all points currently in fixed point cache */
void ltc_ecc_fp_tablelock(int lock);
#endif
/* R = kG */
int ltc_ecc_mulmod(void *k, const ecc_point *G, ecc_point *R, void *a, void *modulus, int map);
#ifdef LTC_ECC_SHAMIR
/* kA*A + kB*B = C */
int ltc_ecc_mul2add(const ecc_point *A, void *kA,
const ecc_point *B, void *kB,
ecc_point *C,
void *ma,
void *modulus);
#ifdef LTC_MECC_FP
/* Shamir's trick with optimized point multiplication using fixed point cache */
int ltc_ecc_fp_mul2add(const ecc_point *A, void *kA,
const ecc_point *B, void *kB,
ecc_point *C,
void *ma,
void *modulus);
#endif
#endif
/* map P to affine from projective */
int ltc_ecc_map(ecc_point *P, void *modulus, void *mp);
#endif /* LTC_MECC */
#ifdef LTC_MDSA
int dsa_int_validate_xy(const dsa_key *key, int *stat);
int dsa_int_validate_pqg(const dsa_key *key, int *stat);
int dsa_int_validate_primes(const dsa_key *key, int *stat);
#endif /* LTC_MDSA */
#ifdef LTC_CURVE25519
int tweetnacl_crypto_sign(
unsigned char *sm,unsigned long long *smlen,
const unsigned char *m,unsigned long long mlen,
const unsigned char *sk, const unsigned char *pk);
int tweetnacl_crypto_sign_open(
int *stat,
unsigned char *m,unsigned long long *mlen,
const unsigned char *sm,unsigned long long smlen,
const unsigned char *pk);
int tweetnacl_crypto_sign_keypair(prng_state *prng, int wprng, unsigned char *pk,unsigned char *sk);
int tweetnacl_crypto_sk_to_pk(unsigned char *pk, const unsigned char *sk);
int tweetnacl_crypto_scalarmult(unsigned char *q, const unsigned char *n, const unsigned char *p);
int tweetnacl_crypto_scalarmult_base(unsigned char *q,const unsigned char *n);
typedef int (*sk_to_pk)(unsigned char *pk ,const unsigned char *sk);
int ec25519_import_pkcs8(const unsigned char *in, unsigned long inlen,
const void *pwd, unsigned long pwdlen,
enum ltc_oid_id id, sk_to_pk fp,
curve25519_key *key);
int ec25519_export( unsigned char *out, unsigned long *outlen,
int which,
const curve25519_key *key);
#endif /* LTC_CURVE25519 */
#ifdef LTC_DER
#define LTC_ASN1_IS_TYPE(e, t) (((e) != NULL) && ((e)->type == (t)))
/* DER handling */
int der_decode_custom_type_ex(const unsigned char *in, unsigned long inlen,
ltc_asn1_list *root,
ltc_asn1_list *list, unsigned long outlen, unsigned int flags);
int der_encode_asn1_identifier(const ltc_asn1_list *id, unsigned char *out, unsigned long *outlen);
int der_decode_asn1_identifier(const unsigned char *in, unsigned long *inlen, ltc_asn1_list *id);
int der_length_asn1_identifier(const ltc_asn1_list *id, unsigned long *idlen);
int der_encode_asn1_length(unsigned long len, unsigned char* out, unsigned long* outlen);
int der_decode_asn1_length(const unsigned char *in, unsigned long *inlen, unsigned long *outlen);
int der_length_asn1_length(unsigned long len, unsigned long *outlen);
int der_length_sequence_ex(const ltc_asn1_list *list, unsigned long inlen,
unsigned long *outlen, unsigned long *payloadlen);
extern const ltc_asn1_type der_asn1_tag_to_type_map[];
extern const unsigned long der_asn1_tag_to_type_map_sz;
extern const int der_asn1_type_to_identifier_map[];
extern const unsigned long der_asn1_type_to_identifier_map_sz;
int der_decode_sequence_multi_ex(const unsigned char *in, unsigned long inlen, unsigned int flags, ...);
int der_teletex_char_encode(int c);
int der_teletex_value_decode(int v);
int der_utf8_valid_char(const wchar_t c);
typedef int (*public_key_decode_cb)(const unsigned char *in, unsigned long inlen, void *ctx);
int x509_decode_public_key_from_certificate(const unsigned char *in, unsigned long inlen,
enum ltc_oid_id algorithm, ltc_asn1_type param_type,
ltc_asn1_list* parameters, unsigned long *parameters_len,
public_key_decode_cb callback, void *ctx);
/* SUBJECT PUBLIC KEY INFO */
int x509_encode_subject_public_key_info(unsigned char *out, unsigned long *outlen,
unsigned int algorithm, const void* public_key, unsigned long public_key_len,
ltc_asn1_type parameters_type, ltc_asn1_list* parameters, unsigned long parameters_len);
int x509_decode_subject_public_key_info(const unsigned char *in, unsigned long inlen,
unsigned int algorithm, void* public_key, unsigned long* public_key_len,
ltc_asn1_type parameters_type, ltc_asn1_list* parameters, unsigned long *parameters_len);
int pk_oid_cmp_with_ulong(const char *o1, const unsigned long *o2, unsigned long o2size);
int pk_oid_cmp_with_asn1(const char *o1, const ltc_asn1_list *o2);
#endif /* LTC_DER */
/* tomcrypt_pkcs.h */
#ifdef LTC_PKCS_8
int pkcs8_decode_flexi(const unsigned char *in, unsigned long inlen,
const void *pwd, unsigned long pwdlen,
ltc_asn1_list **decoded_list);
#endif /* LTC_PKCS_8 */
#ifdef LTC_PKCS_12
int pkcs12_utf8_to_utf16(const unsigned char *in, unsigned long inlen,
unsigned char *out, unsigned long *outlen);
int pkcs12_kdf( int hash_id,
const unsigned char *pw, unsigned long pwlen,
const unsigned char *salt, unsigned long saltlen,
unsigned int iterations, unsigned char purpose,
unsigned char *out, unsigned long outlen);
#endif /* LTC_PKCS_12 */
/* tomcrypt_prng.h */
#define _LTC_PRNG_EXPORT(which) \
int which ## _export(unsigned char *out, unsigned long *outlen, prng_state *prng) \
{ \
unsigned long len = which ## _desc.export_size; \
\
LTC_ARGCHK(prng != NULL); \
LTC_ARGCHK(out != NULL); \
LTC_ARGCHK(outlen != NULL); \
\
if (*outlen < len) { \
*outlen = len; \
return CRYPT_BUFFER_OVERFLOW; \
} \
\
if (which ## _read(out, len, prng) != len) { \
return CRYPT_ERROR_READPRNG; \
} \
\
*outlen = len; \
return CRYPT_OK; \
}
/* extract a byte portably */
#ifdef _MSC_VER
#define LTC_BYTE(x, n) ((unsigned char)((x) >> (8 * (n))))
#else
#define LTC_BYTE(x, n) (((x) >> (8 * (n))) & 255)
#endif
/* ref: HEAD -> develop */
/* git commit: 0c30412a669d37451341ec871c08974da2451eca */
/* commit time: 2019-10-21 11:44:04 +0200 */

232
libtom/libtomcrypt/include/tomcrypt_prng.h Normal file
View File

@ -0,0 +1,232 @@
/* LibTomCrypt, modular cryptographic library -- Tom St Denis
*
* LibTomCrypt is a library that provides various cryptographic
* algorithms in a highly modular and flexible manner.
*
* The library is free for all purposes without any express
* guarantee it works.
*/
/* ---- PRNG Stuff ---- */
#ifdef LTC_YARROW
struct yarrow_prng {
int cipher, hash;
unsigned char pool[MAXBLOCKSIZE];
symmetric_CTR ctr;
};
#endif
#ifdef LTC_RC4
struct rc4_prng {
rc4_state s;
};
#endif
#ifdef LTC_CHACHA20_PRNG
struct chacha20_prng {
chacha_state s; /* chacha state */
unsigned char ent[40]; /* entropy buffer */
unsigned long idx; /* entropy counter */
};
#endif
#ifdef LTC_FORTUNA
struct fortuna_prng {
hash_state pool[LTC_FORTUNA_POOLS]; /* the pools */
symmetric_key skey;
unsigned char K[32], /* the current key */
IV[16]; /* IV for CTR mode */
unsigned long pool_idx, /* current pool we will add to */
pool0_len, /* length of 0'th pool */
wd;
ulong64 reset_cnt; /* number of times we have reset */
};
#endif
#ifdef LTC_SOBER128
struct sober128_prng {
sober128_state s; /* sober128 state */
unsigned char ent[40]; /* entropy buffer */
unsigned long idx; /* entropy counter */
};
#endif
typedef struct {
union {
char dummy[1];
#ifdef LTC_YARROW
struct yarrow_prng yarrow;
#endif
#ifdef LTC_RC4
struct rc4_prng rc4;
#endif
#ifdef LTC_CHACHA20_PRNG
struct chacha20_prng chacha;
#endif
#ifdef LTC_FORTUNA
struct fortuna_prng fortuna;
#endif
#ifdef LTC_SOBER128
struct sober128_prng sober128;
#endif
};
short ready; /* ready flag 0-1 */
LTC_MUTEX_TYPE(lock) /* lock */
} prng_state;
/** PRNG descriptor */
extern struct ltc_prng_descriptor {
/** Name of the PRNG */
const char *name;
/** size in bytes of exported state */
int export_size;
/** Start a PRNG state
@param prng [out] The state to initialize
@return CRYPT_OK if successful
*/
int (*start)(prng_state *prng);
/** Add entropy to the PRNG
@param in The entropy
@param inlen Length of the entropy (octets)\
@param prng The PRNG state
@return CRYPT_OK if successful
*/
int (*add_entropy)(const unsigned char *in, unsigned long inlen, prng_state *prng);
/** Ready a PRNG state to read from
@param prng The PRNG state to ready
@return CRYPT_OK if successful
*/
int (*ready)(prng_state *prng);
/** Read from the PRNG
@param out [out] Where to store the data
@param outlen Length of data desired (octets)
@param prng The PRNG state to read from
@return Number of octets read
*/
unsigned long (*read)(unsigned char *out, unsigned long outlen, prng_state *prng);
/** Terminate a PRNG state
@param prng The PRNG state to terminate
@return CRYPT_OK if successful
*/
int (*done)(prng_state *prng);
/** Export a PRNG state
@param out [out] The destination for the state
@param outlen [in/out] The max size and resulting size of the PRNG state
@param prng The PRNG to export
@return CRYPT_OK if successful
*/
int (*pexport)(unsigned char *out, unsigned long *outlen, prng_state *prng);
/** Import a PRNG state
@param in The data to import
@param inlen The length of the data to import (octets)
@param prng The PRNG to initialize/import
@return CRYPT_OK if successful
*/
int (*pimport)(const unsigned char *in, unsigned long inlen, prng_state *prng);
/** Self-test the PRNG
@return CRYPT_OK if successful, CRYPT_NOP if self-testing has been disabled
*/
int (*test)(void);
} prng_descriptor[];
#ifdef LTC_YARROW
int yarrow_start(prng_state *prng);
int yarrow_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng);
int yarrow_ready(prng_state *prng);
unsigned long yarrow_read(unsigned char *out, unsigned long outlen, prng_state *prng);
int yarrow_done(prng_state *prng);
int yarrow_export(unsigned char *out, unsigned long *outlen, prng_state *prng);
int yarrow_import(const unsigned char *in, unsigned long inlen, prng_state *prng);
int yarrow_test(void);
extern const struct ltc_prng_descriptor yarrow_desc;
#endif
#ifdef LTC_FORTUNA
int fortuna_start(prng_state *prng);
int fortuna_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng);
int fortuna_ready(prng_state *prng);
unsigned long fortuna_read(unsigned char *out, unsigned long outlen, prng_state *prng);
int fortuna_done(prng_state *prng);
int fortuna_export(unsigned char *out, unsigned long *outlen, prng_state *prng);
int fortuna_import(const unsigned char *in, unsigned long inlen, prng_state *prng);
int fortuna_test(void);
extern const struct ltc_prng_descriptor fortuna_desc;
#endif
#ifdef LTC_RC4
int rc4_start(prng_state *prng);
int rc4_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng);
int rc4_ready(prng_state *prng);
unsigned long rc4_read(unsigned char *out, unsigned long outlen, prng_state *prng);
int rc4_done(prng_state *prng);
int rc4_export(unsigned char *out, unsigned long *outlen, prng_state *prng);
int rc4_import(const unsigned char *in, unsigned long inlen, prng_state *prng);
int rc4_test(void);
extern const struct ltc_prng_descriptor rc4_desc;
#endif
#ifdef LTC_CHACHA20_PRNG
int chacha20_prng_start(prng_state *prng);
int chacha20_prng_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng);
int chacha20_prng_ready(prng_state *prng);
unsigned long chacha20_prng_read(unsigned char *out, unsigned long outlen, prng_state *prng);
int chacha20_prng_done(prng_state *prng);
int chacha20_prng_export(unsigned char *out, unsigned long *outlen, prng_state *prng);
int chacha20_prng_import(const unsigned char *in, unsigned long inlen, prng_state *prng);
int chacha20_prng_test(void);
extern const struct ltc_prng_descriptor chacha20_prng_desc;
#endif
#ifdef LTC_SPRNG
int sprng_start(prng_state *prng);
int sprng_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng);
int sprng_ready(prng_state *prng);
unsigned long sprng_read(unsigned char *out, unsigned long outlen, prng_state *prng);
int sprng_done(prng_state *prng);
int sprng_export(unsigned char *out, unsigned long *outlen, prng_state *prng);
int sprng_import(const unsigned char *in, unsigned long inlen, prng_state *prng);
int sprng_test(void);
extern const struct ltc_prng_descriptor sprng_desc;
#endif
#ifdef LTC_SOBER128
int sober128_start(prng_state *prng);
int sober128_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng);
int sober128_ready(prng_state *prng);
unsigned long sober128_read(unsigned char *out, unsigned long outlen, prng_state *prng);
int sober128_done(prng_state *prng);
int sober128_export(unsigned char *out, unsigned long *outlen, prng_state *prng);
int sober128_import(const unsigned char *in, unsigned long inlen, prng_state *prng);
int sober128_test(void);
extern const struct ltc_prng_descriptor sober128_desc;
#endif
int find_prng(const char *name);
int register_prng(const struct ltc_prng_descriptor *prng);
int unregister_prng(const struct ltc_prng_descriptor *prng);
int register_all_prngs(void);
int prng_is_valid(int idx);
LTC_MUTEX_PROTO(ltc_prng_mutex)
/* Slow RNG you **might** be able to use to seed a PRNG with. Be careful as this
* might not work on all platforms as planned
*/
unsigned long rng_get_bytes(unsigned char *out,
unsigned long outlen,
void (*callback)(void));
int rng_make_prng(int bits, int wprng, prng_state *prng, void (*callback)(void));
#ifdef LTC_PRNG_ENABLE_LTC_RNG
extern unsigned long (*ltc_rng)(unsigned char *out, unsigned long outlen,
void (*callback)(void));
#endif
/* ref: HEAD -> master, tag: v1.18.0 */
/* git commit: 0676c9aec7299f5c398d96cbbb64f7e38f67d73f */
/* commit time: 2017-10-10 15:51:36 +0200 */

BIN
libtom/libtomcrypt/lib/tomcrypt.lib Normal file
View File

Binary file not shown.

781
libtom/libtommath/include/tommath.h Normal file
View File

@ -0,0 +1,781 @@
/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
#ifndef BN_H_
#define BN_H_
#include <stdint.h>
#include <stddef.h>
#include <limits.h>
#ifdef LTM_NO_FILE
# warning LTM_NO_FILE has been deprecated, use MP_NO_FILE.
# define MP_NO_FILE
#endif
#ifndef MP_NO_FILE
# include <stdio.h>
#endif
#ifdef MP_8BIT
# ifdef _MSC_VER
# pragma message("8-bit (MP_8BIT) support is deprecated and will be dropped completely in the next version.")
# else
# warning "8-bit (MP_8BIT) support is deprecated and will be dropped completely in the next version."
# endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* MS Visual C++ doesn't have a 128bit type for words, so fall back to 32bit MPI's (where words are 64bit) */
#if (defined(_MSC_VER) || defined(__LLP64__) || defined(__e2k__) || defined(__LCC__)) && !defined(MP_64BIT)
# define MP_32BIT
#endif
/* detect 64-bit mode if possible */
#if defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64) || \
defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__) || \
defined(__s390x__) || defined(__arch64__) || defined(__aarch64__) || \
defined(__sparcv9) || defined(__sparc_v9__) || defined(__sparc64__) || \
defined(__ia64) || defined(__ia64__) || defined(__itanium__) || defined(_M_IA64) || \
defined(__LP64__) || defined(_LP64) || defined(__64BIT__)
# if !(defined(MP_64BIT) || defined(MP_32BIT) || defined(MP_16BIT) || defined(MP_8BIT))
# if defined(__GNUC__) && !defined(__hppa)
/* we support 128bit integers only via: __attribute__((mode(TI))) */
# define MP_64BIT
# else
/* otherwise we fall back to MP_32BIT even on 64bit platforms */
# define MP_32BIT
# endif
# endif
#endif
#ifdef MP_DIGIT_BIT
# error Defining MP_DIGIT_BIT is disallowed, use MP_8/16/31/32/64BIT
#endif
/* some default configurations.
*
* A "mp_digit" must be able to hold MP_DIGIT_BIT + 1 bits
* A "mp_word" must be able to hold 2*MP_DIGIT_BIT + 1 bits
*
* At the very least a mp_digit must be able to hold 7 bits
* [any size beyond that is ok provided it doesn't overflow the data type]
*/
#ifdef MP_8BIT
typedef uint8_t mp_digit;
typedef uint16_t private_mp_word;
# define MP_DIGIT_BIT 7
#elif defined(MP_16BIT)
typedef uint16_t mp_digit;
typedef uint32_t private_mp_word;
# define MP_DIGIT_BIT 15
#elif defined(MP_64BIT)
/* for GCC only on supported platforms */
typedef uint64_t mp_digit;
#if defined(__GNUC__)
typedef unsigned long private_mp_word __attribute__((mode(TI)));
#endif
# define MP_DIGIT_BIT 60
#else
typedef uint32_t mp_digit;
typedef uint64_t private_mp_word;
# ifdef MP_31BIT
/*
* This is an extension that uses 31-bit digits.
* Please be aware that not all functions support this size, especially s_mp_mul_digs_fast
* will be reduced to work on small numbers only:
* Up to 8 limbs, 248 bits instead of up to 512 limbs, 15872 bits with MP_28BIT.
*/
# define MP_DIGIT_BIT 31
# else
/* default case is 28-bit digits, defines MP_28BIT as a handy macro to test */
# define MP_DIGIT_BIT 28
# define MP_28BIT
# endif
#endif
/* mp_word is a private type */
#define mp_word MP_DEPRECATED_PRAGMA("mp_word has been made private") private_mp_word
#define MP_SIZEOF_MP_DIGIT (MP_DEPRECATED_PRAGMA("MP_SIZEOF_MP_DIGIT has been deprecated, use sizeof (mp_digit)") sizeof (mp_digit))
#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1))
#define MP_DIGIT_MAX MP_MASK
/* Primality generation flags */
#define MP_PRIME_BBS 0x0001 /* BBS style prime */
#define MP_PRIME_SAFE 0x0002 /* Safe prime (p-1)/2 == prime */
#define MP_PRIME_2MSB_ON 0x0008 /* force 2nd MSB to 1 */
#define LTM_PRIME_BBS (MP_DEPRECATED_PRAGMA("LTM_PRIME_BBS has been deprecated, use MP_PRIME_BBS") MP_PRIME_BBS)
#define LTM_PRIME_SAFE (MP_DEPRECATED_PRAGMA("LTM_PRIME_SAFE has been deprecated, use MP_PRIME_SAFE") MP_PRIME_SAFE)
#define LTM_PRIME_2MSB_ON (MP_DEPRECATED_PRAGMA("LTM_PRIME_2MSB_ON has been deprecated, use MP_PRIME_2MSB_ON") MP_PRIME_2MSB_ON)
#ifdef MP_USE_ENUMS
typedef enum {
MP_ZPOS = 0, /* positive */
MP_NEG = 1 /* negative */
} mp_sign;
typedef enum {
MP_LT = -1, /* less than */
MP_EQ = 0, /* equal */
MP_GT = 1 /* greater than */
} mp_ord;
typedef enum {
MP_NO = 0,
MP_YES = 1
} mp_bool;
typedef enum {
MP_OKAY = 0, /* no error */
MP_ERR = -1, /* unknown error */
MP_MEM = -2, /* out of mem */
MP_VAL = -3, /* invalid input */
MP_ITER = -4, /* maximum iterations reached */
MP_BUF = -5 /* buffer overflow, supplied buffer too small */
} mp_err;
typedef enum {
MP_LSB_FIRST = -1,
MP_MSB_FIRST = 1
} mp_order;
typedef enum {
MP_LITTLE_ENDIAN = -1,
MP_NATIVE_ENDIAN = 0,
MP_BIG_ENDIAN = 1
} mp_endian;
#else
typedef int mp_sign;
#define MP_ZPOS 0 /* positive integer */
#define MP_NEG 1 /* negative */
typedef int mp_ord;
#define MP_LT -1 /* less than */
#define MP_EQ 0 /* equal to */
#define MP_GT 1 /* greater than */
typedef int mp_bool;
#define MP_YES 1
#define MP_NO 0
typedef int mp_err;
#define MP_OKAY 0 /* no error */
#define MP_ERR -1 /* unknown error */
#define MP_MEM -2 /* out of mem */
#define MP_VAL -3 /* invalid input */
#define MP_RANGE (MP_DEPRECATED_PRAGMA("MP_RANGE has been deprecated in favor of MP_VAL") MP_VAL)
#define MP_ITER -4 /* maximum iterations reached */
#define MP_BUF -5 /* buffer overflow, supplied buffer too small */
typedef int mp_order;
#define MP_LSB_FIRST -1
#define MP_MSB_FIRST 1
typedef int mp_endian;
#define MP_LITTLE_ENDIAN -1
#define MP_NATIVE_ENDIAN 0
#define MP_BIG_ENDIAN 1
#endif
/* tunable cutoffs */
#ifndef MP_FIXED_CUTOFFS
extern int
KARATSUBA_MUL_CUTOFF,
KARATSUBA_SQR_CUTOFF,
TOOM_MUL_CUTOFF,
TOOM_SQR_CUTOFF;
#endif
/* define this to use lower memory usage routines (exptmods mostly) */
/* #define MP_LOW_MEM */
/* default precision */
#ifndef MP_PREC
# ifndef MP_LOW_MEM
# define PRIVATE_MP_PREC 32 /* default digits of precision */
# elif defined(MP_8BIT)
# define PRIVATE_MP_PREC 16 /* default digits of precision */
# else
# define PRIVATE_MP_PREC 8 /* default digits of precision */
# endif
# define MP_PREC (MP_DEPRECATED_PRAGMA("MP_PREC is an internal macro") PRIVATE_MP_PREC)
#endif
/* size of comba arrays, should be at least 2 * 2**(BITS_PER_WORD - BITS_PER_DIGIT*2) */
#define PRIVATE_MP_WARRAY (int)(1uLL << (((CHAR_BIT * sizeof(private_mp_word)) - (2 * MP_DIGIT_BIT)) + 1))
#define MP_WARRAY (MP_DEPRECATED_PRAGMA("MP_WARRAY is an internal macro") PRIVATE_MP_WARRAY)
#if defined(__GNUC__) && __GNUC__ >= 4
# define MP_NULL_TERMINATED __attribute__((sentinel))
#else
# define MP_NULL_TERMINATED
#endif
/*
* MP_WUR - warn unused result
* ---------------------------
*
* The result of functions annotated with MP_WUR must be
* checked and cannot be ignored.
*
* Most functions in libtommath return an error code.
* This error code must be checked in order to prevent crashes or invalid
* results.
*
* If you still want to avoid the error checks for quick and dirty programs
* without robustness guarantees, you can `#define MP_WUR` before including
* tommath.h, disabling the warnings.
*/
#ifndef MP_WUR
# if defined(__GNUC__) && __GNUC__ >= 4
# define MP_WUR __attribute__((warn_unused_result))
# else
# define MP_WUR
# endif
#endif
#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 405)
# define MP_DEPRECATED(x) __attribute__((deprecated("replaced by " #x)))
# define PRIVATE_MP_DEPRECATED_PRAGMA(s) _Pragma(#s)
# define MP_DEPRECATED_PRAGMA(s) PRIVATE_MP_DEPRECATED_PRAGMA(GCC warning s)
#elif defined(_MSC_VER) && _MSC_VER >= 1500
# define MP_DEPRECATED(x) __declspec(deprecated("replaced by " #x))
# define MP_DEPRECATED_PRAGMA(s) __pragma(message(s))
#else
# define MP_DEPRECATED(s)
# define MP_DEPRECATED_PRAGMA(s)
#endif
#define DIGIT_BIT (MP_DEPRECATED_PRAGMA("DIGIT_BIT macro is deprecated, MP_DIGIT_BIT instead") MP_DIGIT_BIT)
#define USED(m) (MP_DEPRECATED_PRAGMA("USED macro is deprecated, use z->used instead") (m)->used)
#define DIGIT(m, k) (MP_DEPRECATED_PRAGMA("DIGIT macro is deprecated, use z->dp instead") (m)->dp[(k)])
#define SIGN(m) (MP_DEPRECATED_PRAGMA("SIGN macro is deprecated, use z->sign instead") (m)->sign)
/* the infamous mp_int structure */
typedef struct {
int used, alloc;
mp_sign sign;
mp_digit *dp;
} mp_int;
/* callback for mp_prime_random, should fill dst with random bytes and return how many read [upto len] */
typedef int private_mp_prime_callback(unsigned char *dst, int len, void *dat);
typedef private_mp_prime_callback MP_DEPRECATED(mp_rand_source) ltm_prime_callback;
/* error code to char* string */
const char *mp_error_to_string(mp_err code) MP_WUR;
/* ---> init and deinit bignum functions <--- */
/* init a bignum */
mp_err mp_init(mp_int *a) MP_WUR;
/* free a bignum */
void mp_clear(mp_int *a);
/* init a null terminated series of arguments */
mp_err mp_init_multi(mp_int *mp, ...) MP_NULL_TERMINATED MP_WUR;
/* clear a null terminated series of arguments */
void mp_clear_multi(mp_int *mp, ...) MP_NULL_TERMINATED;
/* exchange two ints */
void mp_exch(mp_int *a, mp_int *b);
/* shrink ram required for a bignum */
mp_err mp_shrink(mp_int *a) MP_WUR;
/* grow an int to a given size */
mp_err mp_grow(mp_int *a, int size) MP_WUR;
/* init to a given number of digits */
mp_err mp_init_size(mp_int *a, int size) MP_WUR;
/* ---> Basic Manipulations <--- */
#define mp_iszero(a) (((a)->used == 0) ? MP_YES : MP_NO)
mp_bool mp_iseven(const mp_int *a) MP_WUR;
mp_bool mp_isodd(const mp_int *a) MP_WUR;
#define mp_isneg(a) (((a)->sign != MP_ZPOS) ? MP_YES : MP_NO)
/* set to zero */
void mp_zero(mp_int *a);
/* get and set doubles */
double mp_get_double(const mp_int *a) MP_WUR;
mp_err mp_set_double(mp_int *a, double b) MP_WUR;
/* get integer, set integer and init with integer (int32_t) */
int32_t mp_get_i32(const mp_int *a) MP_WUR;
void mp_set_i32(mp_int *a, int32_t b);
mp_err mp_init_i32(mp_int *a, int32_t b) MP_WUR;
/* get integer, set integer and init with integer, behaves like two complement for negative numbers (uint32_t) */
#define mp_get_u32(a) ((uint32_t)mp_get_i32(a))
void mp_set_u32(mp_int *a, uint32_t b);
mp_err mp_init_u32(mp_int *a, uint32_t b) MP_WUR;
/* get integer, set integer and init with integer (int64_t) */
int64_t mp_get_i64(const mp_int *a) MP_WUR;
void mp_set_i64(mp_int *a, int64_t b);
mp_err mp_init_i64(mp_int *a, int64_t b) MP_WUR;
/* get integer, set integer and init with integer, behaves like two complement for negative numbers (uint64_t) */
#define mp_get_u64(a) ((uint64_t)mp_get_i64(a))
void mp_set_u64(mp_int *a, uint64_t b);
mp_err mp_init_u64(mp_int *a, uint64_t b) MP_WUR;
/* get magnitude */
uint32_t mp_get_mag_u32(const mp_int *a) MP_WUR;
uint64_t mp_get_mag_u64(const mp_int *a) MP_WUR;
unsigned long mp_get_mag_ul(const mp_int *a) MP_WUR;
unsigned long long mp_get_mag_ull(const mp_int *a) MP_WUR;
/* get integer, set integer (long) */
long mp_get_l(const mp_int *a) MP_WUR;
void mp_set_l(mp_int *a, long b);
mp_err mp_init_l(mp_int *a, long b) MP_WUR;
/* get integer, set integer (unsigned long) */
#define mp_get_ul(a) ((unsigned long)mp_get_l(a))
void mp_set_ul(mp_int *a, unsigned long b);
mp_err mp_init_ul(mp_int *a, unsigned long b) MP_WUR;
/* get integer, set integer (long long) */
long long mp_get_ll(const mp_int *a) MP_WUR;
void mp_set_ll(mp_int *a, long long b);
mp_err mp_init_ll(mp_int *a, long long b) MP_WUR;
/* get integer, set integer (unsigned long long) */
#define mp_get_ull(a) ((unsigned long long)mp_get_ll(a))
void mp_set_ull(mp_int *a, unsigned long long b);
mp_err mp_init_ull(mp_int *a, unsigned long long b) MP_WUR;
/* set to single unsigned digit, up to MP_DIGIT_MAX */
void mp_set(mp_int *a, mp_digit b);
mp_err mp_init_set(mp_int *a, mp_digit b) MP_WUR;
/* get integer, set integer and init with integer (deprecated) */
MP_DEPRECATED(mp_get_mag_u32/mp_get_u32) unsigned long mp_get_int(const mp_int *a) MP_WUR;
MP_DEPRECATED(mp_get_mag_ul/mp_get_ul) unsigned long mp_get_long(const mp_int *a) MP_WUR;
MP_DEPRECATED(mp_get_mag_ull/mp_get_ull) unsigned long long mp_get_long_long(const mp_int *a) MP_WUR;
MP_DEPRECATED(mp_set_ul) mp_err mp_set_int(mp_int *a, unsigned long b);
MP_DEPRECATED(mp_set_ul) mp_err mp_set_long(mp_int *a, unsigned long b);
MP_DEPRECATED(mp_set_ull) mp_err mp_set_long_long(mp_int *a, unsigned long long b);
MP_DEPRECATED(mp_init_ul) mp_err mp_init_set_int(mp_int *a, unsigned long b) MP_WUR;
/* copy, b = a */
mp_err mp_copy(const mp_int *a, mp_int *b) MP_WUR;
/* inits and copies, a = b */
mp_err mp_init_copy(mp_int *a, const mp_int *b) MP_WUR;
/* trim unused digits */
void mp_clamp(mp_int *a);
/* export binary data */
MP_DEPRECATED(mp_pack) mp_err mp_export(void *rop, size_t *countp, int order, size_t size,
int endian, size_t nails, const mp_int *op) MP_WUR;
/* import binary data */
MP_DEPRECATED(mp_unpack) mp_err mp_import(mp_int *rop, size_t count, int order,
size_t size, int endian, size_t nails,
const void *op) MP_WUR;
/* unpack binary data */
mp_err mp_unpack(mp_int *rop, size_t count, mp_order order, size_t size, mp_endian endian,
size_t nails, const void *op) MP_WUR;
/* pack binary data */
size_t mp_pack_count(const mp_int *a, size_t nails, size_t size) MP_WUR;
mp_err mp_pack(void *rop, size_t maxcount, size_t *written, mp_order order, size_t size,
mp_endian endian, size_t nails, const mp_int *op) MP_WUR;
/* ---> digit manipulation <--- */
/* right shift by "b" digits */
void mp_rshd(mp_int *a, int b);
/* left shift by "b" digits */
mp_err mp_lshd(mp_int *a, int b) MP_WUR;
/* c = a / 2**b, implemented as c = a >> b */
mp_err mp_div_2d(const mp_int *a, int b, mp_int *c, mp_int *d) MP_WUR;
/* b = a/2 */
mp_err mp_div_2(const mp_int *a, mp_int *b) MP_WUR;
/* a/3 => 3c + d == a */
mp_err mp_div_3(const mp_int *a, mp_int *c, mp_digit *d) MP_WUR;
/* c = a * 2**b, implemented as c = a << b */
mp_err mp_mul_2d(const mp_int *a, int b, mp_int *c) MP_WUR;
/* b = a*2 */
mp_err mp_mul_2(const mp_int *a, mp_int *b) MP_WUR;
/* c = a mod 2**b */
mp_err mp_mod_2d(const mp_int *a, int b, mp_int *c) MP_WUR;
/* computes a = 2**b */
mp_err mp_2expt(mp_int *a, int b) MP_WUR;
/* Counts the number of lsbs which are zero before the first zero bit */
int mp_cnt_lsb(const mp_int *a) MP_WUR;
/* I Love Earth! */
/* makes a pseudo-random mp_int of a given size */
mp_err mp_rand(mp_int *a, int digits) MP_WUR;
/* makes a pseudo-random small int of a given size */
MP_DEPRECATED(mp_rand) mp_err mp_rand_digit(mp_digit *r) MP_WUR;
/* use custom random data source instead of source provided the platform */
void mp_rand_source(mp_err(*source)(void *out, size_t size));
#ifdef MP_PRNG_ENABLE_LTM_RNG
# warning MP_PRNG_ENABLE_LTM_RNG has been deprecated, use mp_rand_source instead.
/* A last resort to provide random data on systems without any of the other
* implemented ways to gather entropy.
* It is compatible with `rng_get_bytes()` from libtomcrypt so you could
* provide that one and then set `ltm_rng = rng_get_bytes;` */
extern unsigned long (*ltm_rng)(unsigned char *out, unsigned long outlen, void (*callback)(void));
extern void (*ltm_rng_callback)(void);
#endif
/* ---> binary operations <--- */
/* Checks the bit at position b and returns MP_YES
* if the bit is 1, MP_NO if it is 0 and MP_VAL
* in case of error
*/
MP_DEPRECATED(s_mp_get_bit) int mp_get_bit(const mp_int *a, int b) MP_WUR;
/* c = a XOR b (two complement) */
MP_DEPRECATED(mp_xor) mp_err mp_tc_xor(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
mp_err mp_xor(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* c = a OR b (two complement) */
MP_DEPRECATED(mp_or) mp_err mp_tc_or(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
mp_err mp_or(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* c = a AND b (two complement) */
MP_DEPRECATED(mp_and) mp_err mp_tc_and(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
mp_err mp_and(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* b = ~a (bitwise not, two complement) */
mp_err mp_complement(const mp_int *a, mp_int *b) MP_WUR;
/* right shift with sign extension */
MP_DEPRECATED(mp_signed_rsh) mp_err mp_tc_div_2d(const mp_int *a, int b, mp_int *c) MP_WUR;
mp_err mp_signed_rsh(const mp_int *a, int b, mp_int *c) MP_WUR;
/* ---> Basic arithmetic <--- */
/* b = -a */
mp_err mp_neg(const mp_int *a, mp_int *b) MP_WUR;
/* b = |a| */
mp_err mp_abs(const mp_int *a, mp_int *b) MP_WUR;
/* compare a to b */
mp_ord mp_cmp(const mp_int *a, const mp_int *b) MP_WUR;
/* compare |a| to |b| */
mp_ord mp_cmp_mag(const mp_int *a, const mp_int *b) MP_WUR;
/* c = a + b */
mp_err mp_add(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* c = a - b */
mp_err mp_sub(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* c = a * b */
mp_err mp_mul(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* b = a*a */
mp_err mp_sqr(const mp_int *a, mp_int *b) MP_WUR;
/* a/b => cb + d == a */
mp_err mp_div(const mp_int *a, const mp_int *b, mp_int *c, mp_int *d) MP_WUR;
/* c = a mod b, 0 <= c < b */
mp_err mp_mod(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* Increment "a" by one like "a++". Changes input! */
mp_err mp_incr(mp_int *a) MP_WUR;
/* Decrement "a" by one like "a--". Changes input! */
mp_err mp_decr(mp_int *a) MP_WUR;
/* ---> single digit functions <--- */
/* compare against a single digit */
mp_ord mp_cmp_d(const mp_int *a, mp_digit b) MP_WUR;
/* c = a + b */
mp_err mp_add_d(const mp_int *a, mp_digit b, mp_int *c) MP_WUR;
/* c = a - b */
mp_err mp_sub_d(const mp_int *a, mp_digit b, mp_int *c) MP_WUR;
/* c = a * b */
mp_err mp_mul_d(const mp_int *a, mp_digit b, mp_int *c) MP_WUR;
/* a/b => cb + d == a */
mp_err mp_div_d(const mp_int *a, mp_digit b, mp_int *c, mp_digit *d) MP_WUR;
/* c = a mod b, 0 <= c < b */
mp_err mp_mod_d(const mp_int *a, mp_digit b, mp_digit *c) MP_WUR;
/* ---> number theory <--- */
/* d = a + b (mod c) */
mp_err mp_addmod(const mp_int *a, const mp_int *b, const mp_int *c, mp_int *d) MP_WUR;
/* d = a - b (mod c) */
mp_err mp_submod(const mp_int *a, const mp_int *b, const mp_int *c, mp_int *d) MP_WUR;
/* d = a * b (mod c) */
mp_err mp_mulmod(const mp_int *a, const mp_int *b, const mp_int *c, mp_int *d) MP_WUR;
/* c = a * a (mod b) */
mp_err mp_sqrmod(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* c = 1/a (mod b) */
mp_err mp_invmod(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* c = (a, b) */
mp_err mp_gcd(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* produces value such that U1*a + U2*b = U3 */
mp_err mp_exteuclid(const mp_int *a, const mp_int *b, mp_int *U1, mp_int *U2, mp_int *U3) MP_WUR;
/* c = [a, b] or (a*b)/(a, b) */
mp_err mp_lcm(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* finds one of the b'th root of a, such that |c|**b <= |a|
*
* returns error if a < 0 and b is even
*/
mp_err mp_root_u32(const mp_int *a, uint32_t b, mp_int *c) MP_WUR;
MP_DEPRECATED(mp_root_u32) mp_err mp_n_root(const mp_int *a, mp_digit b, mp_int *c) MP_WUR;
MP_DEPRECATED(mp_root_u32) mp_err mp_n_root_ex(const mp_int *a, mp_digit b, mp_int *c, int fast) MP_WUR;
/* special sqrt algo */
mp_err mp_sqrt(const mp_int *arg, mp_int *ret) MP_WUR;
/* special sqrt (mod prime) */
mp_err mp_sqrtmod_prime(const mp_int *n, const mp_int *prime, mp_int *ret) MP_WUR;
/* is number a square? */
mp_err mp_is_square(const mp_int *arg, mp_bool *ret) MP_WUR;
/* computes the jacobi c = (a | n) (or Legendre if b is prime) */
MP_DEPRECATED(mp_kronecker) mp_err mp_jacobi(const mp_int *a, const mp_int *n, int *c) MP_WUR;
/* computes the Kronecker symbol c = (a | p) (like jacobi() but with {a,p} in Z */
mp_err mp_kronecker(const mp_int *a, const mp_int *p, int *c) MP_WUR;
/* used to setup the Barrett reduction for a given modulus b */
mp_err mp_reduce_setup(mp_int *a, const mp_int *b) MP_WUR;
/* Barrett Reduction, computes a (mod b) with a precomputed value c
*
* Assumes that 0 < x <= m*m, note if 0 > x > -(m*m) then you can merely
* compute the reduction as -1 * mp_reduce(mp_abs(x)) [pseudo code].
*/
mp_err mp_reduce(mp_int *x, const mp_int *m, const mp_int *mu) MP_WUR;
/* setups the montgomery reduction */
mp_err mp_montgomery_setup(const mp_int *n, mp_digit *rho) MP_WUR;
/* computes a = B**n mod b without division or multiplication useful for
* normalizing numbers in a Montgomery system.
*/
mp_err mp_montgomery_calc_normalization(mp_int *a, const mp_int *b) MP_WUR;
/* computes x/R == x (mod N) via Montgomery Reduction */
mp_err mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho) MP_WUR;
/* returns 1 if a is a valid DR modulus */
mp_bool mp_dr_is_modulus(const mp_int *a) MP_WUR;
/* sets the value of "d" required for mp_dr_reduce */
void mp_dr_setup(const mp_int *a, mp_digit *d);
/* reduces a modulo n using the Diminished Radix method */
mp_err mp_dr_reduce(mp_int *x, const mp_int *n, mp_digit k) MP_WUR;
/* returns true if a can be reduced with mp_reduce_2k */
mp_bool mp_reduce_is_2k(const mp_int *a) MP_WUR;
/* determines k value for 2k reduction */
mp_err mp_reduce_2k_setup(const mp_int *a, mp_digit *d) MP_WUR;
/* reduces a modulo b where b is of the form 2**p - k [0 <= a] */
mp_err mp_reduce_2k(mp_int *a, const mp_int *n, mp_digit d) MP_WUR;
/* returns true if a can be reduced with mp_reduce_2k_l */
mp_bool mp_reduce_is_2k_l(const mp_int *a) MP_WUR;
/* determines k value for 2k reduction */
mp_err mp_reduce_2k_setup_l(const mp_int *a, mp_int *d) MP_WUR;
/* reduces a modulo b where b is of the form 2**p - k [0 <= a] */
mp_err mp_reduce_2k_l(mp_int *a, const mp_int *n, const mp_int *d) MP_WUR;
/* Y = G**X (mod P) */
mp_err mp_exptmod(const mp_int *G, const mp_int *X, const mp_int *P, mp_int *Y) MP_WUR;
/* ---> Primes <--- */
/* number of primes */
#ifdef MP_8BIT
# define PRIVATE_MP_PRIME_TAB_SIZE 31
#else
# define PRIVATE_MP_PRIME_TAB_SIZE 256
#endif
#define PRIME_SIZE (MP_DEPRECATED_PRAGMA("PRIME_SIZE has been made internal") PRIVATE_MP_PRIME_TAB_SIZE)
/* table of first PRIME_SIZE primes */
MP_DEPRECATED(internal) extern const mp_digit ltm_prime_tab[PRIVATE_MP_PRIME_TAB_SIZE];
/* result=1 if a is divisible by one of the first PRIME_SIZE primes */
MP_DEPRECATED(mp_prime_is_prime) mp_err mp_prime_is_divisible(const mp_int *a, mp_bool *result) MP_WUR;
/* performs one Fermat test of "a" using base "b".
* Sets result to 0 if composite or 1 if probable prime
*/
mp_err mp_prime_fermat(const mp_int *a, const mp_int *b, mp_bool *result) MP_WUR;
/* performs one Miller-Rabin test of "a" using base "b".
* Sets result to 0 if composite or 1 if probable prime
*/
mp_err mp_prime_miller_rabin(const mp_int *a, const mp_int *b, mp_bool *result) MP_WUR;
/* This gives [for a given bit size] the number of trials required
* such that Miller-Rabin gives a prob of failure lower than 2^-96
*/
int mp_prime_rabin_miller_trials(int size) MP_WUR;
/* performs one strong Lucas-Selfridge test of "a".
* Sets result to 0 if composite or 1 if probable prime
*/
mp_err mp_prime_strong_lucas_selfridge(const mp_int *a, mp_bool *result) MP_WUR;
/* performs one Frobenius test of "a" as described by Paul Underwood.
* Sets result to 0 if composite or 1 if probable prime
*/
mp_err mp_prime_frobenius_underwood(const mp_int *N, mp_bool *result) MP_WUR;
/* performs t random rounds of Miller-Rabin on "a" additional to
* bases 2 and 3. Also performs an initial sieve of trial
* division. Determines if "a" is prime with probability
* of error no more than (1/4)**t.
* Both a strong Lucas-Selfridge to complete the BPSW test
* and a separate Frobenius test are available at compile time.
* With t<0 a deterministic test is run for primes up to
* 318665857834031151167461. With t<13 (abs(t)-13) additional
* tests with sequential small primes are run starting at 43.
* Is Fips 186.4 compliant if called with t as computed by
* mp_prime_rabin_miller_trials();
*
* Sets result to 1 if probably prime, 0 otherwise
*/
mp_err mp_prime_is_prime(const mp_int *a, int t, mp_bool *result) MP_WUR;
/* finds the next prime after the number "a" using "t" trials
* of Miller-Rabin.
*
* bbs_style = 1 means the prime must be congruent to 3 mod 4
*/
mp_err mp_prime_next_prime(mp_int *a, int t, int bbs_style) MP_WUR;
/* makes a truly random prime of a given size (bytes),
* call with bbs = 1 if you want it to be congruent to 3 mod 4
*
* You have to supply a callback which fills in a buffer with random bytes. "dat" is a parameter you can
* have passed to the callback (e.g. a state or something). This function doesn't use "dat" itself
* so it can be NULL
*
* The prime generated will be larger than 2^(8*size).
*/
#define mp_prime_random(a, t, size, bbs, cb, dat) (MP_DEPRECATED_PRAGMA("mp_prime_random has been deprecated, use mp_prime_rand instead") mp_prime_random_ex(a, t, ((size) * 8) + 1, (bbs==1)?MP_PRIME_BBS:0, cb, dat))
/* makes a truly random prime of a given size (bits),
*
* Flags are as follows:
*
* MP_PRIME_BBS - make prime congruent to 3 mod 4
* MP_PRIME_SAFE - make sure (p-1)/2 is prime as well (implies MP_PRIME_BBS)
* MP_PRIME_2MSB_ON - make the 2nd highest bit one
*
* You have to supply a callback which fills in a buffer with random bytes. "dat" is a parameter you can
* have passed to the callback (e.g. a state or something). This function doesn't use "dat" itself
* so it can be NULL
*
*/
MP_DEPRECATED(mp_prime_rand) mp_err mp_prime_random_ex(mp_int *a, int t, int size, int flags,
private_mp_prime_callback cb, void *dat) MP_WUR;
mp_err mp_prime_rand(mp_int *a, int t, int size, int flags) MP_WUR;
/* Integer logarithm to integer base */
mp_err mp_log_u32(const mp_int *a, uint32_t base, uint32_t *c) MP_WUR;
/* c = a**b */
mp_err mp_expt_u32(const mp_int *a, uint32_t b, mp_int *c) MP_WUR;
MP_DEPRECATED(mp_expt_u32) mp_err mp_expt_d(const mp_int *a, mp_digit b, mp_int *c) MP_WUR;
MP_DEPRECATED(mp_expt_u32) mp_err mp_expt_d_ex(const mp_int *a, mp_digit b, mp_int *c, int fast) MP_WUR;
/* ---> radix conversion <--- */
int mp_count_bits(const mp_int *a) MP_WUR;
MP_DEPRECATED(mp_ubin_size) int mp_unsigned_bin_size(const mp_int *a) MP_WUR;
MP_DEPRECATED(mp_from_ubin) mp_err mp_read_unsigned_bin(mp_int *a, const unsigned char *b, int c) MP_WUR;
MP_DEPRECATED(mp_to_ubin) mp_err mp_to_unsigned_bin(const mp_int *a, unsigned char *b) MP_WUR;
MP_DEPRECATED(mp_to_ubin) mp_err mp_to_unsigned_bin_n(const mp_int *a, unsigned char *b, unsigned long *outlen) MP_WUR;
MP_DEPRECATED(mp_sbin_size) int mp_signed_bin_size(const mp_int *a) MP_WUR;
MP_DEPRECATED(mp_from_sbin) mp_err mp_read_signed_bin(mp_int *a, const unsigned char *b, int c) MP_WUR;
MP_DEPRECATED(mp_to_sbin) mp_err mp_to_signed_bin(const mp_int *a, unsigned char *b) MP_WUR;
MP_DEPRECATED(mp_to_sbin) mp_err mp_to_signed_bin_n(const mp_int *a, unsigned char *b, unsigned long *outlen) MP_WUR;
size_t mp_ubin_size(const mp_int *a) MP_WUR;
mp_err mp_from_ubin(mp_int *a, const unsigned char *buf, size_t size) MP_WUR;
mp_err mp_to_ubin(const mp_int *a, unsigned char *buf, size_t maxlen, size_t *written) MP_WUR;
size_t mp_sbin_size(const mp_int *a) MP_WUR;
mp_err mp_from_sbin(mp_int *a, const unsigned char *buf, size_t size) MP_WUR;
mp_err mp_to_sbin(const mp_int *a, unsigned char *buf, size_t maxlen, size_t *written) MP_WUR;
mp_err mp_read_radix(mp_int *a, const char *str, int radix) MP_WUR;
MP_DEPRECATED(mp_to_radix) mp_err mp_toradix(const mp_int *a, char *str, int radix) MP_WUR;
MP_DEPRECATED(mp_to_radix) mp_err mp_toradix_n(const mp_int *a, char *str, int radix, int maxlen) MP_WUR;
mp_err mp_to_radix(const mp_int *a, char *str, size_t maxlen, size_t *written, int radix) MP_WUR;
mp_err mp_radix_size(const mp_int *a, int radix, int *size) MP_WUR;
#ifndef MP_NO_FILE
mp_err mp_fread(mp_int *a, int radix, FILE *stream) MP_WUR;
mp_err mp_fwrite(const mp_int *a, int radix, FILE *stream) MP_WUR;
#endif
#define mp_read_raw(mp, str, len) (MP_DEPRECATED_PRAGMA("replaced by mp_read_signed_bin") mp_read_signed_bin((mp), (str), (len)))
#define mp_raw_size(mp) (MP_DEPRECATED_PRAGMA("replaced by mp_signed_bin_size") mp_signed_bin_size(mp))
#define mp_toraw(mp, str) (MP_DEPRECATED_PRAGMA("replaced by mp_to_signed_bin") mp_to_signed_bin((mp), (str)))
#define mp_read_mag(mp, str, len) (MP_DEPRECATED_PRAGMA("replaced by mp_read_unsigned_bin") mp_read_unsigned_bin((mp), (str), (len))
#define mp_mag_size(mp) (MP_DEPRECATED_PRAGMA("replaced by mp_unsigned_bin_size") mp_unsigned_bin_size(mp))
#define mp_tomag(mp, str) (MP_DEPRECATED_PRAGMA("replaced by mp_to_unsigned_bin") mp_to_unsigned_bin((mp), (str)))
#define mp_tobinary(M, S) (MP_DEPRECATED_PRAGMA("replaced by mp_to_binary") mp_toradix((M), (S), 2))
#define mp_tooctal(M, S) (MP_DEPRECATED_PRAGMA("replaced by mp_to_octal") mp_toradix((M), (S), 8))
#define mp_todecimal(M, S) (MP_DEPRECATED_PRAGMA("replaced by mp_to_decimal") mp_toradix((M), (S), 10))
#define mp_tohex(M, S) (MP_DEPRECATED_PRAGMA("replaced by mp_to_hex") mp_toradix((M), (S), 16))
#define mp_to_binary(M, S, N) mp_to_radix((M), (S), (N), NULL, 2)
#define mp_to_octal(M, S, N) mp_to_radix((M), (S), (N), NULL, 8)
#define mp_to_decimal(M, S, N) mp_to_radix((M), (S), (N), NULL, 10)
#define mp_to_hex(M, S, N) mp_to_radix((M), (S), (N), NULL, 16)
#ifdef __cplusplus
}
#endif
#endif

1319
libtom/libtommath/include/tommath_class.h Normal file
View File

File diff suppressed because it is too large Load Diff

13
libtom/libtommath/include/tommath_cutoffs.h Normal file
View File

@ -0,0 +1,13 @@
/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
/*
Current values evaluated on an AMD A8-6600K (64-bit).
Type "make tune" to optimize them for your machine but
be aware that it may take a long time. It took 2:30 minutes
on the aforementioned machine for example.
*/
#define MP_DEFAULT_KARATSUBA_MUL_CUTOFF 80
#define MP_DEFAULT_KARATSUBA_SQR_CUTOFF 120
#define MP_DEFAULT_TOOM_MUL_CUTOFF 350
#define MP_DEFAULT_TOOM_SQR_CUTOFF 400

303
libtom/libtommath/include/tommath_private.h Normal file
View File

@ -0,0 +1,303 @@
/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
#ifndef TOMMATH_PRIV_H_
#define TOMMATH_PRIV_H_
#include "tommath.h"
#include "tommath_class.h"
/*
* Private symbols
* ---------------
*
* On Unix symbols can be marked as hidden if libtommath is compiled
* as a shared object. By default, symbols are visible.
* As of now, this feature is opt-in via the MP_PRIVATE_SYMBOLS define.
*
* On Win32 a .def file must be used to specify the exported symbols.
*/
#if defined (MP_PRIVATE_SYMBOLS) && defined(__GNUC__) && __GNUC__ >= 4
# define MP_PRIVATE __attribute__ ((visibility ("hidden")))
#else
# define MP_PRIVATE
#endif
/* Hardening libtommath
* --------------------
*
* By default memory is zeroed before calling
* MP_FREE to avoid leaking data. This is good
* practice in cryptographical applications.
*
* Note however that memory allocators used
* in cryptographical applications can often
* be configured by itself to clear memory,
* rendering the clearing in tommath unnecessary.
* See for example https://github.com/GrapheneOS/hardened_malloc
* and the option CONFIG_ZERO_ON_FREE.
*
* Furthermore there are applications which
* value performance more and want this
* feature to be disabled. For such applications
* define MP_NO_ZERO_ON_FREE during compilation.
*/
#ifdef MP_NO_ZERO_ON_FREE
# define MP_FREE_BUFFER(mem, size) MP_FREE((mem), (size))
# define MP_FREE_DIGITS(mem, digits) MP_FREE((mem), sizeof (mp_digit) * (size_t)(digits))
#else
# define MP_FREE_BUFFER(mem, size) \
do { \
size_t fs_ = (size); \
void* fm_ = (mem); \
if (fm_ != NULL) { \
MP_ZERO_BUFFER(fm_, fs_); \
MP_FREE(fm_, fs_); \
} \
} while (0)
# define MP_FREE_DIGITS(mem, digits) \
do { \
int fd_ = (digits); \
void* fm_ = (mem); \
if (fm_ != NULL) { \
size_t fs_ = sizeof (mp_digit) * (size_t)fd_; \
MP_ZERO_BUFFER(fm_, fs_); \
MP_FREE(fm_, fs_); \
} \
} while (0)
#endif
#ifdef MP_USE_MEMSET
# include <string.h>
# define MP_ZERO_BUFFER(mem, size) memset((mem), 0, (size))
# define MP_ZERO_DIGITS(mem, digits) \
do { \
int zd_ = (digits); \
if (zd_ > 0) { \
memset((mem), 0, sizeof(mp_digit) * (size_t)zd_); \
} \
} while (0)
#else
# define MP_ZERO_BUFFER(mem, size) \
do { \
size_t zs_ = (size); \
char* zm_ = (char*)(mem); \
while (zs_-- > 0u) { \
*zm_++ = '\0'; \
} \
} while (0)
# define MP_ZERO_DIGITS(mem, digits) \
do { \
int zd_ = (digits); \
mp_digit* zm_ = (mem); \
while (zd_-- > 0) { \
*zm_++ = 0; \
} \
} while (0)
#endif
/* Tunable cutoffs
* ---------------
*
* - In the default settings, a cutoff X can be modified at runtime
* by adjusting the corresponding X_CUTOFF variable.
*
* - Tunability of the library can be disabled at compile time
* by defining the MP_FIXED_CUTOFFS macro.
*
* - There is an additional file tommath_cutoffs.h, which defines
* the default cutoffs. These can be adjusted manually or by the
* autotuner.
*
*/
#ifdef MP_FIXED_CUTOFFS
# include "tommath_cutoffs.h"
# define MP_KARATSUBA_MUL_CUTOFF MP_DEFAULT_KARATSUBA_MUL_CUTOFF
# define MP_KARATSUBA_SQR_CUTOFF MP_DEFAULT_KARATSUBA_SQR_CUTOFF
# define MP_TOOM_MUL_CUTOFF MP_DEFAULT_TOOM_MUL_CUTOFF
# define MP_TOOM_SQR_CUTOFF MP_DEFAULT_TOOM_SQR_CUTOFF
#else
# define MP_KARATSUBA_MUL_CUTOFF KARATSUBA_MUL_CUTOFF
# define MP_KARATSUBA_SQR_CUTOFF KARATSUBA_SQR_CUTOFF
# define MP_TOOM_MUL_CUTOFF TOOM_MUL_CUTOFF
# define MP_TOOM_SQR_CUTOFF TOOM_SQR_CUTOFF
#endif
/* define heap macros */
#ifndef MP_MALLOC
/* default to libc stuff */
# include <stdlib.h>
# define MP_MALLOC(size) malloc(size)
# define MP_REALLOC(mem, oldsize, newsize) realloc((mem), (newsize))
# define MP_CALLOC(nmemb, size) calloc((nmemb), (size))
# define MP_FREE(mem, size) free(mem)
#else
/* prototypes for our heap functions */
extern void *MP_MALLOC(size_t size);
extern void *MP_REALLOC(void *mem, size_t oldsize, size_t newsize);
extern void *MP_CALLOC(size_t nmemb, size_t size);
extern void MP_FREE(void *mem, size_t size);
#endif
/* feature detection macro */
#ifdef _MSC_VER
/* Prevent false positive: not enough arguments for function-like macro invocation */
#pragma warning(disable: 4003)
#endif
#define MP_STRINGIZE(x) MP__STRINGIZE(x)
#define MP__STRINGIZE(x) ""#x""
#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u)
/* TODO: Remove private_mp_word as soon as deprecated mp_word is removed from tommath. */
#undef mp_word
typedef private_mp_word mp_word;
#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y))
#define MP_MAX(x, y) (((x) > (y)) ? (x) : (y))
/* Static assertion */
#define MP_STATIC_ASSERT(msg, cond) typedef char mp_static_assert_##msg[(cond) ? 1 : -1];
/* ---> Basic Manipulations <--- */
#define MP_IS_ZERO(a) ((a)->used == 0)
#define MP_IS_EVEN(a) (((a)->used == 0) || (((a)->dp[0] & 1u) == 0u))
#define MP_IS_ODD(a) (((a)->used > 0) && (((a)->dp[0] & 1u) == 1u))
#define MP_SIZEOF_BITS(type) ((size_t)CHAR_BIT * sizeof(type))
#define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT)))
/* TODO: Remove PRIVATE_MP_WARRAY as soon as deprecated MP_WARRAY is removed from tommath.h */
#undef MP_WARRAY
#define MP_WARRAY PRIVATE_MP_WARRAY
/* TODO: Remove PRIVATE_MP_PREC as soon as deprecated MP_PREC is removed from tommath.h */
#ifdef PRIVATE_MP_PREC
# undef MP_PREC
# define MP_PREC PRIVATE_MP_PREC
#endif
/* Minimum number of available digits in mp_int, MP_PREC >= MP_MIN_PREC */
#define MP_MIN_PREC ((((int)MP_SIZEOF_BITS(long long) + MP_DIGIT_BIT) - 1) / MP_DIGIT_BIT)
MP_STATIC_ASSERT(prec_geq_min_prec, MP_PREC >= MP_MIN_PREC)
/* random number source */
extern MP_PRIVATE mp_err(*s_mp_rand_source)(void *out, size_t size);
/* lowlevel functions, do not call! */
MP_PRIVATE mp_bool s_mp_get_bit(const mp_int *a, unsigned int b);
MP_PRIVATE mp_err s_mp_add(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
MP_PRIVATE mp_err s_mp_sub(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
MP_PRIVATE mp_err s_mp_mul_digs_fast(const mp_int *a, const mp_int *b, mp_int *c, int digs) MP_WUR;
MP_PRIVATE mp_err s_mp_mul_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs) MP_WUR;
MP_PRIVATE mp_err s_mp_mul_high_digs_fast(const mp_int *a, const mp_int *b, mp_int *c, int digs) MP_WUR;
MP_PRIVATE mp_err s_mp_mul_high_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs) MP_WUR;
MP_PRIVATE mp_err s_mp_sqr_fast(const mp_int *a, mp_int *b) MP_WUR;
MP_PRIVATE mp_err s_mp_sqr(const mp_int *a, mp_int *b) MP_WUR;
MP_PRIVATE mp_err s_mp_balance_mul(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
MP_PRIVATE mp_err s_mp_karatsuba_mul(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
MP_PRIVATE mp_err s_mp_toom_mul(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
MP_PRIVATE mp_err s_mp_karatsuba_sqr(const mp_int *a, mp_int *b) MP_WUR;
MP_PRIVATE mp_err s_mp_toom_sqr(const mp_int *a, mp_int *b) MP_WUR;
MP_PRIVATE mp_err s_mp_invmod_fast(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
MP_PRIVATE mp_err s_mp_invmod_slow(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
MP_PRIVATE mp_err s_mp_montgomery_reduce_fast(mp_int *x, const mp_int *n, mp_digit rho) MP_WUR;
MP_PRIVATE mp_err s_mp_exptmod_fast(const mp_int *G, const mp_int *X, const mp_int *P, mp_int *Y, int redmode) MP_WUR;
MP_PRIVATE mp_err s_mp_exptmod(const mp_int *G, const mp_int *X, const mp_int *P, mp_int *Y, int redmode) MP_WUR;
MP_PRIVATE mp_err s_mp_rand_platform(void *p, size_t n) MP_WUR;
MP_PRIVATE mp_err s_mp_prime_random_ex(mp_int *a, int t, int size, int flags, private_mp_prime_callback cb, void *dat);
MP_PRIVATE void s_mp_reverse(unsigned char *s, size_t len);
MP_PRIVATE mp_err s_mp_prime_is_divisible(const mp_int *a, mp_bool *result);
/* TODO: jenkins prng is not thread safe as of now */
MP_PRIVATE mp_err s_mp_rand_jenkins(void *p, size_t n) MP_WUR;
MP_PRIVATE void s_mp_rand_jenkins_init(uint64_t seed);
extern MP_PRIVATE const char *const mp_s_rmap;
extern MP_PRIVATE const uint8_t mp_s_rmap_reverse[];
extern MP_PRIVATE const size_t mp_s_rmap_reverse_sz;
extern MP_PRIVATE const mp_digit *s_mp_prime_tab;
/* deprecated functions */
MP_DEPRECATED(s_mp_invmod_fast) mp_err fast_mp_invmod(const mp_int *a, const mp_int *b, mp_int *c);
MP_DEPRECATED(s_mp_montgomery_reduce_fast) mp_err fast_mp_montgomery_reduce(mp_int *x, const mp_int *n,
mp_digit rho);
MP_DEPRECATED(s_mp_mul_digs_fast) mp_err fast_s_mp_mul_digs(const mp_int *a, const mp_int *b, mp_int *c,
int digs);
MP_DEPRECATED(s_mp_mul_high_digs_fast) mp_err fast_s_mp_mul_high_digs(const mp_int *a, const mp_int *b,
mp_int *c,
int digs);
MP_DEPRECATED(s_mp_sqr_fast) mp_err fast_s_mp_sqr(const mp_int *a, mp_int *b);
MP_DEPRECATED(s_mp_balance_mul) mp_err mp_balance_mul(const mp_int *a, const mp_int *b, mp_int *c);
MP_DEPRECATED(s_mp_exptmod_fast) mp_err mp_exptmod_fast(const mp_int *G, const mp_int *X, const mp_int *P,
mp_int *Y,
int redmode);
MP_DEPRECATED(s_mp_invmod_slow) mp_err mp_invmod_slow(const mp_int *a, const mp_int *b, mp_int *c);
MP_DEPRECATED(s_mp_karatsuba_mul) mp_err mp_karatsuba_mul(const mp_int *a, const mp_int *b, mp_int *c);
MP_DEPRECATED(s_mp_karatsuba_sqr) mp_err mp_karatsuba_sqr(const mp_int *a, mp_int *b);
MP_DEPRECATED(s_mp_toom_mul) mp_err mp_toom_mul(const mp_int *a, const mp_int *b, mp_int *c);
MP_DEPRECATED(s_mp_toom_sqr) mp_err mp_toom_sqr(const mp_int *a, mp_int *b);
MP_DEPRECATED(s_mp_reverse) void bn_reverse(unsigned char *s, int len);
#define MP_GET_ENDIANNESS(x) \
do{\
int16_t n = 0x1; \
char *p = (char *)&n; \
x = (p[0] == '\x01') ? MP_LITTLE_ENDIAN : MP_BIG_ENDIAN; \
} while (0)
/* code-generating macros */
#define MP_SET_UNSIGNED(name, type) \
void name(mp_int * a, type b) \
{ \
int i = 0; \
while (b != 0u) { \
a->dp[i++] = ((mp_digit)b & MP_MASK); \
if (MP_SIZEOF_BITS(type) <= MP_DIGIT_BIT) { break; } \
b >>= ((MP_SIZEOF_BITS(type) <= MP_DIGIT_BIT) ? 0 : MP_DIGIT_BIT); \
} \
a->used = i; \
a->sign = MP_ZPOS; \
MP_ZERO_DIGITS(a->dp + a->used, a->alloc - a->used); \
}
#define MP_SET_SIGNED(name, uname, type, utype) \
void name(mp_int * a, type b) \
{ \
uname(a, (b < 0) ? -(utype)b : (utype)b); \
if (b < 0) { a->sign = MP_NEG; } \
}
#define MP_INIT_INT(name , set, type) \
mp_err name(mp_int * a, type b) \
{ \
mp_err err; \
if ((err = mp_init(a)) != MP_OKAY) { \
return err; \
} \
set(a, b); \
return MP_OKAY; \
}
#define MP_GET_MAG(name, type) \
type name(const mp_int* a) \
{ \
unsigned i = MP_MIN((unsigned)a->used, (unsigned)((MP_SIZEOF_BITS(type) + MP_DIGIT_BIT - 1) / MP_DIGIT_BIT)); \
type res = 0u; \
while (i --> 0u) { \
res <<= ((MP_SIZEOF_BITS(type) <= MP_DIGIT_BIT) ? 0 : MP_DIGIT_BIT); \
res |= (type)a->dp[i]; \
if (MP_SIZEOF_BITS(type) <= MP_DIGIT_BIT) { break; } \
} \
return res; \
}
#define MP_GET_SIGNED(name, mag, type, utype) \
type name(const mp_int* a) \
{ \
utype res = mag(a); \
return (a->sign == MP_NEG) ? (type)-res : (type)res; \
}
#endif

110
libtom/libtommath/include/tommath_superclass.h Normal file
View File

@ -0,0 +1,110 @@
/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
/* super class file for PK algos */
/* default ... include all MPI */
#ifndef LTM_NOTHING
#define LTM_ALL
#endif
/* RSA only (does not support DH/DSA/ECC) */
/* #define SC_RSA_1 */
/* #define SC_RSA_1_WITH_TESTS */
/* For reference.... On an Athlon64 optimizing for speed...
LTM's mpi.o with all functions [striped] is 142KiB in size.
*/
#ifdef SC_RSA_1_WITH_TESTS
# define BN_MP_ERROR_TO_STRING_C
# define BN_MP_FREAD_C
# define BN_MP_FWRITE_C
# define BN_MP_INCR_C
# define BN_MP_ISEVEN_C
# define BN_MP_ISODD_C
# define BN_MP_NEG_C
# define BN_MP_PRIME_FROBENIUS_UNDERWOOD_C
# define BN_MP_RADIX_SIZE_C
# define BN_MP_RAND_C
# define BN_MP_REDUCE_C
# define BN_MP_REDUCE_2K_L_C
# define BN_MP_FROM_SBIN_C
# define BN_MP_ROOT_U32_C
# define BN_MP_SET_L_C
# define BN_MP_SET_UL_C
# define BN_MP_SBIN_SIZE_C
# define BN_MP_TO_RADIX_C
# define BN_MP_TO_SBIN_C
# define BN_S_MP_RAND_JENKINS_C
# define BN_S_MP_RAND_PLATFORM_C
#endif
/* Works for RSA only, mpi.o is 68KiB */
#if defined(SC_RSA_1) || defined (SC_RSA_1_WITH_TESTS)
# define BN_CUTOFFS_C
# define BN_MP_ADDMOD_C
# define BN_MP_CLEAR_MULTI_C
# define BN_MP_EXPTMOD_C
# define BN_MP_GCD_C
# define BN_MP_INIT_MULTI_C
# define BN_MP_INVMOD_C
# define BN_MP_LCM_C
# define BN_MP_MOD_C
# define BN_MP_MOD_D_C
# define BN_MP_MULMOD_C
# define BN_MP_PRIME_IS_PRIME_C
# define BN_MP_PRIME_RABIN_MILLER_TRIALS_C
# define BN_MP_PRIME_RAND_C
# define BN_MP_RADIX_SMAP_C
# define BN_MP_SET_INT_C
# define BN_MP_SHRINK_C
# define BN_MP_TO_UNSIGNED_BIN_C
# define BN_MP_UNSIGNED_BIN_SIZE_C
# define BN_PRIME_TAB_C
# define BN_S_MP_REVERSE_C
/* other modifiers */
# define BN_MP_DIV_SMALL /* Slower division, not critical */
/* here we are on the last pass so we turn things off. The functions classes are still there
* but we remove them specifically from the build. This also invokes tweaks in functions
* like removing support for even moduli, etc...
*/
# ifdef LTM_LAST
# undef BN_MP_DR_IS_MODULUS_C
# undef BN_MP_DR_SETUP_C
# undef BN_MP_DR_REDUCE_C
# undef BN_MP_DIV_3_C
# undef BN_MP_REDUCE_2K_SETUP_C
# undef BN_MP_REDUCE_2K_C
# undef BN_MP_REDUCE_IS_2K_C
# undef BN_MP_REDUCE_SETUP_C
# undef BN_S_MP_BALANCE_MUL_C
# undef BN_S_MP_EXPTMOD_C
# undef BN_S_MP_INVMOD_FAST_C
# undef BN_S_MP_KARATSUBA_MUL_C
# undef BN_S_MP_KARATSUBA_SQR_C
# undef BN_S_MP_MUL_HIGH_DIGS_C
# undef BN_S_MP_MUL_HIGH_DIGS_FAST_C
# undef BN_S_MP_TOOM_MUL_C
# undef BN_S_MP_TOOM_SQR_C
# ifndef SC_RSA_1_WITH_TESTS
# undef BN_MP_REDUCE_C
# endif
/* To safely undefine these you have to make sure your RSA key won't exceed the Comba threshold
* which is roughly 255 digits [7140 bits for 32-bit machines, 15300 bits for 64-bit machines]
* which means roughly speaking you can handle upto 2536-bit RSA keys with these defined without
* trouble.
*/
# undef BN_MP_MONTGOMERY_REDUCE_C
# undef BN_S_MP_MUL_DIGS_C
# undef BN_S_MP_SQR_C
# endif
#endif

BIN
libtom/libtommath/lib/tommath.lib Normal file
View File

Binary file not shown.

781
libtom/libtommath/tommath.h Normal file
View File

@ -0,0 +1,781 @@
/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
#ifndef BN_H_
#define BN_H_
#include <stdint.h>
#include <stddef.h>
#include <limits.h>
#ifdef LTM_NO_FILE
# warning LTM_NO_FILE has been deprecated, use MP_NO_FILE.
# define MP_NO_FILE
#endif
#ifndef MP_NO_FILE
# include <stdio.h>
#endif
#ifdef MP_8BIT
# ifdef _MSC_VER
# pragma message("8-bit (MP_8BIT) support is deprecated and will be dropped completely in the next version.")
# else
# warning "8-bit (MP_8BIT) support is deprecated and will be dropped completely in the next version."
# endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* MS Visual C++ doesn't have a 128bit type for words, so fall back to 32bit MPI's (where words are 64bit) */
#if (defined(_MSC_VER) || defined(__LLP64__) || defined(__e2k__) || defined(__LCC__)) && !defined(MP_64BIT)
# define MP_32BIT
#endif
/* detect 64-bit mode if possible */
#if defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64) || \
defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__) || \
defined(__s390x__) || defined(__arch64__) || defined(__aarch64__) || \
defined(__sparcv9) || defined(__sparc_v9__) || defined(__sparc64__) || \
defined(__ia64) || defined(__ia64__) || defined(__itanium__) || defined(_M_IA64) || \
defined(__LP64__) || defined(_LP64) || defined(__64BIT__)
# if !(defined(MP_64BIT) || defined(MP_32BIT) || defined(MP_16BIT) || defined(MP_8BIT))
# if defined(__GNUC__) && !defined(__hppa)
/* we support 128bit integers only via: __attribute__((mode(TI))) */
# define MP_64BIT
# else
/* otherwise we fall back to MP_32BIT even on 64bit platforms */
# define MP_32BIT
# endif
# endif
#endif
#ifdef MP_DIGIT_BIT
# error Defining MP_DIGIT_BIT is disallowed, use MP_8/16/31/32/64BIT
#endif
/* some default configurations.
*
* A "mp_digit" must be able to hold MP_DIGIT_BIT + 1 bits
* A "mp_word" must be able to hold 2*MP_DIGIT_BIT + 1 bits
*
* At the very least a mp_digit must be able to hold 7 bits
* [any size beyond that is ok provided it doesn't overflow the data type]
*/
#ifdef MP_8BIT
typedef uint8_t mp_digit;
typedef uint16_t private_mp_word;
# define MP_DIGIT_BIT 7
#elif defined(MP_16BIT)
typedef uint16_t mp_digit;
typedef uint32_t private_mp_word;
# define MP_DIGIT_BIT 15
#elif defined(MP_64BIT)
/* for GCC only on supported platforms */
typedef uint64_t mp_digit;
#if defined(__GNUC__)
typedef unsigned long private_mp_word __attribute__((mode(TI)));
#endif
# define MP_DIGIT_BIT 60
#else
typedef uint32_t mp_digit;
typedef uint64_t private_mp_word;
# ifdef MP_31BIT
/*
* This is an extension that uses 31-bit digits.
* Please be aware that not all functions support this size, especially s_mp_mul_digs_fast
* will be reduced to work on small numbers only:
* Up to 8 limbs, 248 bits instead of up to 512 limbs, 15872 bits with MP_28BIT.
*/
# define MP_DIGIT_BIT 31
# else
/* default case is 28-bit digits, defines MP_28BIT as a handy macro to test */
# define MP_DIGIT_BIT 28
# define MP_28BIT
# endif
#endif
/* mp_word is a private type */
#define mp_word MP_DEPRECATED_PRAGMA("mp_word has been made private") private_mp_word
#define MP_SIZEOF_MP_DIGIT (MP_DEPRECATED_PRAGMA("MP_SIZEOF_MP_DIGIT has been deprecated, use sizeof (mp_digit)") sizeof (mp_digit))
#define MP_MASK ((((mp_digit)1)<<((mp_digit)MP_DIGIT_BIT))-((mp_digit)1))
#define MP_DIGIT_MAX MP_MASK
/* Primality generation flags */
#define MP_PRIME_BBS 0x0001 /* BBS style prime */
#define MP_PRIME_SAFE 0x0002 /* Safe prime (p-1)/2 == prime */
#define MP_PRIME_2MSB_ON 0x0008 /* force 2nd MSB to 1 */
#define LTM_PRIME_BBS (MP_DEPRECATED_PRAGMA("LTM_PRIME_BBS has been deprecated, use MP_PRIME_BBS") MP_PRIME_BBS)
#define LTM_PRIME_SAFE (MP_DEPRECATED_PRAGMA("LTM_PRIME_SAFE has been deprecated, use MP_PRIME_SAFE") MP_PRIME_SAFE)
#define LTM_PRIME_2MSB_ON (MP_DEPRECATED_PRAGMA("LTM_PRIME_2MSB_ON has been deprecated, use MP_PRIME_2MSB_ON") MP_PRIME_2MSB_ON)
#ifdef MP_USE_ENUMS
typedef enum {
MP_ZPOS = 0, /* positive */
MP_NEG = 1 /* negative */
} mp_sign;
typedef enum {
MP_LT = -1, /* less than */
MP_EQ = 0, /* equal */
MP_GT = 1 /* greater than */
} mp_ord;
typedef enum {
MP_NO = 0,
MP_YES = 1
} mp_bool;
typedef enum {
MP_OKAY = 0, /* no error */
MP_ERR = -1, /* unknown error */
MP_MEM = -2, /* out of mem */
MP_VAL = -3, /* invalid input */
MP_ITER = -4, /* maximum iterations reached */
MP_BUF = -5 /* buffer overflow, supplied buffer too small */
} mp_err;
typedef enum {
MP_LSB_FIRST = -1,
MP_MSB_FIRST = 1
} mp_order;
typedef enum {
MP_LITTLE_ENDIAN = -1,
MP_NATIVE_ENDIAN = 0,
MP_BIG_ENDIAN = 1
} mp_endian;
#else
typedef int mp_sign;
#define MP_ZPOS 0 /* positive integer */
#define MP_NEG 1 /* negative */
typedef int mp_ord;
#define MP_LT -1 /* less than */
#define MP_EQ 0 /* equal to */
#define MP_GT 1 /* greater than */
typedef int mp_bool;
#define MP_YES 1
#define MP_NO 0
typedef int mp_err;
#define MP_OKAY 0 /* no error */
#define MP_ERR -1 /* unknown error */
#define MP_MEM -2 /* out of mem */
#define MP_VAL -3 /* invalid input */
#define MP_RANGE (MP_DEPRECATED_PRAGMA("MP_RANGE has been deprecated in favor of MP_VAL") MP_VAL)
#define MP_ITER -4 /* maximum iterations reached */
#define MP_BUF -5 /* buffer overflow, supplied buffer too small */
typedef int mp_order;
#define MP_LSB_FIRST -1
#define MP_MSB_FIRST 1
typedef int mp_endian;
#define MP_LITTLE_ENDIAN -1
#define MP_NATIVE_ENDIAN 0
#define MP_BIG_ENDIAN 1
#endif
/* tunable cutoffs */
#ifndef MP_FIXED_CUTOFFS
extern int
KARATSUBA_MUL_CUTOFF,
KARATSUBA_SQR_CUTOFF,
TOOM_MUL_CUTOFF,
TOOM_SQR_CUTOFF;
#endif
/* define this to use lower memory usage routines (exptmods mostly) */
/* #define MP_LOW_MEM */
/* default precision */
#ifndef MP_PREC
# ifndef MP_LOW_MEM
# define PRIVATE_MP_PREC 32 /* default digits of precision */
# elif defined(MP_8BIT)
# define PRIVATE_MP_PREC 16 /* default digits of precision */
# else
# define PRIVATE_MP_PREC 8 /* default digits of precision */
# endif
# define MP_PREC (MP_DEPRECATED_PRAGMA("MP_PREC is an internal macro") PRIVATE_MP_PREC)
#endif
/* size of comba arrays, should be at least 2 * 2**(BITS_PER_WORD - BITS_PER_DIGIT*2) */
#define PRIVATE_MP_WARRAY (int)(1uLL << (((CHAR_BIT * sizeof(private_mp_word)) - (2 * MP_DIGIT_BIT)) + 1))
#define MP_WARRAY (MP_DEPRECATED_PRAGMA("MP_WARRAY is an internal macro") PRIVATE_MP_WARRAY)
#if defined(__GNUC__) && __GNUC__ >= 4
# define MP_NULL_TERMINATED __attribute__((sentinel))
#else
# define MP_NULL_TERMINATED
#endif
/*
* MP_WUR - warn unused result
* ---------------------------
*
* The result of functions annotated with MP_WUR must be
* checked and cannot be ignored.
*
* Most functions in libtommath return an error code.
* This error code must be checked in order to prevent crashes or invalid
* results.
*
* If you still want to avoid the error checks for quick and dirty programs
* without robustness guarantees, you can `#define MP_WUR` before including
* tommath.h, disabling the warnings.
*/
#ifndef MP_WUR
# if defined(__GNUC__) && __GNUC__ >= 4
# define MP_WUR __attribute__((warn_unused_result))
# else
# define MP_WUR
# endif
#endif
#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 405)
# define MP_DEPRECATED(x) __attribute__((deprecated("replaced by " #x)))
# define PRIVATE_MP_DEPRECATED_PRAGMA(s) _Pragma(#s)
# define MP_DEPRECATED_PRAGMA(s) PRIVATE_MP_DEPRECATED_PRAGMA(GCC warning s)
#elif defined(_MSC_VER) && _MSC_VER >= 1500
# define MP_DEPRECATED(x) __declspec(deprecated("replaced by " #x))
# define MP_DEPRECATED_PRAGMA(s) __pragma(message(s))
#else
# define MP_DEPRECATED(s)
# define MP_DEPRECATED_PRAGMA(s)
#endif
#define DIGIT_BIT (MP_DEPRECATED_PRAGMA("DIGIT_BIT macro is deprecated, MP_DIGIT_BIT instead") MP_DIGIT_BIT)
#define USED(m) (MP_DEPRECATED_PRAGMA("USED macro is deprecated, use z->used instead") (m)->used)
#define DIGIT(m, k) (MP_DEPRECATED_PRAGMA("DIGIT macro is deprecated, use z->dp instead") (m)->dp[(k)])
#define SIGN(m) (MP_DEPRECATED_PRAGMA("SIGN macro is deprecated, use z->sign instead") (m)->sign)
/* the infamous mp_int structure */
typedef struct {
int used, alloc;
mp_sign sign;
mp_digit *dp;
} mp_int;
/* callback for mp_prime_random, should fill dst with random bytes and return how many read [upto len] */
typedef int private_mp_prime_callback(unsigned char *dst, int len, void *dat);
typedef private_mp_prime_callback MP_DEPRECATED(mp_rand_source) ltm_prime_callback;
/* error code to char* string */
const char *mp_error_to_string(mp_err code) MP_WUR;
/* ---> init and deinit bignum functions <--- */
/* init a bignum */
mp_err mp_init(mp_int *a) MP_WUR;
/* free a bignum */
void mp_clear(mp_int *a);
/* init a null terminated series of arguments */
mp_err mp_init_multi(mp_int *mp, ...) MP_NULL_TERMINATED MP_WUR;
/* clear a null terminated series of arguments */
void mp_clear_multi(mp_int *mp, ...) MP_NULL_TERMINATED;
/* exchange two ints */
void mp_exch(mp_int *a, mp_int *b);
/* shrink ram required for a bignum */
mp_err mp_shrink(mp_int *a) MP_WUR;
/* grow an int to a given size */
mp_err mp_grow(mp_int *a, int size) MP_WUR;
/* init to a given number of digits */
mp_err mp_init_size(mp_int *a, int size) MP_WUR;
/* ---> Basic Manipulations <--- */
#define mp_iszero(a) (((a)->used == 0) ? MP_YES : MP_NO)
mp_bool mp_iseven(const mp_int *a) MP_WUR;
mp_bool mp_isodd(const mp_int *a) MP_WUR;
#define mp_isneg(a) (((a)->sign != MP_ZPOS) ? MP_YES : MP_NO)
/* set to zero */
void mp_zero(mp_int *a);
/* get and set doubles */
double mp_get_double(const mp_int *a) MP_WUR;
mp_err mp_set_double(mp_int *a, double b) MP_WUR;
/* get integer, set integer and init with integer (int32_t) */
int32_t mp_get_i32(const mp_int *a) MP_WUR;
void mp_set_i32(mp_int *a, int32_t b);
mp_err mp_init_i32(mp_int *a, int32_t b) MP_WUR;
/* get integer, set integer and init with integer, behaves like two complement for negative numbers (uint32_t) */
#define mp_get_u32(a) ((uint32_t)mp_get_i32(a))
void mp_set_u32(mp_int *a, uint32_t b);
mp_err mp_init_u32(mp_int *a, uint32_t b) MP_WUR;
/* get integer, set integer and init with integer (int64_t) */
int64_t mp_get_i64(const mp_int *a) MP_WUR;
void mp_set_i64(mp_int *a, int64_t b);
mp_err mp_init_i64(mp_int *a, int64_t b) MP_WUR;
/* get integer, set integer and init with integer, behaves like two complement for negative numbers (uint64_t) */
#define mp_get_u64(a) ((uint64_t)mp_get_i64(a))
void mp_set_u64(mp_int *a, uint64_t b);
mp_err mp_init_u64(mp_int *a, uint64_t b) MP_WUR;
/* get magnitude */
uint32_t mp_get_mag_u32(const mp_int *a) MP_WUR;
uint64_t mp_get_mag_u64(const mp_int *a) MP_WUR;
unsigned long mp_get_mag_ul(const mp_int *a) MP_WUR;
unsigned long long mp_get_mag_ull(const mp_int *a) MP_WUR;
/* get integer, set integer (long) */
long mp_get_l(const mp_int *a) MP_WUR;
void mp_set_l(mp_int *a, long b);
mp_err mp_init_l(mp_int *a, long b) MP_WUR;
/* get integer, set integer (unsigned long) */
#define mp_get_ul(a) ((unsigned long)mp_get_l(a))
void mp_set_ul(mp_int *a, unsigned long b);
mp_err mp_init_ul(mp_int *a, unsigned long b) MP_WUR;
/* get integer, set integer (long long) */
long long mp_get_ll(const mp_int *a) MP_WUR;
void mp_set_ll(mp_int *a, long long b);
mp_err mp_init_ll(mp_int *a, long long b) MP_WUR;
/* get integer, set integer (unsigned long long) */
#define mp_get_ull(a) ((unsigned long long)mp_get_ll(a))
void mp_set_ull(mp_int *a, unsigned long long b);
mp_err mp_init_ull(mp_int *a, unsigned long long b) MP_WUR;
/* set to single unsigned digit, up to MP_DIGIT_MAX */
void mp_set(mp_int *a, mp_digit b);
mp_err mp_init_set(mp_int *a, mp_digit b) MP_WUR;
/* get integer, set integer and init with integer (deprecated) */
MP_DEPRECATED(mp_get_mag_u32/mp_get_u32) unsigned long mp_get_int(const mp_int *a) MP_WUR;
MP_DEPRECATED(mp_get_mag_ul/mp_get_ul) unsigned long mp_get_long(const mp_int *a) MP_WUR;
MP_DEPRECATED(mp_get_mag_ull/mp_get_ull) unsigned long long mp_get_long_long(const mp_int *a) MP_WUR;
MP_DEPRECATED(mp_set_ul) mp_err mp_set_int(mp_int *a, unsigned long b);
MP_DEPRECATED(mp_set_ul) mp_err mp_set_long(mp_int *a, unsigned long b);
MP_DEPRECATED(mp_set_ull) mp_err mp_set_long_long(mp_int *a, unsigned long long b);
MP_DEPRECATED(mp_init_ul) mp_err mp_init_set_int(mp_int *a, unsigned long b) MP_WUR;
/* copy, b = a */
mp_err mp_copy(const mp_int *a, mp_int *b) MP_WUR;
/* inits and copies, a = b */
mp_err mp_init_copy(mp_int *a, const mp_int *b) MP_WUR;
/* trim unused digits */
void mp_clamp(mp_int *a);
/* export binary data */
MP_DEPRECATED(mp_pack) mp_err mp_export(void *rop, size_t *countp, int order, size_t size,
int endian, size_t nails, const mp_int *op) MP_WUR;
/* import binary data */
MP_DEPRECATED(mp_unpack) mp_err mp_import(mp_int *rop, size_t count, int order,
size_t size, int endian, size_t nails,
const void *op) MP_WUR;
/* unpack binary data */
mp_err mp_unpack(mp_int *rop, size_t count, mp_order order, size_t size, mp_endian endian,
size_t nails, const void *op) MP_WUR;
/* pack binary data */
size_t mp_pack_count(const mp_int *a, size_t nails, size_t size) MP_WUR;
mp_err mp_pack(void *rop, size_t maxcount, size_t *written, mp_order order, size_t size,
mp_endian endian, size_t nails, const mp_int *op) MP_WUR;
/* ---> digit manipulation <--- */
/* right shift by "b" digits */
void mp_rshd(mp_int *a, int b);
/* left shift by "b" digits */
mp_err mp_lshd(mp_int *a, int b) MP_WUR;
/* c = a / 2**b, implemented as c = a >> b */
mp_err mp_div_2d(const mp_int *a, int b, mp_int *c, mp_int *d) MP_WUR;
/* b = a/2 */
mp_err mp_div_2(const mp_int *a, mp_int *b) MP_WUR;
/* a/3 => 3c + d == a */
mp_err mp_div_3(const mp_int *a, mp_int *c, mp_digit *d) MP_WUR;
/* c = a * 2**b, implemented as c = a << b */
mp_err mp_mul_2d(const mp_int *a, int b, mp_int *c) MP_WUR;
/* b = a*2 */
mp_err mp_mul_2(const mp_int *a, mp_int *b) MP_WUR;
/* c = a mod 2**b */
mp_err mp_mod_2d(const mp_int *a, int b, mp_int *c) MP_WUR;
/* computes a = 2**b */
mp_err mp_2expt(mp_int *a, int b) MP_WUR;
/* Counts the number of lsbs which are zero before the first zero bit */
int mp_cnt_lsb(const mp_int *a) MP_WUR;
/* I Love Earth! */
/* makes a pseudo-random mp_int of a given size */
mp_err mp_rand(mp_int *a, int digits) MP_WUR;
/* makes a pseudo-random small int of a given size */
MP_DEPRECATED(mp_rand) mp_err mp_rand_digit(mp_digit *r) MP_WUR;
/* use custom random data source instead of source provided the platform */
void mp_rand_source(mp_err(*source)(void *out, size_t size));
#ifdef MP_PRNG_ENABLE_LTM_RNG
# warning MP_PRNG_ENABLE_LTM_RNG has been deprecated, use mp_rand_source instead.
/* A last resort to provide random data on systems without any of the other
* implemented ways to gather entropy.
* It is compatible with `rng_get_bytes()` from libtomcrypt so you could
* provide that one and then set `ltm_rng = rng_get_bytes;` */
extern unsigned long (*ltm_rng)(unsigned char *out, unsigned long outlen, void (*callback)(void));
extern void (*ltm_rng_callback)(void);
#endif
/* ---> binary operations <--- */
/* Checks the bit at position b and returns MP_YES
* if the bit is 1, MP_NO if it is 0 and MP_VAL
* in case of error
*/
MP_DEPRECATED(s_mp_get_bit) int mp_get_bit(const mp_int *a, int b) MP_WUR;
/* c = a XOR b (two complement) */
MP_DEPRECATED(mp_xor) mp_err mp_tc_xor(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
mp_err mp_xor(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* c = a OR b (two complement) */
MP_DEPRECATED(mp_or) mp_err mp_tc_or(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
mp_err mp_or(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* c = a AND b (two complement) */
MP_DEPRECATED(mp_and) mp_err mp_tc_and(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
mp_err mp_and(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* b = ~a (bitwise not, two complement) */
mp_err mp_complement(const mp_int *a, mp_int *b) MP_WUR;
/* right shift with sign extension */
MP_DEPRECATED(mp_signed_rsh) mp_err mp_tc_div_2d(const mp_int *a, int b, mp_int *c) MP_WUR;
mp_err mp_signed_rsh(const mp_int *a, int b, mp_int *c) MP_WUR;
/* ---> Basic arithmetic <--- */
/* b = -a */
mp_err mp_neg(const mp_int *a, mp_int *b) MP_WUR;
/* b = |a| */
mp_err mp_abs(const mp_int *a, mp_int *b) MP_WUR;
/* compare a to b */
mp_ord mp_cmp(const mp_int *a, const mp_int *b) MP_WUR;
/* compare |a| to |b| */
mp_ord mp_cmp_mag(const mp_int *a, const mp_int *b) MP_WUR;
/* c = a + b */
mp_err mp_add(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* c = a - b */
mp_err mp_sub(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* c = a * b */
mp_err mp_mul(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* b = a*a */
mp_err mp_sqr(const mp_int *a, mp_int *b) MP_WUR;
/* a/b => cb + d == a */
mp_err mp_div(const mp_int *a, const mp_int *b, mp_int *c, mp_int *d) MP_WUR;
/* c = a mod b, 0 <= c < b */
mp_err mp_mod(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* Increment "a" by one like "a++". Changes input! */
mp_err mp_incr(mp_int *a) MP_WUR;
/* Decrement "a" by one like "a--". Changes input! */
mp_err mp_decr(mp_int *a) MP_WUR;
/* ---> single digit functions <--- */
/* compare against a single digit */
mp_ord mp_cmp_d(const mp_int *a, mp_digit b) MP_WUR;
/* c = a + b */
mp_err mp_add_d(const mp_int *a, mp_digit b, mp_int *c) MP_WUR;
/* c = a - b */
mp_err mp_sub_d(const mp_int *a, mp_digit b, mp_int *c) MP_WUR;
/* c = a * b */
mp_err mp_mul_d(const mp_int *a, mp_digit b, mp_int *c) MP_WUR;
/* a/b => cb + d == a */
mp_err mp_div_d(const mp_int *a, mp_digit b, mp_int *c, mp_digit *d) MP_WUR;
/* c = a mod b, 0 <= c < b */
mp_err mp_mod_d(const mp_int *a, mp_digit b, mp_digit *c) MP_WUR;
/* ---> number theory <--- */
/* d = a + b (mod c) */
mp_err mp_addmod(const mp_int *a, const mp_int *b, const mp_int *c, mp_int *d) MP_WUR;
/* d = a - b (mod c) */
mp_err mp_submod(const mp_int *a, const mp_int *b, const mp_int *c, mp_int *d) MP_WUR;
/* d = a * b (mod c) */
mp_err mp_mulmod(const mp_int *a, const mp_int *b, const mp_int *c, mp_int *d) MP_WUR;
/* c = a * a (mod b) */
mp_err mp_sqrmod(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* c = 1/a (mod b) */
mp_err mp_invmod(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* c = (a, b) */
mp_err mp_gcd(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* produces value such that U1*a + U2*b = U3 */
mp_err mp_exteuclid(const mp_int *a, const mp_int *b, mp_int *U1, mp_int *U2, mp_int *U3) MP_WUR;
/* c = [a, b] or (a*b)/(a, b) */
mp_err mp_lcm(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
/* finds one of the b'th root of a, such that |c|**b <= |a|
*
* returns error if a < 0 and b is even
*/
mp_err mp_root_u32(const mp_int *a, uint32_t b, mp_int *c) MP_WUR;
MP_DEPRECATED(mp_root_u32) mp_err mp_n_root(const mp_int *a, mp_digit b, mp_int *c) MP_WUR;
MP_DEPRECATED(mp_root_u32) mp_err mp_n_root_ex(const mp_int *a, mp_digit b, mp_int *c, int fast) MP_WUR;
/* special sqrt algo */
mp_err mp_sqrt(const mp_int *arg, mp_int *ret) MP_WUR;
/* special sqrt (mod prime) */
mp_err mp_sqrtmod_prime(const mp_int *n, const mp_int *prime, mp_int *ret) MP_WUR;
/* is number a square? */
mp_err mp_is_square(const mp_int *arg, mp_bool *ret) MP_WUR;
/* computes the jacobi c = (a | n) (or Legendre if b is prime) */
MP_DEPRECATED(mp_kronecker) mp_err mp_jacobi(const mp_int *a, const mp_int *n, int *c) MP_WUR;
/* computes the Kronecker symbol c = (a | p) (like jacobi() but with {a,p} in Z */
mp_err mp_kronecker(const mp_int *a, const mp_int *p, int *c) MP_WUR;
/* used to setup the Barrett reduction for a given modulus b */
mp_err mp_reduce_setup(mp_int *a, const mp_int *b) MP_WUR;
/* Barrett Reduction, computes a (mod b) with a precomputed value c
*
* Assumes that 0 < x <= m*m, note if 0 > x > -(m*m) then you can merely
* compute the reduction as -1 * mp_reduce(mp_abs(x)) [pseudo code].
*/
mp_err mp_reduce(mp_int *x, const mp_int *m, const mp_int *mu) MP_WUR;
/* setups the montgomery reduction */
mp_err mp_montgomery_setup(const mp_int *n, mp_digit *rho) MP_WUR;
/* computes a = B**n mod b without division or multiplication useful for
* normalizing numbers in a Montgomery system.
*/
mp_err mp_montgomery_calc_normalization(mp_int *a, const mp_int *b) MP_WUR;
/* computes x/R == x (mod N) via Montgomery Reduction */
mp_err mp_montgomery_reduce(mp_int *x, const mp_int *n, mp_digit rho) MP_WUR;
/* returns 1 if a is a valid DR modulus */
mp_bool mp_dr_is_modulus(const mp_int *a) MP_WUR;
/* sets the value of "d" required for mp_dr_reduce */
void mp_dr_setup(const mp_int *a, mp_digit *d);
/* reduces a modulo n using the Diminished Radix method */
mp_err mp_dr_reduce(mp_int *x, const mp_int *n, mp_digit k) MP_WUR;
/* returns true if a can be reduced with mp_reduce_2k */
mp_bool mp_reduce_is_2k(const mp_int *a) MP_WUR;
/* determines k value for 2k reduction */
mp_err mp_reduce_2k_setup(const mp_int *a, mp_digit *d) MP_WUR;
/* reduces a modulo b where b is of the form 2**p - k [0 <= a] */
mp_err mp_reduce_2k(mp_int *a, const mp_int *n, mp_digit d) MP_WUR;
/* returns true if a can be reduced with mp_reduce_2k_l */
mp_bool mp_reduce_is_2k_l(const mp_int *a) MP_WUR;
/* determines k value for 2k reduction */
mp_err mp_reduce_2k_setup_l(const mp_int *a, mp_int *d) MP_WUR;
/* reduces a modulo b where b is of the form 2**p - k [0 <= a] */
mp_err mp_reduce_2k_l(mp_int *a, const mp_int *n, const mp_int *d) MP_WUR;
/* Y = G**X (mod P) */
mp_err mp_exptmod(const mp_int *G, const mp_int *X, const mp_int *P, mp_int *Y) MP_WUR;
/* ---> Primes <--- */
/* number of primes */
#ifdef MP_8BIT
# define PRIVATE_MP_PRIME_TAB_SIZE 31
#else
# define PRIVATE_MP_PRIME_TAB_SIZE 256
#endif
#define PRIME_SIZE (MP_DEPRECATED_PRAGMA("PRIME_SIZE has been made internal") PRIVATE_MP_PRIME_TAB_SIZE)
/* table of first PRIME_SIZE primes */
MP_DEPRECATED(internal) extern const mp_digit ltm_prime_tab[PRIVATE_MP_PRIME_TAB_SIZE];
/* result=1 if a is divisible by one of the first PRIME_SIZE primes */
MP_DEPRECATED(mp_prime_is_prime) mp_err mp_prime_is_divisible(const mp_int *a, mp_bool *result) MP_WUR;
/* performs one Fermat test of "a" using base "b".
* Sets result to 0 if composite or 1 if probable prime
*/
mp_err mp_prime_fermat(const mp_int *a, const mp_int *b, mp_bool *result) MP_WUR;
/* performs one Miller-Rabin test of "a" using base "b".
* Sets result to 0 if composite or 1 if probable prime
*/
mp_err mp_prime_miller_rabin(const mp_int *a, const mp_int *b, mp_bool *result) MP_WUR;
/* This gives [for a given bit size] the number of trials required
* such that Miller-Rabin gives a prob of failure lower than 2^-96
*/
int mp_prime_rabin_miller_trials(int size) MP_WUR;
/* performs one strong Lucas-Selfridge test of "a".
* Sets result to 0 if composite or 1 if probable prime
*/
mp_err mp_prime_strong_lucas_selfridge(const mp_int *a, mp_bool *result) MP_WUR;
/* performs one Frobenius test of "a" as described by Paul Underwood.
* Sets result to 0 if composite or 1 if probable prime
*/
mp_err mp_prime_frobenius_underwood(const mp_int *N, mp_bool *result) MP_WUR;
/* performs t random rounds of Miller-Rabin on "a" additional to
* bases 2 and 3. Also performs an initial sieve of trial
* division. Determines if "a" is prime with probability
* of error no more than (1/4)**t.
* Both a strong Lucas-Selfridge to complete the BPSW test
* and a separate Frobenius test are available at compile time.
* With t<0 a deterministic test is run for primes up to
* 318665857834031151167461. With t<13 (abs(t)-13) additional
* tests with sequential small primes are run starting at 43.
* Is Fips 186.4 compliant if called with t as computed by
* mp_prime_rabin_miller_trials();
*
* Sets result to 1 if probably prime, 0 otherwise
*/
mp_err mp_prime_is_prime(const mp_int *a, int t, mp_bool *result) MP_WUR;
/* finds the next prime after the number "a" using "t" trials
* of Miller-Rabin.
*
* bbs_style = 1 means the prime must be congruent to 3 mod 4
*/
mp_err mp_prime_next_prime(mp_int *a, int t, int bbs_style) MP_WUR;
/* makes a truly random prime of a given size (bytes),
* call with bbs = 1 if you want it to be congruent to 3 mod 4
*
* You have to supply a callback which fills in a buffer with random bytes. "dat" is a parameter you can
* have passed to the callback (e.g. a state or something). This function doesn't use "dat" itself
* so it can be NULL
*
* The prime generated will be larger than 2^(8*size).
*/
#define mp_prime_random(a, t, size, bbs, cb, dat) (MP_DEPRECATED_PRAGMA("mp_prime_random has been deprecated, use mp_prime_rand instead") mp_prime_random_ex(a, t, ((size) * 8) + 1, (bbs==1)?MP_PRIME_BBS:0, cb, dat))
/* makes a truly random prime of a given size (bits),
*
* Flags are as follows:
*
* MP_PRIME_BBS - make prime congruent to 3 mod 4
* MP_PRIME_SAFE - make sure (p-1)/2 is prime as well (implies MP_PRIME_BBS)
* MP_PRIME_2MSB_ON - make the 2nd highest bit one
*
* You have to supply a callback which fills in a buffer with random bytes. "dat" is a parameter you can
* have passed to the callback (e.g. a state or something). This function doesn't use "dat" itself
* so it can be NULL
*
*/
MP_DEPRECATED(mp_prime_rand) mp_err mp_prime_random_ex(mp_int *a, int t, int size, int flags,
private_mp_prime_callback cb, void *dat) MP_WUR;
mp_err mp_prime_rand(mp_int *a, int t, int size, int flags) MP_WUR;
/* Integer logarithm to integer base */
mp_err mp_log_u32(const mp_int *a, uint32_t base, uint32_t *c) MP_WUR;
/* c = a**b */
mp_err mp_expt_u32(const mp_int *a, uint32_t b, mp_int *c) MP_WUR;
MP_DEPRECATED(mp_expt_u32) mp_err mp_expt_d(const mp_int *a, mp_digit b, mp_int *c) MP_WUR;
MP_DEPRECATED(mp_expt_u32) mp_err mp_expt_d_ex(const mp_int *a, mp_digit b, mp_int *c, int fast) MP_WUR;
/* ---> radix conversion <--- */
int mp_count_bits(const mp_int *a) MP_WUR;
MP_DEPRECATED(mp_ubin_size) int mp_unsigned_bin_size(const mp_int *a) MP_WUR;
MP_DEPRECATED(mp_from_ubin) mp_err mp_read_unsigned_bin(mp_int *a, const unsigned char *b, int c) MP_WUR;
MP_DEPRECATED(mp_to_ubin) mp_err mp_to_unsigned_bin(const mp_int *a, unsigned char *b) MP_WUR;
MP_DEPRECATED(mp_to_ubin) mp_err mp_to_unsigned_bin_n(const mp_int *a, unsigned char *b, unsigned long *outlen) MP_WUR;
MP_DEPRECATED(mp_sbin_size) int mp_signed_bin_size(const mp_int *a) MP_WUR;
MP_DEPRECATED(mp_from_sbin) mp_err mp_read_signed_bin(mp_int *a, const unsigned char *b, int c) MP_WUR;
MP_DEPRECATED(mp_to_sbin) mp_err mp_to_signed_bin(const mp_int *a, unsigned char *b) MP_WUR;
MP_DEPRECATED(mp_to_sbin) mp_err mp_to_signed_bin_n(const mp_int *a, unsigned char *b, unsigned long *outlen) MP_WUR;
size_t mp_ubin_size(const mp_int *a) MP_WUR;
mp_err mp_from_ubin(mp_int *a, const unsigned char *buf, size_t size) MP_WUR;
mp_err mp_to_ubin(const mp_int *a, unsigned char *buf, size_t maxlen, size_t *written) MP_WUR;
size_t mp_sbin_size(const mp_int *a) MP_WUR;
mp_err mp_from_sbin(mp_int *a, const unsigned char *buf, size_t size) MP_WUR;
mp_err mp_to_sbin(const mp_int *a, unsigned char *buf, size_t maxlen, size_t *written) MP_WUR;
mp_err mp_read_radix(mp_int *a, const char *str, int radix) MP_WUR;
MP_DEPRECATED(mp_to_radix) mp_err mp_toradix(const mp_int *a, char *str, int radix) MP_WUR;
MP_DEPRECATED(mp_to_radix) mp_err mp_toradix_n(const mp_int *a, char *str, int radix, int maxlen) MP_WUR;
mp_err mp_to_radix(const mp_int *a, char *str, size_t maxlen, size_t *written, int radix) MP_WUR;
mp_err mp_radix_size(const mp_int *a, int radix, int *size) MP_WUR;
#ifndef MP_NO_FILE
mp_err mp_fread(mp_int *a, int radix, FILE *stream) MP_WUR;
mp_err mp_fwrite(const mp_int *a, int radix, FILE *stream) MP_WUR;
#endif
#define mp_read_raw(mp, str, len) (MP_DEPRECATED_PRAGMA("replaced by mp_read_signed_bin") mp_read_signed_bin((mp), (str), (len)))
#define mp_raw_size(mp) (MP_DEPRECATED_PRAGMA("replaced by mp_signed_bin_size") mp_signed_bin_size(mp))
#define mp_toraw(mp, str) (MP_DEPRECATED_PRAGMA("replaced by mp_to_signed_bin") mp_to_signed_bin((mp), (str)))
#define mp_read_mag(mp, str, len) (MP_DEPRECATED_PRAGMA("replaced by mp_read_unsigned_bin") mp_read_unsigned_bin((mp), (str), (len))
#define mp_mag_size(mp) (MP_DEPRECATED_PRAGMA("replaced by mp_unsigned_bin_size") mp_unsigned_bin_size(mp))
#define mp_tomag(mp, str) (MP_DEPRECATED_PRAGMA("replaced by mp_to_unsigned_bin") mp_to_unsigned_bin((mp), (str)))
#define mp_tobinary(M, S) (MP_DEPRECATED_PRAGMA("replaced by mp_to_binary") mp_toradix((M), (S), 2))
#define mp_tooctal(M, S) (MP_DEPRECATED_PRAGMA("replaced by mp_to_octal") mp_toradix((M), (S), 8))
#define mp_todecimal(M, S) (MP_DEPRECATED_PRAGMA("replaced by mp_to_decimal") mp_toradix((M), (S), 10))
#define mp_tohex(M, S) (MP_DEPRECATED_PRAGMA("replaced by mp_to_hex") mp_toradix((M), (S), 16))
#define mp_to_binary(M, S, N) mp_to_radix((M), (S), (N), NULL, 2)
#define mp_to_octal(M, S, N) mp_to_radix((M), (S), (N), NULL, 8)
#define mp_to_decimal(M, S, N) mp_to_radix((M), (S), (N), NULL, 10)
#define mp_to_hex(M, S, N) mp_to_radix((M), (S), (N), NULL, 16)
#ifdef __cplusplus
}
#endif
#endif

1319
libtom/libtommath/tommath_class.h Normal file
View File

File diff suppressed because it is too large Load Diff

13
libtom/libtommath/tommath_cutoffs.h Normal file
View File

@ -0,0 +1,13 @@
/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
/*
Current values evaluated on an AMD A8-6600K (64-bit).
Type "make tune" to optimize them for your machine but
be aware that it may take a long time. It took 2:30 minutes
on the aforementioned machine for example.
*/
#define MP_DEFAULT_KARATSUBA_MUL_CUTOFF 80
#define MP_DEFAULT_KARATSUBA_SQR_CUTOFF 120
#define MP_DEFAULT_TOOM_MUL_CUTOFF 350
#define MP_DEFAULT_TOOM_SQR_CUTOFF 400

303
libtom/libtommath/tommath_private.h Normal file
View File

@ -0,0 +1,303 @@
/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
#ifndef TOMMATH_PRIV_H_
#define TOMMATH_PRIV_H_
#include "tommath.h"
#include "tommath_class.h"
/*
* Private symbols
* ---------------
*
* On Unix symbols can be marked as hidden if libtommath is compiled
* as a shared object. By default, symbols are visible.
* As of now, this feature is opt-in via the MP_PRIVATE_SYMBOLS define.
*
* On Win32 a .def file must be used to specify the exported symbols.
*/
#if defined (MP_PRIVATE_SYMBOLS) && defined(__GNUC__) && __GNUC__ >= 4
# define MP_PRIVATE __attribute__ ((visibility ("hidden")))
#else
# define MP_PRIVATE
#endif
/* Hardening libtommath
* --------------------
*
* By default memory is zeroed before calling
* MP_FREE to avoid leaking data. This is good
* practice in cryptographical applications.
*
* Note however that memory allocators used
* in cryptographical applications can often
* be configured by itself to clear memory,
* rendering the clearing in tommath unnecessary.
* See for example https://github.com/GrapheneOS/hardened_malloc
* and the option CONFIG_ZERO_ON_FREE.
*
* Furthermore there are applications which
* value performance more and want this
* feature to be disabled. For such applications
* define MP_NO_ZERO_ON_FREE during compilation.
*/
#ifdef MP_NO_ZERO_ON_FREE
# define MP_FREE_BUFFER(mem, size) MP_FREE((mem), (size))
# define MP_FREE_DIGITS(mem, digits) MP_FREE((mem), sizeof (mp_digit) * (size_t)(digits))
#else
# define MP_FREE_BUFFER(mem, size) \
do { \
size_t fs_ = (size); \
void* fm_ = (mem); \
if (fm_ != NULL) { \
MP_ZERO_BUFFER(fm_, fs_); \
MP_FREE(fm_, fs_); \
} \
} while (0)
# define MP_FREE_DIGITS(mem, digits) \
do { \
int fd_ = (digits); \
void* fm_ = (mem); \
if (fm_ != NULL) { \
size_t fs_ = sizeof (mp_digit) * (size_t)fd_; \
MP_ZERO_BUFFER(fm_, fs_); \
MP_FREE(fm_, fs_); \
} \
} while (0)
#endif
#ifdef MP_USE_MEMSET
# include <string.h>
# define MP_ZERO_BUFFER(mem, size) memset((mem), 0, (size))
# define MP_ZERO_DIGITS(mem, digits) \
do { \
int zd_ = (digits); \
if (zd_ > 0) { \
memset((mem), 0, sizeof(mp_digit) * (size_t)zd_); \
} \
} while (0)
#else
# define MP_ZERO_BUFFER(mem, size) \
do { \
size_t zs_ = (size); \
char* zm_ = (char*)(mem); \
while (zs_-- > 0u) { \
*zm_++ = '\0'; \
} \
} while (0)
# define MP_ZERO_DIGITS(mem, digits) \
do { \
int zd_ = (digits); \
mp_digit* zm_ = (mem); \
while (zd_-- > 0) { \
*zm_++ = 0; \
} \
} while (0)
#endif
/* Tunable cutoffs
* ---------------
*
* - In the default settings, a cutoff X can be modified at runtime
* by adjusting the corresponding X_CUTOFF variable.
*
* - Tunability of the library can be disabled at compile time
* by defining the MP_FIXED_CUTOFFS macro.
*
* - There is an additional file tommath_cutoffs.h, which defines
* the default cutoffs. These can be adjusted manually or by the
* autotuner.
*
*/
#ifdef MP_FIXED_CUTOFFS
# include "tommath_cutoffs.h"
# define MP_KARATSUBA_MUL_CUTOFF MP_DEFAULT_KARATSUBA_MUL_CUTOFF
# define MP_KARATSUBA_SQR_CUTOFF MP_DEFAULT_KARATSUBA_SQR_CUTOFF
# define MP_TOOM_MUL_CUTOFF MP_DEFAULT_TOOM_MUL_CUTOFF
# define MP_TOOM_SQR_CUTOFF MP_DEFAULT_TOOM_SQR_CUTOFF
#else
# define MP_KARATSUBA_MUL_CUTOFF KARATSUBA_MUL_CUTOFF
# define MP_KARATSUBA_SQR_CUTOFF KARATSUBA_SQR_CUTOFF
# define MP_TOOM_MUL_CUTOFF TOOM_MUL_CUTOFF
# define MP_TOOM_SQR_CUTOFF TOOM_SQR_CUTOFF
#endif
/* define heap macros */
#ifndef MP_MALLOC
/* default to libc stuff */
# include <stdlib.h>
# define MP_MALLOC(size) malloc(size)
# define MP_REALLOC(mem, oldsize, newsize) realloc((mem), (newsize))
# define MP_CALLOC(nmemb, size) calloc((nmemb), (size))
# define MP_FREE(mem, size) free(mem)
#else
/* prototypes for our heap functions */
extern void *MP_MALLOC(size_t size);
extern void *MP_REALLOC(void *mem, size_t oldsize, size_t newsize);
extern void *MP_CALLOC(size_t nmemb, size_t size);
extern void MP_FREE(void *mem, size_t size);
#endif
/* feature detection macro */
#ifdef _MSC_VER
/* Prevent false positive: not enough arguments for function-like macro invocation */
#pragma warning(disable: 4003)
#endif
#define MP_STRINGIZE(x) MP__STRINGIZE(x)
#define MP__STRINGIZE(x) ""#x""
#define MP_HAS(x) (sizeof(MP_STRINGIZE(BN_##x##_C)) == 1u)
/* TODO: Remove private_mp_word as soon as deprecated mp_word is removed from tommath. */
#undef mp_word
typedef private_mp_word mp_word;
#define MP_MIN(x, y) (((x) < (y)) ? (x) : (y))
#define MP_MAX(x, y) (((x) > (y)) ? (x) : (y))
/* Static assertion */
#define MP_STATIC_ASSERT(msg, cond) typedef char mp_static_assert_##msg[(cond) ? 1 : -1];
/* ---> Basic Manipulations <--- */
#define MP_IS_ZERO(a) ((a)->used == 0)
#define MP_IS_EVEN(a) (((a)->used == 0) || (((a)->dp[0] & 1u) == 0u))
#define MP_IS_ODD(a) (((a)->used > 0) && (((a)->dp[0] & 1u) == 1u))
#define MP_SIZEOF_BITS(type) ((size_t)CHAR_BIT * sizeof(type))
#define MP_MAXFAST (int)(1uL << (MP_SIZEOF_BITS(mp_word) - (2u * (size_t)MP_DIGIT_BIT)))
/* TODO: Remove PRIVATE_MP_WARRAY as soon as deprecated MP_WARRAY is removed from tommath.h */
#undef MP_WARRAY
#define MP_WARRAY PRIVATE_MP_WARRAY
/* TODO: Remove PRIVATE_MP_PREC as soon as deprecated MP_PREC is removed from tommath.h */
#ifdef PRIVATE_MP_PREC
# undef MP_PREC
# define MP_PREC PRIVATE_MP_PREC
#endif
/* Minimum number of available digits in mp_int, MP_PREC >= MP_MIN_PREC */
#define MP_MIN_PREC ((((int)MP_SIZEOF_BITS(long long) + MP_DIGIT_BIT) - 1) / MP_DIGIT_BIT)
MP_STATIC_ASSERT(prec_geq_min_prec, MP_PREC >= MP_MIN_PREC)
/* random number source */
extern MP_PRIVATE mp_err(*s_mp_rand_source)(void *out, size_t size);
/* lowlevel functions, do not call! */
MP_PRIVATE mp_bool s_mp_get_bit(const mp_int *a, unsigned int b);
MP_PRIVATE mp_err s_mp_add(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
MP_PRIVATE mp_err s_mp_sub(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
MP_PRIVATE mp_err s_mp_mul_digs_fast(const mp_int *a, const mp_int *b, mp_int *c, int digs) MP_WUR;
MP_PRIVATE mp_err s_mp_mul_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs) MP_WUR;
MP_PRIVATE mp_err s_mp_mul_high_digs_fast(const mp_int *a, const mp_int *b, mp_int *c, int digs) MP_WUR;
MP_PRIVATE mp_err s_mp_mul_high_digs(const mp_int *a, const mp_int *b, mp_int *c, int digs) MP_WUR;
MP_PRIVATE mp_err s_mp_sqr_fast(const mp_int *a, mp_int *b) MP_WUR;
MP_PRIVATE mp_err s_mp_sqr(const mp_int *a, mp_int *b) MP_WUR;
MP_PRIVATE mp_err s_mp_balance_mul(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
MP_PRIVATE mp_err s_mp_karatsuba_mul(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
MP_PRIVATE mp_err s_mp_toom_mul(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
MP_PRIVATE mp_err s_mp_karatsuba_sqr(const mp_int *a, mp_int *b) MP_WUR;
MP_PRIVATE mp_err s_mp_toom_sqr(const mp_int *a, mp_int *b) MP_WUR;
MP_PRIVATE mp_err s_mp_invmod_fast(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
MP_PRIVATE mp_err s_mp_invmod_slow(const mp_int *a, const mp_int *b, mp_int *c) MP_WUR;
MP_PRIVATE mp_err s_mp_montgomery_reduce_fast(mp_int *x, const mp_int *n, mp_digit rho) MP_WUR;
MP_PRIVATE mp_err s_mp_exptmod_fast(const mp_int *G, const mp_int *X, const mp_int *P, mp_int *Y, int redmode) MP_WUR;
MP_PRIVATE mp_err s_mp_exptmod(const mp_int *G, const mp_int *X, const mp_int *P, mp_int *Y, int redmode) MP_WUR;
MP_PRIVATE mp_err s_mp_rand_platform(void *p, size_t n) MP_WUR;
MP_PRIVATE mp_err s_mp_prime_random_ex(mp_int *a, int t, int size, int flags, private_mp_prime_callback cb, void *dat);
MP_PRIVATE void s_mp_reverse(unsigned char *s, size_t len);
MP_PRIVATE mp_err s_mp_prime_is_divisible(const mp_int *a, mp_bool *result);
/* TODO: jenkins prng is not thread safe as of now */
MP_PRIVATE mp_err s_mp_rand_jenkins(void *p, size_t n) MP_WUR;
MP_PRIVATE void s_mp_rand_jenkins_init(uint64_t seed);
extern MP_PRIVATE const char *const mp_s_rmap;
extern MP_PRIVATE const uint8_t mp_s_rmap_reverse[];
extern MP_PRIVATE const size_t mp_s_rmap_reverse_sz;
extern MP_PRIVATE const mp_digit *s_mp_prime_tab;
/* deprecated functions */
MP_DEPRECATED(s_mp_invmod_fast) mp_err fast_mp_invmod(const mp_int *a, const mp_int *b, mp_int *c);
MP_DEPRECATED(s_mp_montgomery_reduce_fast) mp_err fast_mp_montgomery_reduce(mp_int *x, const mp_int *n,
mp_digit rho);
MP_DEPRECATED(s_mp_mul_digs_fast) mp_err fast_s_mp_mul_digs(const mp_int *a, const mp_int *b, mp_int *c,
int digs);
MP_DEPRECATED(s_mp_mul_high_digs_fast) mp_err fast_s_mp_mul_high_digs(const mp_int *a, const mp_int *b,
mp_int *c,
int digs);
MP_DEPRECATED(s_mp_sqr_fast) mp_err fast_s_mp_sqr(const mp_int *a, mp_int *b);
MP_DEPRECATED(s_mp_balance_mul) mp_err mp_balance_mul(const mp_int *a, const mp_int *b, mp_int *c);
MP_DEPRECATED(s_mp_exptmod_fast) mp_err mp_exptmod_fast(const mp_int *G, const mp_int *X, const mp_int *P,
mp_int *Y,
int redmode);
MP_DEPRECATED(s_mp_invmod_slow) mp_err mp_invmod_slow(const mp_int *a, const mp_int *b, mp_int *c);
MP_DEPRECATED(s_mp_karatsuba_mul) mp_err mp_karatsuba_mul(const mp_int *a, const mp_int *b, mp_int *c);
MP_DEPRECATED(s_mp_karatsuba_sqr) mp_err mp_karatsuba_sqr(const mp_int *a, mp_int *b);
MP_DEPRECATED(s_mp_toom_mul) mp_err mp_toom_mul(const mp_int *a, const mp_int *b, mp_int *c);
MP_DEPRECATED(s_mp_toom_sqr) mp_err mp_toom_sqr(const mp_int *a, mp_int *b);
MP_DEPRECATED(s_mp_reverse) void bn_reverse(unsigned char *s, int len);
#define MP_GET_ENDIANNESS(x) \
do{\
int16_t n = 0x1; \
char *p = (char *)&n; \
x = (p[0] == '\x01') ? MP_LITTLE_ENDIAN : MP_BIG_ENDIAN; \
} while (0)
/* code-generating macros */
#define MP_SET_UNSIGNED(name, type) \
void name(mp_int * a, type b) \
{ \
int i = 0; \
while (b != 0u) { \
a->dp[i++] = ((mp_digit)b & MP_MASK); \
if (MP_SIZEOF_BITS(type) <= MP_DIGIT_BIT) { break; } \
b >>= ((MP_SIZEOF_BITS(type) <= MP_DIGIT_BIT) ? 0 : MP_DIGIT_BIT); \
} \
a->used = i; \
a->sign = MP_ZPOS; \
MP_ZERO_DIGITS(a->dp + a->used, a->alloc - a->used); \
}
#define MP_SET_SIGNED(name, uname, type, utype) \
void name(mp_int * a, type b) \
{ \
uname(a, (b < 0) ? -(utype)b : (utype)b); \
if (b < 0) { a->sign = MP_NEG; } \
}
#define MP_INIT_INT(name , set, type) \
mp_err name(mp_int * a, type b) \
{ \
mp_err err; \
if ((err = mp_init(a)) != MP_OKAY) { \
return err; \
} \
set(a, b); \
return MP_OKAY; \
}
#define MP_GET_MAG(name, type) \
type name(const mp_int* a) \
{ \
unsigned i = MP_MIN((unsigned)a->used, (unsigned)((MP_SIZEOF_BITS(type) + MP_DIGIT_BIT - 1) / MP_DIGIT_BIT)); \
type res = 0u; \
while (i --> 0u) { \
res <<= ((MP_SIZEOF_BITS(type) <= MP_DIGIT_BIT) ? 0 : MP_DIGIT_BIT); \
res |= (type)a->dp[i]; \
if (MP_SIZEOF_BITS(type) <= MP_DIGIT_BIT) { break; } \
} \
return res; \
}
#define MP_GET_SIGNED(name, mag, type, utype) \
type name(const mp_int* a) \
{ \
utype res = mag(a); \
return (a->sign == MP_NEG) ? (type)-res : (type)res; \
}
#endif

110
libtom/libtommath/tommath_superclass.h Normal file
View File

@ -0,0 +1,110 @@
/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
/* super class file for PK algos */
/* default ... include all MPI */
#ifndef LTM_NOTHING
#define LTM_ALL
#endif
/* RSA only (does not support DH/DSA/ECC) */
/* #define SC_RSA_1 */
/* #define SC_RSA_1_WITH_TESTS */
/* For reference.... On an Athlon64 optimizing for speed...
LTM's mpi.o with all functions [striped] is 142KiB in size.
*/
#ifdef SC_RSA_1_WITH_TESTS
# define BN_MP_ERROR_TO_STRING_C
# define BN_MP_FREAD_C
# define BN_MP_FWRITE_C
# define BN_MP_INCR_C
# define BN_MP_ISEVEN_C
# define BN_MP_ISODD_C
# define BN_MP_NEG_C
# define BN_MP_PRIME_FROBENIUS_UNDERWOOD_C
# define BN_MP_RADIX_SIZE_C
# define BN_MP_RAND_C
# define BN_MP_REDUCE_C
# define BN_MP_REDUCE_2K_L_C
# define BN_MP_FROM_SBIN_C
# define BN_MP_ROOT_U32_C
# define BN_MP_SET_L_C
# define BN_MP_SET_UL_C
# define BN_MP_SBIN_SIZE_C
# define BN_MP_TO_RADIX_C
# define BN_MP_TO_SBIN_C
# define BN_S_MP_RAND_JENKINS_C
# define BN_S_MP_RAND_PLATFORM_C
#endif
/* Works for RSA only, mpi.o is 68KiB */
#if defined(SC_RSA_1) || defined (SC_RSA_1_WITH_TESTS)
# define BN_CUTOFFS_C
# define BN_MP_ADDMOD_C
# define BN_MP_CLEAR_MULTI_C
# define BN_MP_EXPTMOD_C
# define BN_MP_GCD_C
# define BN_MP_INIT_MULTI_C
# define BN_MP_INVMOD_C
# define BN_MP_LCM_C
# define BN_MP_MOD_C
# define BN_MP_MOD_D_C
# define BN_MP_MULMOD_C
# define BN_MP_PRIME_IS_PRIME_C
# define BN_MP_PRIME_RABIN_MILLER_TRIALS_C
# define BN_MP_PRIME_RAND_C
# define BN_MP_RADIX_SMAP_C
# define BN_MP_SET_INT_C
# define BN_MP_SHRINK_C
# define BN_MP_TO_UNSIGNED_BIN_C
# define BN_MP_UNSIGNED_BIN_SIZE_C
# define BN_PRIME_TAB_C
# define BN_S_MP_REVERSE_C
/* other modifiers */
# define BN_MP_DIV_SMALL /* Slower division, not critical */
/* here we are on the last pass so we turn things off. The functions classes are still there
* but we remove them specifically from the build. This also invokes tweaks in functions
* like removing support for even moduli, etc...
*/
# ifdef LTM_LAST
# undef BN_MP_DR_IS_MODULUS_C
# undef BN_MP_DR_SETUP_C
# undef BN_MP_DR_REDUCE_C
# undef BN_MP_DIV_3_C
# undef BN_MP_REDUCE_2K_SETUP_C
# undef BN_MP_REDUCE_2K_C
# undef BN_MP_REDUCE_IS_2K_C
# undef BN_MP_REDUCE_SETUP_C
# undef BN_S_MP_BALANCE_MUL_C
# undef BN_S_MP_EXPTMOD_C
# undef BN_S_MP_INVMOD_FAST_C
# undef BN_S_MP_KARATSUBA_MUL_C
# undef BN_S_MP_KARATSUBA_SQR_C
# undef BN_S_MP_MUL_HIGH_DIGS_C
# undef BN_S_MP_MUL_HIGH_DIGS_FAST_C
# undef BN_S_MP_TOOM_MUL_C
# undef BN_S_MP_TOOM_SQR_C
# ifndef SC_RSA_1_WITH_TESTS
# undef BN_MP_REDUCE_C
# endif
/* To safely undefine these you have to make sure your RSA key won't exceed the Comba threshold
* which is roughly 255 digits [7140 bits for 32-bit machines, 15300 bits for 64-bit machines]
* which means roughly speaking you can handle upto 2536-bit RSA keys with these defined without
* trouble.
*/
# undef BN_MP_MONTGOMERY_REDUCE_C
# undef BN_S_MP_MUL_DIGS_C
# undef BN_S_MP_SQR_C
# endif
#endif

31
ultimateteknotool.v2.sln Normal file
View File

@ -0,0 +1,31 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.29806.167
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ultimateteknotool.v2", "ultimateteknotool.v2\ultimateteknotool.v2.vcxproj", "{95BE6499-8951-48EA-BF37-4EA0EF2FA58B}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{95BE6499-8951-48EA-BF37-4EA0EF2FA58B}.Debug|x64.ActiveCfg = Debug|x64
{95BE6499-8951-48EA-BF37-4EA0EF2FA58B}.Debug|x64.Build.0 = Debug|x64
{95BE6499-8951-48EA-BF37-4EA0EF2FA58B}.Debug|x86.ActiveCfg = Debug|Win32
{95BE6499-8951-48EA-BF37-4EA0EF2FA58B}.Debug|x86.Build.0 = Debug|Win32
{95BE6499-8951-48EA-BF37-4EA0EF2FA58B}.Release|x64.ActiveCfg = Release|x64
{95BE6499-8951-48EA-BF37-4EA0EF2FA58B}.Release|x64.Build.0 = Release|x64
{95BE6499-8951-48EA-BF37-4EA0EF2FA58B}.Release|x86.ActiveCfg = Release|Win32
{95BE6499-8951-48EA-BF37-4EA0EF2FA58B}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {2F846983-2EAE-4CE2-9FC3-21A34CD4E479}
EndGlobalSection
EndGlobal

88
ultimateteknotool.v2/CWinAPIFileW.cpp Normal file
View File

@ -0,0 +1,88 @@
#include "pch.h"
#include "CWinAPIFileW.h"
constexpr LARGE_INTEGER zero = { 0 };
CWinAPIFileW::CWinAPIFileW()
{
}
CWinAPIFileW::~CWinAPIFileW()
{
if (this->m_hFile != INVALID_HANDLE_VALUE)
{
::CloseHandle(this->m_hFile);
}
}
bool CWinAPIFileW::OpenForWriting(wchar_t* name)
{
this->Close();
this->m_hFile = CreateFileW(name, GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (this->m_hFile != INVALID_HANDLE_VALUE)
{
return true;
}
return false;
}
void CWinAPIFileW::WriteInAppend(const char* src, size_t len)
{
if (::SetFilePointerEx(this->m_hFile, zero, NULL, FILE_END))
/* If the function succeeds, the return value is nonzero. */
{
::WriteFile(this->m_hFile, src, len, &m_byteswriten, NULL);
}
}
bool CWinAPIFileW::OpenForReading(wchar_t* name)
{
this->Close();
this->m_hFile = CreateFileW(name, GENERIC_READ, 0, NULL,
OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (this->m_hFile != INVALID_HANDLE_VALUE)
{
return true;
}
return false;
}
void CWinAPIFileW::ReadFrom(char* dst, size_t len)
{
::ReadFile(this->m_hFile, dst, len, &m_bytesread, NULL);
}
void CWinAPIFileW::Truncate(wchar_t* name)
{
this->Close();
this->m_hFile = CreateFileW(name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
TRUNCATE_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
this->Close();
}
bool CWinAPIFileW::IsFileExist(wchar_t* name) const
{
HANDLE DummyBoi = INVALID_HANDLE_VALUE;
DummyBoi = CreateFileW(name, 0, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (DummyBoi != INVALID_HANDLE_VALUE)
{
::CloseHandle(DummyBoi);
return true;
}
return false;
}
void CWinAPIFileW::Close()
{
if (this->m_hFile != INVALID_HANDLE_VALUE)
{
::CloseHandle(this->m_hFile);
}
}

24
ultimateteknotool.v2/CWinAPIFileW.h Normal file
View File

@ -0,0 +1,24 @@
#pragma once
#include <windows.h>
#include "debugconsole.h"
class CWinAPIFileW
{
private:
//static constexpr unsigned short MAX_LENOFNAME = 64;
//wchar_t m_wsName[MAX_LENOFNAME] = { 0 };
HANDLE m_hFile = INVALID_HANDLE_VALUE;
DWORD m_byteswriten = 0;
DWORD m_bytesread = 0;
public:
CWinAPIFileW();
~CWinAPIFileW();
bool OpenForWriting(wchar_t* name);
void WriteInAppend(const char* src, size_t len);
bool OpenForReading(wchar_t* name);
void ReadFrom(char* dst, size_t len);
void Truncate(wchar_t* name);
bool IsFileExist(wchar_t* name) const;
void Close();
};

166
ultimateteknotool.v2/CWindowCfgReader.cpp Normal file
View File

@ -0,0 +1,166 @@
#include "pch.h"
#include "CWindowCfgReader.h"
//static constexpr unsigned short chuck_sz = 32;
inline void CWindowCfgReader::IncrTotal_DeserialSuccess()
{
this->m_wcharsreadtotal += this->m_deserialwcharsread;
if (this->m_buffersize > this->m_deserialwcharsread) { this->m_buffersize -= this->m_deserialwcharsread; }
else
{
this->m_buffersize = 0;
}
}
inline void CWindowCfgReader::IncrTotal_DeserialFailed()
{
this->m_wcharsreadtotal++;
if (this->m_buffersize > 0) { this->m_buffersize--; }
else
{
this->m_buffersize = 0;
}
}
void CWindowCfgReader::LoadTextSettingW(CWindow_edit_cfg* win, unsigned short textlimit)
{
wchar_t* pointer;
pointer = lazysectionbuffer_3x512.GetNulledMem(textlimit + 4, 0);
this->m_deserialwcharsread = serializer::DeserialTextW(&this->m_buffer[this->m_wcharsreadtotal], this->m_buffersize, pointer, textlimit);
if (this->m_deserialwcharsread)
{
//if (chuck_sz > textlimit && textlimit >= 1)
//{
// pointer[textlimit - 1] = 0x00;
//}
//else
//{
// pointer[chuck_sz - 1] = 0x00;
//}
CWindowTextWriter_WriteText(win, pointer);
this->IncrTotal_DeserialSuccess();
}
else
{
this->IncrTotal_DeserialFailed();
}
}
void CWindowCfgReader::LoadButtonStateW(CWindow_button_cfg* win)
{
this->m_deserialwcharsread = serializer::DeserialButtonStateW(&this->m_buffer[this->m_wcharsreadtotal], this->m_buffersize, win->isPressed);
if (this->m_deserialwcharsread)
{
if (win->isPressed)
{
::SendMessageW(win->hwnd, BM_SETCHECK, BST_CHECKED, NULL);
}
else
{
::SendMessageW(win->hwnd, BM_SETCHECK, BST_UNCHECKED, NULL);
}
this->IncrTotal_DeserialSuccess();
}
else
{
this->IncrTotal_DeserialFailed();
}
}
bool CWindowCfgReader::LoadButtonStateW()
{
bool ret = false;
this->m_deserialwcharsread = serializer::DeserialButtonStateW(&this->m_buffer[this->m_wcharsreadtotal], this->m_buffersize, ret);
if (this->m_deserialwcharsread)
{
this->IncrTotal_DeserialSuccess();
}
else
{
this->IncrTotal_DeserialFailed();
}
return ret;
}
const wchar_t* CWindowCfgReader::LoadTextSettingW(unsigned short textlimit)
{
wchar_t* pointer;
pointer = lazysectionbuffer_3x512.GetNulledMem(textlimit + 4, 0);
this->m_deserialwcharsread = serializer::DeserialTextW(&this->m_buffer[this->m_wcharsreadtotal], this->m_buffersize, pointer, textlimit);
if (this->m_deserialwcharsread)
{
//if (chuck_sz > textlimit && textlimit >= 1)
//{
// pointer[textlimit - 1] = 0x00;
//}
//else
//{
// pointer[chuck_sz - 1] = 0x00;
//}
this->IncrTotal_DeserialSuccess();
}
else
{
pointer[0] = 0x0000;
this->IncrTotal_DeserialFailed();
}
return pointer;
}
constexpr unsigned char EXTRA_SPACE_BUFF = 1;
wchar_t* CWindowPostLoadStrings::GetMemoryForString(unsigned short textlimit)
{
if ((textlimit + this->currentUsedSize) >= wchart_buffer.size())
{
return nullptr;
}
else
{
this->currentUsedSize += textlimit;
return wchart_buffer.data() + (this->currentUsedSize - textlimit);
}
}
void CWindowPostLoadStrings::Register(size_t buffersize)
{
this->Unregister();
wchart_buffer.resize(buffersize, 0x0000);
}
void CWindowPostLoadStrings::Unregister()
{
if (this->wchart_buffer.empty() == false)
{
this->wchart_buffer.clear();
}
if (this->pairs.empty() == false)
{
this->pairs.clear();
}
this->currentUsedSize = 0;
}
void CWindowPostLoadStrings::LoadTextSettingW(CWindow_edit_cfg* win, const wchar_t* ptxt, unsigned short textlimit)
{
wchar_t* pp = nullptr;
pp = this->GetMemoryForString(textlimit + EXTRA_SPACE_BUFF);
if (pp != nullptr)
{
for (unsigned short i = 0; i < textlimit && ptxt[i]; i++)
{
pp[i] = ptxt[i];
}
this->pairs.push_back(std::pair<CWindow_edit_cfg*, wchar_t*>(win, pp));
}
}
void CWindowPostLoadStrings::LoadTextInEdits()
{
for (auto& x : this->pairs)
{
CWindowTextWriter_WriteText(x.first, x.second);
}
}

77
ultimateteknotool.v2/CWindowCfgReader.h Normal file
View File

@ -0,0 +1,77 @@
#pragma once
#include "CWinAPIFileW.h"
#include "CWindow_edit_cfg.h"
#include "CWindow_button_cfg.h"
#include "CWindowTextWriter.h"
#include "Serializers.h"
#include "LazyBuffer_512wchart.h"
class CWindowCfgReader
{
private:
wchar_t* m_buffer = nullptr;
size_t m_buffersize = 0;
size_t m_deserialwcharsread = 0;
size_t m_wcharsreadtotal = 0;
inline void IncrTotal_DeserialSuccess();
inline void IncrTotal_DeserialFailed();
public:
CWindowCfgReader() = delete;
CWindowCfgReader(wchar_t* p, size_t sz) :m_buffer(p), m_buffersize(sz) {
this->m_deserialwcharsread = 0; this->m_wcharsreadtotal = 0;
}
~CWindowCfgReader() = default;
void LoadTextSettingW(CWindow_edit_cfg* win, unsigned short textlimit);
void LoadButtonStateW(CWindow_button_cfg* win);
bool LoadButtonStateW();
const wchar_t* LoadTextSettingW(unsigned short textlimit);
};
class CWindowPostLoadStrings
{
private:
std::vector<wchar_t> wchart_buffer;
std::vector<std::pair<CWindow_edit_cfg*, wchar_t*>> pairs;
size_t currentUsedSize = 0;
wchar_t* GetMemoryForString(unsigned short textlimit);
public:
CWindowPostLoadStrings() = default;
~CWindowPostLoadStrings() = default;
void Register(size_t buffersize);
void Unregister();
void LoadTextSettingW(CWindow_edit_cfg* win, const wchar_t* ptxt, unsigned short textlimit);
void LoadTextInEdits();
};
class CWindowButtonStatePostLoader : public WindowsVisitor
{
virtual void Visit(CWindow_edit* win) override
{
return;
}
virtual void Visit(CWindow_edit_cfg* win) override
{
return;
}
virtual void Visit(CWindow_button* win) override
{
return;
}
virtual void Visit(CWindow_button_cfg* win) override
{
if (win->isPressed)
{
::SendMessageW(win->hwnd, BM_SETCHECK, BST_CHECKED, NULL);
}
else
{
::SendMessageW(win->hwnd, BM_SETCHECK, BST_UNCHECKED, NULL);
}
}
virtual void Visit(CWindow_static* win) override
{
return;
}
};

50
ultimateteknotool.v2/CWindowCfgWriter.cpp Normal file
View File

@ -0,0 +1,50 @@
#include "pch.h"
#include "CWindowCfgWriter.h"
static constexpr wchar_t dummytext[] = L"\0\0\0\0";
//void CWindowCfgWriter_SaveTextSetting(CWindow_edit_cfg* win, CWinAPIFileW* apifile)
//{
// // read window
// // serialize
// // write file
// //
//}
//
//
//void CWindowCfgWriter_SaveButtonSetting(CWindow_button_cfg* win, CWinAPIFileW* apifile)
//{
// serializer::ButtonStateWDescriptor desc = { 0 };
// bytes_serialized = serializer::SerialButtonStateW(win->isPressed, desc);
// apifile->WriteInAppend((char*)desc.text, bytes_serialized * sizeof(wchar_t));
//}
void CWindowCfgWriter::DecreaseBufferSize(size_t value)
{
if (value >= this->m_buffersize)
{
this->m_buffersize = 0;
}
else
{
this->m_buffersize = this->m_buffersize - value;
}
}
void CWindowCfgWriter::SaveTextSettingW(CWindow_edit_cfg* win, unsigned short chunk)
{
const wchar_t* dummyboi = dummytext;
dummyboi = CWindowTextReader_GetTextW(win, chunk);
if (this->m_wcharswrotetotal >= this->m_constBufferSizeVerifyValue) { throw 1; }
this->m_serialwcharswrote = serializer::SerialTextW(dummyboi, chunk, &(this->m_buffer[this->m_wcharswrotetotal]), this->m_buffersize);
this->m_wcharswrotetotal += this->m_serialwcharswrote;
this->DecreaseBufferSize(this->m_serialwcharswrote);
}
void CWindowCfgWriter::SaveButtonStateW(CWindow_button_cfg* win)
{
if (this->m_wcharswrotetotal >= this->m_constBufferSizeVerifyValue) { throw 1; }
this->m_serialwcharswrote = serializer::SerialButtonStateW(win->isPressed, &(this->m_buffer[this->m_wcharswrotetotal]), this->m_buffersize);
this->m_wcharswrotetotal += this->m_serialwcharswrote;
this->DecreaseBufferSize(this->m_serialwcharswrote);
}

32
ultimateteknotool.v2/CWindowCfgWriter.h Normal file
View File

@ -0,0 +1,32 @@
#pragma once
#include "CWinAPIFileW.h"
#include "CWindow_edit_cfg.h"
#include "CWindow_button_cfg.h"
#include "CWindowTextReader.h"
#include "Serializers.h"
class CWindowCfgWriter
{
private:
wchar_t* m_buffer = nullptr;
const size_t m_constBufferSizeVerifyValue = 0;
size_t m_buffersize = 0;
size_t m_serialwcharswrote = 0;
size_t m_wcharswrotetotal = 0;
void DecreaseBufferSize(size_t value);
public:
CWindowCfgWriter() = delete;
CWindowCfgWriter(wchar_t* p, size_t sz) :m_buffer(p), m_buffersize(sz), m_constBufferSizeVerifyValue(sz) {
this->m_serialwcharswrote = 0; this->m_wcharswrotetotal = 0;
}
~CWindowCfgWriter() = default;
void SaveTextSettingW(CWindow_edit_cfg* win, unsigned short chunk = 32);
void SaveButtonStateW(CWindow_button_cfg* win);
size_t GetTotalBytesWriten() const { return this->m_wcharswrotetotal; }
};
//void CWindowCfgWriter_SaveTextSetting(CWindow_edit_cfg* win, CWinAPIFileW* apifile);
//void CWindowCfgWriter_SaveButtonSetting(CWindow_button_cfg* win, CWinAPIFileW* apifile);

2
ultimateteknotool.v2/CWindowFileW.cpp Normal file
View File

@ -0,0 +1,2 @@
#include "pch.h"
#include "CWinAPIFileW.h"

13
ultimateteknotool.v2/CWindowTextLimiter.cpp Normal file
View File

@ -0,0 +1,13 @@
#include "pch.h"
#include "CWindowTextLimiter.h"
static_assert(sizeof(WPARAM) >= sizeof(size_t), "SendMessage requires WPARAM type arg#3");
void CWindowTextLimiter_LimitText(CWindow_edit* win, size_t limit)
{
if (limit) { ::SendMessageW(win->hwnd, EM_SETLIMITTEXT, limit, 0); }
}
void CWindowTextLimiter_LimitText(CWindow_edit_cfg* win, size_t limit)
{
if (limit) { ::SendMessageW(win->hwnd, EM_SETLIMITTEXT, limit, 0); }
}

14
ultimateteknotool.v2/CWindowTextLimiter.h Normal file
View File

@ -0,0 +1,14 @@
#pragma once
#include <windows.h>
#include "WindowsVisitor.h"
#include "CWindow_hwnd.h"
#include "CWindow_edit.h"
#include "CWindow_button.h"
#include "CWindow_edit_cfg.h"
#include "CWindow_button_cfg.h"
#include "CWindow_static.h"
void CWindowTextLimiter_LimitText(CWindow_edit* win, size_t limit);
void CWindowTextLimiter_LimitText(CWindow_edit_cfg* win, size_t limit);

50
ultimateteknotool.v2/CWindowTextReader.cpp Normal file
View File

@ -0,0 +1,50 @@
#include "pch.h"
#include "CWindowTextReader.h"
#include "ParserRandMask.h"
#include "LazyBuffer.h"
wchar_t* CWindowTextReader_GetTextW(CWindow_edit* win, unsigned short maxchunksz)
{
wchar_t* future_text = lazysectionbuffer_3x512.GetNulledMem(maxchunksz + 4, 0);
::GetWindowTextW(win->hwnd, future_text, maxchunksz);
return future_text;
}
wchar_t* CWindowTextReader_GetTextW(CWindow_edit_cfg* win, unsigned short maxchunksz)
{
wchar_t* future_text = lazysectionbuffer_3x512.GetNulledMem(maxchunksz + 4, 0);
::GetWindowTextW(win->hwnd, future_text, maxchunksz);
return future_text;
}
wchar_t* CWindowTextReader_GetTextW_ParseRandMask(CWindow_edit_cfg* win, unsigned short maxchunksz)
{
wchar_t* future_text = lazysectionbuffer_3x512.GetNulledMem(maxchunksz + maxchunksz + 4, 1);
/* fix for overwrite func -> prevent double call*/
::GetWindowTextW(win->hwnd, future_text + maxchunksz + 1, maxchunksz);
parsers::ParseRandMaskTextW(future_text + maxchunksz + 1, maxchunksz, future_text, maxchunksz);
return future_text;
}
wchar_t* CWindowTextReader_GetTextW_ParseRandMask_Overwrite(CWindow_edit_cfg* normal, CWindow_edit_cfg* rand, unsigned short maxchunksz)
{
wchar_t* normal_text = CWindowTextReader_GetTextW(normal, maxchunksz);
wchar_t* rand_text = CWindowTextReader_GetTextW_ParseRandMask(rand, maxchunksz);
wchar_t* future_text = lazysectionbuffer_3x512.GetNulledMem(maxchunksz + 4, 2);
for (unsigned short i = 0; i < maxchunksz && (normal_text[i] || rand_text[i]); i++)
{
if (rand_text[i] != L' ')
{
future_text[i] = rand_text[i];
}
else
{
future_text[i] = normal_text[i];
}
}
return future_text;
}

45
ultimateteknotool.v2/CWindowTextReader.h Normal file
View File

@ -0,0 +1,45 @@
#pragma once
#include <windows.h>
#include "WindowsVisitor.h"
#include "CWindow_hwnd.h"
#include "CWindow_edit.h"
#include "CWindow_button.h"
#include "CWindow_edit_cfg.h"
#include "CWindow_button_cfg.h"
#include "CWindow_static.h"
#include "LazyBuffer_512wchart.h"
// bad idea
//class CWindowTextReader : public WindowsVisitor
//{
//private:
// unsigned short maxchunksize = 32;
//public:
// void ChangeMaxChunkSize(unsigned short value) { if (value) { this->maxchunksize = value; } }
// virtual void Visit(CWindow_edit* win) override
// {
// ::GetWindowTextW(win->hwnd, lazybuffer512wchart.GetNulledMem(maxchunksize), maxchunksize);
// }
// virtual void Visit(CWindow_edit_cfg* win) override
// {
// ::GetWindowTextW(win->hwnd, lazybuffer512wchart.GetNulledMem(maxchunksize), maxchunksize);
// }
// virtual void Visit(CWindow_button* win) override
// {
// /* lmao, no */
// }
// virtual void Visit(CWindow_button_cfg* win) override
// {
// /* lmao, no */
// }
// virtual void Visit(CWindow_static* win) override
// {
// /* lmao, no */
// }
//};
wchar_t* CWindowTextReader_GetTextW(CWindow_edit* win, unsigned short maxchunksz);
wchar_t* CWindowTextReader_GetTextW(CWindow_edit_cfg* win, unsigned short maxchunksz);
wchar_t* CWindowTextReader_GetTextW_ParseRandMask(CWindow_edit_cfg* win, unsigned short maxchunksz);
wchar_t* CWindowTextReader_GetTextW_ParseRandMask_Overwrite(CWindow_edit_cfg* normal, CWindow_edit_cfg* rand, unsigned short maxchunksz);

18
ultimateteknotool.v2/CWindowTextWriter.cpp Normal file
View File

@ -0,0 +1,18 @@
#include "pch.h"
#include "CWindowTextWriter.h"
void CWindowTextWriter_WriteText(CWindow_edit* win, const wchar_t* text)
{
if (text != nullptr)
{
::SetWindowTextW(win->hwnd, text);
}
}
void CWindowTextWriter_WriteText(CWindow_edit_cfg* win, const wchar_t* text)
{
if (text != nullptr)
{
::SetWindowTextW(win->hwnd, text);
}
}

20
ultimateteknotool.v2/CWindowTextWriter.h Normal file
View File

@ -0,0 +1,20 @@
#pragma once
#include <windows.h>
#include "WindowsVisitor.h"
#include "CWindow_hwnd.h"
#include "CWindow_edit.h"
#include "CWindow_button.h"
#include "CWindow_edit_cfg.h"
#include "CWindow_button_cfg.h"
#include "CWindow_static.h"
static_assert(nullptr == 0, "nullptr is not 0");
namespace cwindowtextwriter_internal {
constexpr wchar_t ws_emptytext[] = L"";
}
void CWindowTextWriter_WriteText(CWindow_edit* win, const wchar_t* text);
void CWindowTextWriter_WriteText(CWindow_edit_cfg* win, const wchar_t* text);

2
ultimateteknotool.v2/CWindow_button.cpp Normal file
View File

@ -0,0 +1,2 @@
#include "pch.h"
#include "CWindow_button.h"

12
ultimateteknotool.v2/CWindow_button.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include "CWindow_hwnd.h"
class CWindow_button : public CWindow_hwnd, public CWindow_abs_temp<CWindow_button>
{
public:
DWORD id = 0;
CWindow_button() :CWindow_hwnd() { id = 0; }
~CWindow_button() = default;
//DWORD GetID()const { return this->id; }
};

2
ultimateteknotool.v2/CWindow_button_cfg.cpp Normal file
View File

@ -0,0 +1,2 @@
#include "pch.h"
#include "CWindow_button_cfg.h"

15
ultimateteknotool.v2/CWindow_button_cfg.h Normal file
View File

@ -0,0 +1,15 @@
#pragma once
#include "CWindow_hwnd.h"
class CWindow_button_cfg : public CWindow_hwnd, public CWindow_abs_temp<CWindow_button_cfg>
{
private:
public:
DWORD id = 0; /*LOWORD of WPARAM = UINT_PTR*/
bool isPressed = false;
CWindow_button_cfg() :CWindow_hwnd() {}
~CWindow_button_cfg() = default;
void SwitchState() { isPressed = !isPressed; }
};

2
ultimateteknotool.v2/CWindow_edit.cpp Normal file
View File

@ -0,0 +1,2 @@
#include "pch.h"
#include "CWindow_edit.h"

12
ultimateteknotool.v2/CWindow_edit.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include "CWindow_hwnd.h"
class CWindow_edit : public CWindow_hwnd, public CWindow_abs_temp<CWindow_edit>
{
private:
public:
CWindow_edit():CWindow_hwnd(){}
~CWindow_edit() = default;
};

2
ultimateteknotool.v2/CWindow_edit_cfg.cpp Normal file
View File

@ -0,0 +1,2 @@
#include "pch.h"
#include "CWindow_edit_cfg.h"

12
ultimateteknotool.v2/CWindow_edit_cfg.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include "CWindow_hwnd.h"
class CWindow_edit_cfg : public CWindow_hwnd, public CWindow_abs_temp<CWindow_edit_cfg>
{
private:
public:
CWindow_edit_cfg() :CWindow_hwnd() {}
~CWindow_edit_cfg() = default;
};

36
ultimateteknotool.v2/CWindow_hwnd.h Normal file
View File

@ -0,0 +1,36 @@
#pragma once
#include <windows.h>
#include "WindowsVisitor.h"
//struct WindowsVisitor;
class CWindow_abs
{
public:
virtual void Visit(WindowsVisitor* v) = 0;
virtual ~CWindow_abs() = default;
};
template<class T>
class CWindow_abs_temp : public CWindow_abs
{
public:
CWindow_abs_temp() {}
void Visit(WindowsVisitor* v) override
{
v->Visit(static_cast<T*>(this));
}
};
class CWindow_hwnd
{
private:
public:
HWND hwnd = NULL;
CWindow_hwnd():hwnd(0){}
virtual ~CWindow_hwnd() = default;
void Show() const { ::ShowWindow(this->hwnd, SW_SHOW); }
void Hide() const { ::ShowWindow(this->hwnd, SW_HIDE); }
};

2
ultimateteknotool.v2/CWindow_static.cpp Normal file
View File

@ -0,0 +1,2 @@
#include "pch.h"
#include "CWindow_static.h"

10
ultimateteknotool.v2/CWindow_static.h Normal file
View File

@ -0,0 +1,10 @@
#pragma once
#include "CWindow_hwnd.h"
class CWindow_static : public CWindow_hwnd , public CWindow_abs_temp<CWindow_static>
{
public:
CWindow_static():CWindow_hwnd(){}
~CWindow_static() = default;
};

75
ultimateteknotool.v2/CWindowsBuilder.h Normal file
View File

@ -0,0 +1,75 @@
#pragma once
#include "WindowsVisitor.h"
#include "CWindow_hwnd.h"
#include "CWindow_edit.h"
#include "CWindow_button.h"
#include "CWindow_edit_cfg.h"
#include "CWindow_button_cfg.h"
#include "CWindow_static.h"
class CWindowsBuilder : public WindowsVisitor
{
private:
const wchar_t* build_text = (wchar_t*)L" ";
DWORD build_style = ~WS_VISIBLE;
HWND build_parenthwnd = NULL;
DWORD build_uniqueid = 1;
public:
int build_left_pos = 0;
int build_top_pos = 0;
int build_width = 0;
int build_height = 0;
void ChangeTextP(const wchar_t* only_static_text) { this->build_text = only_static_text; }
void ChangeStyle(DWORD style) { this->build_style = style; }
void ChangeLeftPos(int pos) { this->build_left_pos = pos; }
void ChangeTopPos(int pos) { this->build_top_pos = pos; }
void ChangeWidth(int sz) { this->build_width = sz; }
void ChangeHeight(int sz) { this->build_height = sz; }
void ChangeParentHWND(HWND newhwnd) { this->build_parenthwnd = newhwnd; }
/*void ChangeUniqueID(DWORD id) { this->build_uniqueid = id; }*/
virtual void Visit(CWindow_edit* win) override
{
win->hwnd = ::CreateWindowExW(
0, L"edit",
build_text, build_style,
build_left_pos, build_top_pos, build_width, build_height,
build_parenthwnd, 0, 0, 0);
}
virtual void Visit(CWindow_edit_cfg* win) override
{
win->hwnd = ::CreateWindowExW(
0, L"edit",
build_text, build_style,
build_left_pos, build_top_pos, build_width, build_height,
build_parenthwnd, 0, 0, 0);
}
virtual void Visit(CWindow_button* win) override
{
win->hwnd = ::CreateWindowExW(
0, L"button",
build_text, build_style,
build_left_pos, build_top_pos, build_width, build_height,
build_parenthwnd, (HMENU)build_uniqueid, 0, 0);
win->id = build_uniqueid;
build_uniqueid++;
}
virtual void Visit(CWindow_button_cfg* win) override
{
win->hwnd = ::CreateWindowExW(
0, L"button",
build_text, build_style,
build_left_pos, build_top_pos, build_width, build_height,
build_parenthwnd, (HMENU)build_uniqueid, 0, 0);
win->id = build_uniqueid;
build_uniqueid++;
}
virtual void Visit(CWindow_static* win) override
{
win->hwnd = ::CreateWindowExW(
0, L"static",
build_text, build_style,
build_left_pos, build_top_pos, build_width, build_height,
build_parenthwnd, (HMENU)build_uniqueid, 0, 0);
}
};

2
ultimateteknotool.v2/CWindowsFontApplier.cpp Normal file
View File

@ -0,0 +1,2 @@
#include "pch.h"
#include "CWindowsFontApplier.h"

38
ultimateteknotool.v2/CWindowsFontApplier.h Normal file
View File

@ -0,0 +1,38 @@
#pragma once
#include <windows.h>
#include "HFont_Wrapper.h"
#include "WindowsVisitor.h"
#include "CWindow_hwnd.h"
#include "CWindow_edit.h"
#include "CWindow_button.h"
#include "CWindow_edit_cfg.h"
#include "CWindow_button_cfg.h"
#include "CWindow_static.h"
class CWindowsFontApplier : public WindowsVisitor
{
public:
HFONT hFont;
CWindowsFontApplier(HFont_Wrapper& wrapper) { hFont = wrapper.GetFont(); }
virtual void Visit(CWindow_edit* win) override
{
if (hFont != 0) { ::SendMessageW(win->hwnd, WM_SETFONT, (WPARAM)hFont, TRUE); }
}
virtual void Visit(CWindow_edit_cfg* win) override
{
if (hFont != 0) { ::SendMessageW(win->hwnd, WM_SETFONT, (WPARAM)hFont, TRUE); }
}
virtual void Visit(CWindow_button* win) override
{
if (hFont != 0) { ::SendMessageW(win->hwnd, WM_SETFONT, (WPARAM)hFont, TRUE); }
}
virtual void Visit(CWindow_button_cfg* win) override
{
if (hFont != 0) { ::SendMessageW(win->hwnd, WM_SETFONT, (WPARAM)hFont, TRUE); }
}
virtual void Visit(CWindow_static* win) override
{
if (hFont != 0) { ::SendMessageW(win->hwnd, WM_SETFONT, (WPARAM)hFont, TRUE); }
}
};

2
ultimateteknotool.v2/HFont_Wrapper.cpp Normal file
View File

@ -0,0 +1,2 @@
#include "pch.h"
#include "HFont_Wrapper.h"

16
ultimateteknotool.v2/HFont_Wrapper.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include <windows.h>
class HFont_Wrapper
{
private:
HFONT font;
public:
HFont_Wrapper() { font = 0; }
void HFONT_Wrap(HFONT vfont) { font = vfont; }
const HFONT& GetFont() { return this->font; }
~HFont_Wrapper()
{
::DeleteObject(this->font);
}
};

82
ultimateteknotool.v2/Hooker_JMP.cpp Normal file
View File

@ -0,0 +1,82 @@
#include "pch.h"
#include <stdlib.h>
#include <vector>
#include "Hooker_JMP.h"
struct MallocNoob
{
std::vector<void*> holders;
MallocNoob()
{
}
unsigned char* doalloc(const size_t sz)
{
void* retard = 0;
retard = ::malloc(sz);
holders.push_back(retard);
return static_cast<unsigned char*>(retard);
}
~MallocNoob()
{
for (auto& x : this->holders)
{
if (x != 0)
{
::free(x);
}
}
}
};
MallocNoob allocer;
typedef BOOL(WINAPI* sys_VirtualProtect_t)(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect);
#pragma optimize("" ,off)
void* Hooker_JMP::__Hook32_internal__NativeHook(uint8_t* addr, uint8_t* hook, uint8_t len)
{
DWORD oldProtectID;
if (::VirtualProtect(addr, len, PAGE_READWRITE, &oldProtectID) == TRUE)
{
uint32_t jumpto, newjump;
unsigned char* jmp = 0;
if (addr[0] == 0xE9)
{
jmp = allocer.doalloc(10);
if (jmp == 0) { return nullptr; }
jumpto = (*reinterpret_cast<uint32_t*>((addr + 1))) + (reinterpret_cast<uint32_t>(addr)) + 5;
newjump = (jumpto - reinterpret_cast<uint32_t>(jmp + 5));
jmp[0] = 0xE9;
*reinterpret_cast<uint32_t*>((jmp + 1)) = newjump;
jmp += 5;
jmp[0] = 0xE9;
*(reinterpret_cast<uint32_t*>((jmp + 1))) = reinterpret_cast<uint32_t>(reinterpret_cast<uint32_t*>((addr - jmp)));
}
else
{
jmp = allocer.doalloc(5+len);
if (jmp == 0) { return nullptr; }
::memcpy(jmp, addr, len);
jmp += len;
jmp[0] = 0xE9;
*reinterpret_cast<uint32_t*>((jmp + 1)) = reinterpret_cast<uint32_t>(reinterpret_cast<uint32_t*>(addr + len - jmp)) - 5;
}
addr[0] = 0xE9;
*reinterpret_cast<uint32_t*>((addr + 1)) = reinterpret_cast<uint32_t>(reinterpret_cast<uint32_t*>(hook - addr)) - 5;
for (uint32_t i = 5; i < len; i++)
addr[i] = 0x90;
::VirtualProtect(addr, len, oldProtectID, &oldProtectID);
return (jmp - len);
}
return nullptr;
}
#pragma optimize("" ,on)

25
ultimateteknotool.v2/Hooker_JMP.h Normal file
View File

@ -0,0 +1,25 @@
#pragma once
#include "stdint.h"
#include "debugconsole.h"
#include <memory>
#include <mutex>
#include "SystemFunctionXRefRemover.h"
namespace Hooker_JMP
{
void* __Hook32_internal__NativeHook(uint8_t* addr, uint8_t* hook, uint8_t len);
template<typename FunctionType, typename HookType>
bool Hook32(uint32_t addr, HookType& hook, uint8_t asm_length_of_original_code, FunctionType& original_call)
{
original_call = nullptr;
original_call = reinterpret_cast<FunctionType>(
__Hook32_internal__NativeHook(reinterpret_cast<uint8_t*>(addr), reinterpret_cast<uint8_t*>(hook), asm_length_of_original_code)
);
return original_call != nullptr;
}
};

11
ultimateteknotool.v2/HooksAfterResumingThreads.cpp Normal file
View File

@ -0,0 +1,11 @@
#include "pch.h"
#include "HooksAfterResumingThreads.h"
bool hooks_after_resuming_threads::Hook()
{
bool ret = false;
ret = hooks::JMPHook_SerializeNetData(iw5mp_functions_addresses::SerializeNetData, 5) &&
hooks::bdDTLSAssociation_functions::JMPHook_sendInit(iw5mp_functions_addresses::bdDTLSAssociation_functions::sendInit, 5) &&
hooks::iw5mp_functions::JMPHook_GetChallengeS2(iw5mp_functions_addresses::GetChallengeS2, 5);
return ret;
}

10
ultimateteknotool.v2/HooksAfterResumingThreads.h Normal file
View File

@ -0,0 +1,10 @@
#pragma once
#include "JMPHook_SerializeNetdata.h"
#include "JMPHook_bdDTLSAssociation_functions.h"
#include "iw5mp_functions_declaration.h"
#include "JMP_iw5mp_functions.h"
namespace hooks_after_resuming_threads
{
bool Hook();
};

15
ultimateteknotool.v2/HooksOnThreadsStart.cpp Normal file
View File

@ -0,0 +1,15 @@
#include "pch.h"
#include "HooksOnThreadsStart.h"
bool hooks_on_threads_start::Hook()
{
bool ret = false;
ret = hooks::sysinfoapi_functions::JMPHook_GetSystemFirmwareTable((uint32_t)((void*)GetSystemFirmwareTable), 5);
if (ret)
{
ret = hooks::bdUPnP_functions::JMPHook_extractDeviceInfo(iw5mp_functions_addresses::bdUPnP_functions::extractDeviceInfo, 6);
//hooks::iphlpapi_functions::JMPHook_GetInterfaceInfo((uint32_t)((void*)::GetInterfaceInfo), 5);
}
return ret;
}

10
ultimateteknotool.v2/HooksOnThreadsStart.h Normal file
View File

@ -0,0 +1,10 @@
#pragma once
#include "iw5mp_functions_declaration.h"
#include "JMPHook_sysinfoapi_functions.h"
#include "JMPHook_bdUPnP_functions.h"
#include "JMPHook_iphlpapi_functions.h"
namespace hooks_on_threads_start
{
bool Hook();
};

126
ultimateteknotool.v2/Injector.cpp Normal file
View File

@ -0,0 +1,126 @@
#include "pch.h"
#include "Injector.h"
std::unique_ptr<Injector> Injector::m_pInst;
std::once_flag Injector::m_Initflag;
//void Injector::OverwriteTargetLibName(const char* target_lib_ASCII_nullterminated_string, const char* injecting_this)
// {
// // src: http://dronesec.pw/blog/2017/09/19/abusing-delay-load-dll/
// /*
// defined in winnt.h
// typedef struct _IMAGE_DELAYLOAD_DESCRIPTOR {
// union {
// DWORD AllAttributes;
// struct {
// DWORD RvaBased : 1; // Delay load version 2
// DWORD ReservedAttributes : 31;
// } DUMMYSTRUCTNAME;
// } Attributes;
//
// DWORD DllNameRVA; // RVA to the name of the target library (NULL-terminate ASCII string)
// DWORD ModuleHandleRVA; // RVA to the HMODULE caching location (PHMODULE)
// DWORD ImportAddressTableRVA; // RVA to the start of the IAT (PIMAGE_THUNK_DATA)
// DWORD ImportNameTableRVA; // RVA to the start of the name table (PIMAGE_THUNK_DATA::AddressOfData)
// DWORD BoundImportAddressTableRVA; // RVA to an optional bound IAT
// DWORD UnloadInformationTableRVA; // RVA to an optional unload info table
// DWORD TimeDateStamp; // 0 if not bound,
// // Otherwise, date/time of the target DLL
//
// } IMAGE_DELAYLOAD_DESCRIPTOR, *PIMAGE_DELAYLOAD_DESCRIPTOR;
// */
// PIMAGE_DOS_HEADER pImgDos = (PIMAGE_DOS_HEADER)GetModuleHandle(NULL);
// PIMAGE_NT_HEADERS pImgNt = (PIMAGE_NT_HEADERS)((LPBYTE)pImgDos + pImgDos->e_lfanew);
// PIMAGE_DELAYLOAD_DESCRIPTOR pImgDelay =
// (PIMAGE_DELAYLOAD_DESCRIPTOR)((LPBYTE)pImgDos + pImgNt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT].VirtualAddress);
// DWORD dwBaseAddr = (DWORD)GetModuleHandle(NULL);
// DWORD dwOldProtect = 0;
// SIZE_T wBytes = 0;
// for (IMAGE_DELAYLOAD_DESCRIPTOR* entry = pImgDelay; entry->ImportAddressTableRVA != NULL; entry++) {
// char* _cDllName = (char*)(dwBaseAddr + entry->DllNameRVA);
// if (::strcmp(_cDllName, target_lib_ASCII_nullterminated_string) == 0) {
// DWORD dwEntryAddr = (DWORD)((DWORD)GetModuleHandle(NULL) + entry->DllNameRVA);
// VirtualProtect((LPVOID)dwEntryAddr, sizeof(DWORD), PAGE_READWRITE, &dwOldProtect);
// WriteProcessMemory(GetCurrentProcess(), (LPVOID)dwEntryAddr, (LPVOID)injecting_this, strlen(injecting_this), &wBytes);
// VirtualProtect((LPVOID)dwEntryAddr, sizeof(DWORD), dwOldProtect, &dwOldProtect);
// return;
// }
// }
// return;
// }
Injector& Injector::Inject0r()
{
std::call_once(m_Initflag, []()
{
m_pInst.reset(new Injector); // straight calling default constructor
});
return *m_pInst.get();
}
bool Injector::APC_Inject(const std::wstring& dll_path)
{
HANDLE CurrentProcess = 0;
CurrentProcess = ::GetCurrentProcess();
SIZE_T StringSizeInBytes = (dll_path.size() + 4) * sizeof(decltype(dll_path[0]));
if (CurrentProcess == 0) return false;
else
{
LPVOID pThreadData = 0;
pThreadData = VirtualAllocEx(CurrentProcess, NULL, StringSizeInBytes, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (pThreadData == 0)
{
::CloseHandle(CurrentProcess);
return false;
}
else
{
if (!WriteProcessMemory(CurrentProcess, pThreadData, (LPCVOID)dll_path.c_str(), StringSizeInBytes, NULL))
{
::CloseHandle(CurrentProcess);
return false;
}
else
{
LPTHREAD_START_ROUTINE LoadLibraryAddress = 0;
HMODULE Kernel32Module = ::GetModuleHandleW(L"Kernel32");
if (Kernel32Module == 0)
{
::CloseHandle(CurrentProcess);
return false;
}
else {
LoadLibraryAddress = (LPTHREAD_START_ROUTINE)::GetProcAddress(Kernel32Module, "LoadLibraryW");
if (LoadLibraryAddress == 0)
{
::CloseHandle(CurrentProcess);
return false;
}
else {
HANDLE hThread = 0;
hThread = ::CreateRemoteThread(CurrentProcess, NULL, 0, LoadLibraryAddress, pThreadData, 0, NULL);
if (hThread == 0) {
::CloseHandle(CurrentProcess);
return false;
}
else {
WaitForSingleObject(hThread, INFINITE);
::CloseHandle(hThread);
::CloseHandle(CurrentProcess);
return true;
}
}
}
}
}
}
}
bool Injector::APC_FreeDll(const std::wstring& dll_path)
{
return false;
}

28
ultimateteknotool.v2/Injector.h Normal file
View File

@ -0,0 +1,28 @@
#pragma once
//#include <thread>
#include <mutex>
#include <memory>
#include <libloaderapi.h>
// must be singleton
class Injector
{
private:
static std::unique_ptr<Injector> m_pInst;
static std::once_flag m_Initflag;
Injector() = default;
Injector(const Injector&) = delete;
Injector(Injector&&) = delete;
Injector& operator=(const Injector&) = delete;
Injector& operator=(Injector&&) = delete;
bool VerifyInject(const std::wstring& dll_path);
//[[deprecated]] void OverwriteTargetLibName(const char*, const char*);
public:
~Injector() = default;
static Injector& Inject0r();
bool APC_Inject(const std::wstring& dll_path);
bool APC_FreeDll(const std::wstring& dll_path);
};

190
ultimateteknotool.v2/JMPHook_SerializeNetdata.cpp Normal file
View File

@ -0,0 +1,190 @@
#include "pch.h"
#include "JMPHook_SerializeNetdata.h"
namespace hooks
{
typedef void* (__fastcall* SerializeNETData_t)(void* _this, void* edx, void* pDst); // game is using this function for serialize net data in cookieecho
void* __fastcall hooked_SerializeNetData(void* _this, void* edx, void* pDst);
};
static hooks::SerializeNETData_t OriginalFunction;
struct _sub_6EC2A0_data
{
uint8_t LocalIP[4]; // 0-3
uint16_t LPort; // 4-5
uint8_t RouteIP1[4];
uint16_t RPort1;
uint8_t RouteIP2[4];
uint16_t RPort2;
uint8_t ExternalIP[4]; // 18-21
uint16_t EPort; // 22-23 LPort==EPort
};
static _sub_6EC2A0_data NewData = { 0 };
static _sub_6EC2A0_data CurrentData = { 0 };
namespace MustBeChanged
{
bool ExternalIP = false;
bool LocalIP = false;
bool OtherIP1 = false;
bool OtherIP2 = false;
bool ExternalPort = false;
bool LocalPort = false;
bool OtherPort1 = false;
bool OtherPort2 = false;
};
inline void __copy_4bytes__in__4bytes__(uint8_t dstIP[4], const uint8_t srcIP[4])
{
dstIP[0] = srcIP[0];
dstIP[1] = srcIP[1];
dstIP[2] = srcIP[2];
dstIP[3] = srcIP[3];
}
inline void __copy_sub_6EC2A0_data__in___sub_6EC2A0_data__(_sub_6EC2A0_data* dst, _sub_6EC2A0_data* src)
{
__copy_4bytes__in__4bytes__(dst->ExternalIP, src->ExternalIP);
__copy_4bytes__in__4bytes__(dst->LocalIP, src->LocalIP);
__copy_4bytes__in__4bytes__(dst->RouteIP1, src->RouteIP1);
__copy_4bytes__in__4bytes__(dst->RouteIP2, src->RouteIP2);
dst->EPort = src->EPort;
dst->LPort = src->LPort;
dst->RPort1 = src->RPort1;
dst->RPort2 = src->RPort2;
}
#define MACRO_CHANGEIP(boolv, dst, src) if(boolv){ __copy_4bytes__in__4bytes__(dst, src); }
#define MACRO_CHANGEPORT(boolv, dst, src) if(boolv){ dst = src ; }
void* __fastcall hooks::hooked_SerializeNetData(void* _this, void* edx, void* pDst)
{
void* ret;
ret = OriginalFunction(_this, edx, pDst);
_sub_6EC2A0_data* pdata = static_cast<_sub_6EC2A0_data*>(pDst);
MACRO_CHANGEIP(MustBeChanged::ExternalIP, pdata->ExternalIP, NewData.ExternalIP);
MACRO_CHANGEIP(MustBeChanged::LocalIP, pdata->LocalIP, NewData.LocalIP);
MACRO_CHANGEIP(MustBeChanged::OtherIP1, pdata->RouteIP1, NewData.RouteIP1);
MACRO_CHANGEIP(MustBeChanged::OtherIP2, pdata->RouteIP2, NewData.RouteIP2);
MACRO_CHANGEPORT(MustBeChanged::ExternalPort, pdata->EPort, NewData.EPort);
MACRO_CHANGEPORT(MustBeChanged::LocalPort, pdata->LPort, NewData.LPort);
MACRO_CHANGEPORT(MustBeChanged::OtherPort1, pdata->RPort1, NewData.RPort1);
MACRO_CHANGEPORT(MustBeChanged::OtherPort2, pdata->RPort2, NewData.RPort2);
__copy_sub_6EC2A0_data__in___sub_6EC2A0_data__(&CurrentData, pdata);
windows_accountpage::UpdateCurrentNETData();
return ret;
}
#undef MACRO_CHANGEIP
#undef MACRO_CHANGEPORT
bool hooks::JMPHook_SerializeNetData(uint32_t addr, uint8_t asmlen)
{
return Hooker_JMP::Hook32<SerializeNETData_t, decltype(hooked_SerializeNetData)>(
addr,
hooked_SerializeNetData,
asmlen,
OriginalFunction
);
}
void hooks::serializeNetData_change::ExternalIP(const uint8_t newIP[4])
{
MustBeChanged::ExternalIP = true;
__copy_4bytes__in__4bytes__(NewData.ExternalIP, newIP);
}
void hooks::serializeNetData_change::LocalIP(const uint8_t newIP[4])
{
MustBeChanged::LocalIP = true;
__copy_4bytes__in__4bytes__(NewData.LocalIP, newIP);
}
void hooks::serializeNetData_change::OtherlIP1(const uint8_t newIP[4])
{
MustBeChanged::OtherIP1 = true;
__copy_4bytes__in__4bytes__(NewData.RouteIP1, newIP);
}
void hooks::serializeNetData_change::OtherlIP2(const uint8_t newIP[4])
{
MustBeChanged::OtherIP2 = true;
__copy_4bytes__in__4bytes__(NewData.RouteIP2, newIP);
}
void hooks::serializeNetData_change::ExternalPort(const uint16_t newPort)
{
MustBeChanged::ExternalPort = true;
NewData.EPort = newPort;
}
void hooks::serializeNetData_change::LocalPort(const uint16_t newPort)
{
MustBeChanged::LocalPort = true;
NewData.LPort = newPort;
}
void hooks::serializeNetData_change::OtherPort1(const uint16_t newPort)
{
MustBeChanged::OtherPort1 = true;
NewData.RPort1 = newPort;
}
void hooks::serializeNetData_change::OtherPort2(const uint16_t newPort)
{
MustBeChanged::OtherPort2 = true;
NewData.RPort2 = newPort;
}
void hooks::serializeNetData_get::ExternalIP(uint8_t newIP[4])
{
__copy_4bytes__in__4bytes__(newIP, CurrentData.ExternalIP);
}
void hooks::serializeNetData_get::LocalIP(uint8_t newIP[4])
{
__copy_4bytes__in__4bytes__(newIP, CurrentData.LocalIP);
}
void hooks::serializeNetData_get::OtherlIP1(uint8_t newIP[4])
{
__copy_4bytes__in__4bytes__(newIP, CurrentData.RouteIP1);
}
void hooks::serializeNetData_get::OtherlIP2(uint8_t newIP[4])
{
__copy_4bytes__in__4bytes__(newIP, CurrentData.RouteIP2);
}
uint16_t hooks::serializeNetData_get::ExternalPort()
{
return CurrentData.EPort;
}
uint16_t hooks::serializeNetData_get::LocalPort()
{
return CurrentData.LPort;
}
uint16_t hooks::serializeNetData_get::OtherPort1()
{
return CurrentData.RPort1;
}
uint16_t hooks::serializeNetData_get::OtherPort2()
{
return CurrentData.RPort2;
}

30
ultimateteknotool.v2/JMPHook_SerializeNetdata.h Normal file
View File

@ -0,0 +1,30 @@
#pragma once
#include <stdint.h>
#include "Hooker_JMP.h"
#include "windows_accountpage.h"
namespace hooks
{
bool JMPHook_SerializeNetData(uint32_t addr, uint8_t asmlen);
namespace serializeNetData_change {
void ExternalIP(const uint8_t newIP[4]);
void LocalIP(const uint8_t newIP[4]);
void OtherlIP1(const uint8_t newIP[4]);
void OtherlIP2(const uint8_t newIP[4]);
void ExternalPort(const uint16_t newPort);
void LocalPort(const uint16_t newPort);
void OtherPort1(const uint16_t newPort);
void OtherPort2(const uint16_t newPort);
};
namespace serializeNetData_get {
void ExternalIP(uint8_t newIP[4]);
void LocalIP(uint8_t newIP[4]);
void OtherlIP1(uint8_t newIP[4]);
void OtherlIP2(uint8_t newIP[4]);
uint16_t ExternalPort();
uint16_t LocalPort();
uint16_t OtherPort1();
uint16_t OtherPort2();
};
};

34
ultimateteknotool.v2/JMPHook_bdDTLSAssociation_functions.cpp Normal file
View File

@ -0,0 +1,34 @@
#include "pch.h"
#include "JMPHook_bdDTLSAssociation_functions.h"
namespace hooks
{
namespace bdDTLSAssociation_functions
{
namespace sendInit
{
typedef void(__thiscall* sendInit_t)(int thisinstance);
static sendInit_t originalFunc = nullptr;
void __fastcall Hooked_sendInit(int thisinstance, int _edx);
};
};
};
bool hooks::bdDTLSAssociation_functions::JMPHook_sendInit(uint32_t addr, uint8_t asmlen)
{
return Hooker_JMP::Hook32<sendInit::sendInit_t, decltype(sendInit::Hooked_sendInit)>(
addr,
sendInit::Hooked_sendInit,
asmlen,
sendInit::originalFunc
);
}
void __fastcall hooks::bdDTLSAssociation_functions::sendInit::Hooked_sendInit(int thisinstance, int _edx)
{
windows_accountpage::DoJobOnConnect();
originalFunc(thisinstance);
return;
}

12
ultimateteknotool.v2/JMPHook_bdDTLSAssociation_functions.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include <stdint.h>
#include "Hooker_JMP.h"
#include "windows_accountpage.h"
namespace hooks
{
namespace bdDTLSAssociation_functions
{
bool JMPHook_sendInit(uint32_t addr, uint8_t asmlen);
};
};

213
ultimateteknotool.v2/JMPHook_bdUPnP_functions.cpp Normal file
View File

@ -0,0 +1,213 @@
#include "pch.h"
#include "JMPHook_bdUPnP_functions.h"
#include "LazyBuffer.h"
namespace hooks
{
namespace bdUPnP_functions
{
namespace ns_extractDeviceInfo {
typedef char(__thiscall* bdUPnP_extractDeviceInfo_t)(void* th1s, int a2, char** a3, DWORD* a4);
bdUPnP_extractDeviceInfo_t original_func;
char __fastcall hooked_extractDeviceInfo(uint8_t* th1s, void* deadboi, int a2, char** a3, DWORD* a4);
static constexpr size_t bufferSize = 256;
/*
SAMPLE ->
LOCATION: http://192.168.0.0:1900/igd.xml
SERVER: ipos/7.0 UPnP/1.0 TL-wa850re/5.0
ST: urn:schemas-upnp-org:service:WANIPConnection:1
USN: uuid:923865f5-f5da-4ad5-15b7-7404637fdf37::urn:schemas-upnp-org:service:WANIPConnection:1
*/
template<unsigned short SIZE>
class Field
{
private:
uint8_t newtext[SIZE + 1] = { 0 };
bool mustchange_field = false;
void CopyStringIn(uint8_t* dst) const
{
for (unsigned short i = 0; i < SIZE && newtext[i]; i++)
{
dst[i] = newtext[i];
}
}
void Flush()
{
for (unsigned short i = 0; i < SIZE; i++)
{
newtext[i] = 0x00;
}
}
public:
Field() = default;
~Field()= default;
void UpdateCurrentString(const uint8_t* src, unsigned short sz_src)
{
this->Flush();
for (unsigned short i = 0; i < SIZE && src[i] && i < sz_src; i++)
{
newtext[i] = src[i];
}
this->mustchange_field = true;
}
void ChangeFieldIn(uint8_t* dst)
{
this->CopyStringIn(dst);
mustchange_field = false;
}
};
static Field<maxtext_field_location>location;
static Field<maxtext_field_server>server;
static Field<maxtext_field_USN>USN;
static uint8_t* stat_relative = nullptr;
uint8_t* GetFirstRightEntry()
{
return stat_relative;
}
};
};
};
static CONSTEXPRENCRYPTSTRW(Error_UPnPSpoofFailed, L"<Error>UPnP spoof failed", 0x31F1);
#define MACRO_Error_UPnPSpoofFailed DECRYPTCONSTENCSTRW(Error_UPnPSpoofFailed, sizeof(L"<Error>UPnP spoof failed") / sizeof(wchar_t), 0x31F1)
bool hooks::bdUPnP_functions::JMPHook_extractDeviceInfo(uint32_t addr, uint8_t asmlen)
{
return Hooker_JMP::Hook32<ns_extractDeviceInfo::bdUPnP_extractDeviceInfo_t, decltype(ns_extractDeviceInfo::hooked_extractDeviceInfo)>(
addr,
ns_extractDeviceInfo::hooked_extractDeviceInfo,
asmlen,
ns_extractDeviceInfo::original_func
);
}
void hooks::bdUPnP_functions::SetDeviceInfo_location(const wchar_t* str)
{
bdUPnP_functions::ns_extractDeviceInfo::location.UpdateCurrentString(
textconvertors::ConvertWTextToU8Text(str, bdUPnP_functions::ns_extractDeviceInfo::maxtext_field_location),
bdUPnP_functions::ns_extractDeviceInfo::maxtext_field_location
);
}
void hooks::bdUPnP_functions::SetDeviceInfo_server(const wchar_t* str)
{
bdUPnP_functions::ns_extractDeviceInfo::server.UpdateCurrentString(
textconvertors::ConvertWTextToU8Text(str, bdUPnP_functions::ns_extractDeviceInfo::maxtext_field_server),
bdUPnP_functions::ns_extractDeviceInfo::maxtext_field_server
);
}
void hooks::bdUPnP_functions::SetDeviceInfo_USN(const wchar_t* str)
{
bdUPnP_functions::ns_extractDeviceInfo::USN.UpdateCurrentString(
textconvertors::ConvertWTextToU8Text(str, bdUPnP_functions::ns_extractDeviceInfo::maxtext_field_USN),
bdUPnP_functions::ns_extractDeviceInfo::maxtext_field_USN
);
}
template<uint8_t b1, uint8_t b2, uint8_t b3, uint8_t b4>
uint8_t* searchEntry(uint8_t* th1s, const size_t len)
{
uint8_t* addr = th1s;
for (size_t i = 0; i < len; i++)
{
if (*addr == b1)
{
addr++;
if (*addr == b2)
{
addr++;
if (*addr == b3)
{
addr++;
if (*addr == b4)
{
addr++;
return addr;
}
}
}
}
addr++;
}
return nullptr;
}
static_assert(nullptr == 0, "nullptr is not equal to null?!");
char __fastcall hooks::bdUPnP_functions::ns_extractDeviceInfo::hooked_extractDeviceInfo(uint8_t* th1s, void* deadboi, int a2, char** a3, DWORD* a4)
{
uint8_t* relative = th1s;
size_t validsize = bufferSize;
relative = searchEntry<'T', 'I', 'O', 'N'>(th1s, validsize);
if (relative != 0 )
{
relative += 2;
stat_relative = relative;
location.ChangeFieldIn(relative);
windows_accountpage::UPnP::update_device::Location(textconvertors::ConvertU8TextToWText_StupidButFast_graphNspace(relative, maxtext_field_location));
relative = searchEntry<'R', 'V', 'E', 'R'>(relative, validsize);
if (relative != 0)
{
relative += 2;
relative += 18;
server.ChangeFieldIn(relative);
windows_accountpage::UPnP::update_device::Server(textconvertors::ConvertU8TextToWText_StupidButFast_graphNspace(relative, maxtext_field_server));
relative = searchEntry<'U', 'S', 'N', ':'>(relative, validsize);
if (relative != 0)
{
relative += 1;
USN.ChangeFieldIn(relative);
windows_accountpage::UPnP::update_device::USN(textconvertors::ConvertU8TextToWText_StupidButFast_graphNspace(relative, maxtext_field_USN));
}
else {
windows_accountpage::UPnP::update_device::USN(MACRO_Error_UPnPSpoofFailed);
}
}
else { windows_accountpage::UPnP::update_device::Server(MACRO_Error_UPnPSpoofFailed); }
}
else { windows_accountpage::UPnP::update_device::Location(MACRO_Error_UPnPSpoofFailed); }
return original_func(th1s, a2, a3, a4);
}
void hooks::bdUPnP_functions::SetDeviceInfo()
{
uint8_t* relative = nullptr;
relative = ns_extractDeviceInfo::GetFirstRightEntry();
if (relative == nullptr) { return; }
size_t validsize = ns_extractDeviceInfo::bufferSize;
ns_extractDeviceInfo::location.ChangeFieldIn(relative);
windows_accountpage::UPnP::update_device::Location(textconvertors::ConvertU8TextToWText_StupidButFast_graphNspace(relative, ns_extractDeviceInfo::maxtext_field_location));
relative = searchEntry<'R', 'V', 'E', 'R'>(relative, validsize);
if (relative != 0)
{
relative += 2;
relative += 18;
ns_extractDeviceInfo::server.ChangeFieldIn(relative);
windows_accountpage::UPnP::update_device::Server(textconvertors::ConvertU8TextToWText_StupidButFast_graphNspace(relative, ns_extractDeviceInfo::maxtext_field_server));
relative = searchEntry<'U', 'S', 'N', ':'>(relative, validsize);
if (relative != 0)
{
relative += 1;
ns_extractDeviceInfo::USN.ChangeFieldIn(relative);
windows_accountpage::UPnP::update_device::USN(textconvertors::ConvertU8TextToWText_StupidButFast_graphNspace(relative, ns_extractDeviceInfo::maxtext_field_USN));
}
else {
windows_accountpage::UPnP::update_device::USN(MACRO_Error_UPnPSpoofFailed);
}
}
else { windows_accountpage::UPnP::update_device::Server(MACRO_Error_UPnPSpoofFailed); }
}
#undef MACRO_Error_UPnPSpoofFailed

27
ultimateteknotool.v2/JMPHook_bdUPnP_functions.h Normal file
View File

@ -0,0 +1,27 @@
#pragma once
#include <stdint.h>
#include "Hooker_JMP.h"
#include "windows_accountpage.h"
#include "TextConvertors.h"
#include "compiletime_XORstring.h"
#include "debugconsole.h"
namespace hooks
{
namespace bdUPnP_functions
{
bool JMPHook_extractDeviceInfo(uint32_t addr, uint8_t asmlen);
void SetDeviceInfo_location(const wchar_t* str);
void SetDeviceInfo_server(const wchar_t* str);
void SetDeviceInfo_USN(const wchar_t* str);
void SetDeviceInfo();
namespace ns_extractDeviceInfo
{
constexpr unsigned short maxtext_field_location = 36;
constexpr unsigned short maxtext_field_server = 36;
constexpr unsigned short maxtext_field_USN = 72;
uint8_t* GetFirstRightEntry();
};
};
};

34
ultimateteknotool.v2/JMPHook_iphlpapi_functions.cpp Normal file
View File

@ -0,0 +1,34 @@
#include "pch.h"
#include "JMPHook_iphlpapi_functions.h"
namespace hooks
{
namespace iphlpapi_functions
{
typedef DWORD (*GetInterfaceInfo_t)(
PIP_INTERFACE_INFO pIfTable,
PULONG dwOutBufLen
);
GetInterfaceInfo_t OriginalFunc = nullptr;
DWORD Hook_GetInterfaceInfo(
PIP_INTERFACE_INFO pIfTable,
PULONG dwOutBufLen
)
{
WCWOUT("Hook_GetInterfaceInfo");
return OriginalFunc(pIfTable, dwOutBufLen);
}
};
};
bool hooks::iphlpapi_functions::JMPHook_GetInterfaceInfo(uint32_t addr, uint8_t asmlen)
{
return Hooker_JMP::Hook32<GetInterfaceInfo_t, decltype(Hook_GetInterfaceInfo)>(
addr,
Hook_GetInterfaceInfo,
asmlen,
OriginalFunc
);
}

14
ultimateteknotool.v2/JMPHook_iphlpapi_functions.h Normal file
View File

@ -0,0 +1,14 @@
#pragma once
#include <stdint.h>
#include "Hooker_JMP.h"
#include <iphlpapi.h>
#pragma comment(lib, "iphlpapi.lib")
#include "debugconsole.h"
namespace hooks
{
namespace iphlpapi_functions
{
bool JMPHook_GetInterfaceInfo(uint32_t addr, uint8_t asmlen);
};
};

333
ultimateteknotool.v2/JMPHook_sysinfoapi_functions.cpp Normal file
View File

@ -0,0 +1,333 @@
#include "pch.h"
#include "JMPHook_sysinfoapi_functions.h"
#include "windows_accountpage.h"
#include "Randomizer.h"
#include <sstream>
namespace hooks
{
namespace sysinfoapi_functions
{
namespace ns_getSystemFirmwareTable {
typedef UINT(WINAPI* GetSystemFirmwareTable_t) (DWORD FirmwareTableProviderSignature, DWORD FirmwareTableID, PVOID pFirmwareTableBuffer, DWORD BufferSize);
static GetSystemFirmwareTable_t OriginalFunction = nullptr;
UINT WINAPI hooked_GetSystemFirmwareTable(DWORD FirmwareTableProviderSignature, DWORD FirmwareTableID, PVOID pFirmwareTableBuffer, DWORD BufferSize);
static bool request_generate_new_data = true;
static bool always_generate_new_data = false;
static bool faking_firmware_data_is_enabled = false;
static bool stupid_randomise_whole_data = false;
typedef struct _RawSMBIOSData
{
BYTE Used20CallingMethod;
BYTE SMBIOSMajorVersion;
BYTE SMBIOSMinorVersion;
BYTE DmiRevision;
DWORD Length;
BYTE* SMBIOSTableData;
} RawSMBIOSData, * PRawSMBIOSData;
typedef struct _SMBIOSHEADER_
{
BYTE Type;
BYTE Length;
WORD Handle;
} SMBIOSHEADER, * PSMBIOSHEADER;
/*
real one header struct
struct HEADER
{
BYTE type;
BYTE length;
BYTE data[length - 2];
BYTE Text[depend on];
BYTE _nulledbyte; // so struct has doublenull in the end
}
*/
enum StructureType
{
BIOS_INFO_TYPE = 0x00,
SYSTEM_INFO_TYPE = 0x01,
BASEBOARD_INFO_TYPE = 0x02,
CHASSIS_INFO_TYPE = 0x03,
PROCESSOR_INFO_TYPE = 0x04,
CACHE_INFO_TYPE = 0x07,
PORTS_INFO_TYPE = 0x08,
SYSTEMSLOTS_INFO_TYPE = 0x09,
ONBOARDDEVS_INFO_TYPE = 0x0A,
OEMSTRING_INFO_TYPE = 0x0B,
SYSTEMCONFIG_INFO_TYPE = 0x0C,
BIOSLANG_INFO_TYPE = 0x0D,
GROUPASSOCS_INFO_TYPE = 0x0E,
SYSLOG_INFO_TYPE = 0x0F,
PHYSMEM_INFO_TYPE = 0x10,
MEMDEV_INFO_TYPE = 0x11,
MEMERROR32_INFO_TYPE = 0x12,
MEMARRAYMAPPED_INFO_TYPE = 0x13,
MEMDEVMAPPED_INFO_TYPE = 0x14,
BUILTINPTRDEV_INFO_TYPE = 0x15,
BATTERY_INFO_TYPE = 0x16,
SYSRESET_INFO_TYPE = 0x17,
HARDSEC_INFO_TYPE = 0x18,
SYSPOWER_INFO_TYPE = 0x19,
VOLTPROBE_INFO_TYPE = 0x1A,
COOLINGDEV_INFO_TYPE = 0x1B,
TEMPPROBE_INFO_TYPE = 0x1C,
ELECPROBE_INFO_TYPE = 0x1D,
OOBRA_INFO_TYPE = 0x1E,
SYSBOOT_INFO_TYPE = 0x20,
MEMERROR64_INFO_TYPE = 0x21,
MNGDEV_INFO_TYPE = 0x22,
MNGDEVCOMP_INFO_TYPE = 0x23,
MNGDEVTHRES_INFO_TYPE = 0x24,
MEMCHAN_INFO_TYPE = 0x25,
IPMIDEV_INFO_TYPE = 0x26,
POWERSUPPLY_INFO_TYPE = 0x27,
ADDITIONAL_INFO_TYPE = 0x28,
ONBOARDDEVSEX_INFO_TYPE = 0x29,
MNGCTRLHOSTIF_INFO_TYPE = 0x2A,
INACTIVE_INFO_TYPE = 0x7E,
EOF_INFO_TYPE = 0x7F,
};
/*
h000 b22fa79e 4f86f8a0 9e8ea282 539f98a0 normal hash
h001 43677e04 ceccbe47 3f2be224 2d700c7b changing data -> new hash
h002 7b738ab1 23373d8d 5f308163 6975e1d3 changing data -> new hash
h003 b22fa79e 4f86f8a0 9e8ea282 539f98a0 normal hash
...
h010 b22fa79e 4f86f8a0 9e8ea282 539f98a0 normal hash
h011 e7059b40 85f66d3a 892101a4 f0e65b93 changing data -> new hash
h012 b22fa79e 4f86f8a0 9e8ea282 539f98a0 normal hash
...
h255 b22fa79e 4f86f8a0 9e8ea282 539f98a0 normal hash
GSFT: blocksize->12
data->1.2.?240.3.255.128.152.139.55.1.??
GSFT: blocksize->124
text->xxxxxxxxxxxxxxxxxx?xxxxGigabyte Technology Co., Ltd.?Z390 UD?Default string?Default string?Default string?Default string?
GSFT: blocksize->101
text->xxxxxxxxxxxxxx??Gigabyte Technology Co., Ltd.?Z390 UD?x.x?Default string?Default string?Default string?
GSFT: blocksize->9
data->9.17.28.?1.165.13.4.4.?
GSFT: blocksize->19
text->xxx?xDefault string?
GSFT: blocksize->8
data->34.11.37.?1.4.???
GSFT: blocksize->12
data->17.40.59.?58.?254.255.?????
GSFT: blocksize->12
data->17.40.61.?58.?254.255.?????
GSFT: blocksize->17
data->221.26.65.?3.1.?7.?49.52.?2.?????
GSFT: blocksize->5
data->11.?7.???
GSFT: blocksize->4
data->1.????
GSFT: blocksize->12
data->10.?255.255.255.255.255.11.?255.255.??
GSFT: blocksize->1
data->16.?
blocksize (not intended) = 4,5,8,9,17,19
GSFT: blocksize->12
data->1.2.?240.3.255.128.152.139.55.1.??
GSFT: blocksize->124
text->xxxxxxxxxxxxxxxxxx?xxxxGigabyte Technology Co., Ltd.?Z390 UD?Default string?Default string?Default string?Default string?
GSFT: blocksize->101
text->xxxxxxxxxxxxxx??Gigabyte Technology Co., Ltd.?Z390 UD?x.x?Default string?Default string?Default string?
GSFT: blocksize->12
data->17.40.59.?58.?254.255.?????
GSFT: blocksize->12
data->17.40.59.?58.?254.255.?????
GSFT: blocksize->12
data->10.?255.255.255.255.255.11.?255.255.??
*/
template<size_t BUFFSIZE>
class GenFakeData
{
private:
char _data[BUFFSIZE] = { 0 };
bool _is_generated = false;
public:
GenFakeData() = default;
~GenFakeData() = default;
void RegenerateData() { this->_is_generated = false; }
char* GetData()
{
if (this->_is_generated == false)
{
for (size_t i = 0; i < BUFFSIZE; i++)
{
this->_data[i] = RANDALNUM;
}
this->_is_generated = true;
}
return this->_data;
}
size_t GetSZ() const { return BUFFSIZE; }
};
GenFakeData<128>x128_data;
};
};
};
bool hooks::sysinfoapi_functions::JMPHook_GetSystemFirmwareTable(uint32_t addr, uint8_t asmlen)
{
return Hooker_JMP::Hook32<ns_getSystemFirmwareTable::GetSystemFirmwareTable_t, decltype(ns_getSystemFirmwareTable::hooked_GetSystemFirmwareTable)>(
addr,
ns_getSystemFirmwareTable::hooked_GetSystemFirmwareTable,
asmlen,
ns_getSystemFirmwareTable::OriginalFunction
);
}
void hooks::sysinfoapi_functions::GetSystemFirmwareTable_SetState_GenerateNewData()
{
ns_getSystemFirmwareTable::request_generate_new_data = true;
}
void hooks::sysinfoapi_functions::GetSystemFirmwareTable_SetState_FakingDataEnabled(const bool& state)
{
ns_getSystemFirmwareTable::faking_firmware_data_is_enabled = state;
WCWOUT("ns_getSystemFirmwareTable::faking_firmware_data_is_enabled->", ns_getSystemFirmwareTable::faking_firmware_data_is_enabled);
}
void hooks::sysinfoapi_functions::GetSystemFirmwareTable_SetState_AlwaysGenerateNewDataEnabled(const bool& state)
{
ns_getSystemFirmwareTable::always_generate_new_data = state;
}
void hooks::sysinfoapi_functions::GetSystemFirmwareTable_SetState_RandomiseAllDataEnabled(const bool& state)
{
ns_getSystemFirmwareTable::stupid_randomise_whole_data = state;
}
std::wstringstream wstream;
std::wstringstream wstream2;
UINT WINAPI hooks::sysinfoapi_functions::ns_getSystemFirmwareTable::hooked_GetSystemFirmwareTable
(DWORD FirmwareTableProviderSignature, DWORD FirmwareTableID, PVOID pFirmwareTableBuffer, DWORD BufferSize)
{
if (pFirmwareTableBuffer == NULL) { return OriginalFunction(FirmwareTableProviderSignature, FirmwareTableID, pFirmwareTableBuffer, BufferSize); }
UINT ret = 0;
ret = OriginalFunction(FirmwareTableProviderSignature, FirmwareTableID, pFirmwareTableBuffer, BufferSize);
if (ret != 0) {
const PRawSMBIOSData pDMIData = static_cast<const PRawSMBIOSData>(pFirmwareTableBuffer);
const LPBYTE pEOFData = static_cast<const LPBYTE>(pFirmwareTableBuffer) + pDMIData->Length;
PSMBIOSHEADER pHeader = reinterpret_cast<PSMBIOSHEADER>(&(pDMIData->SMBIOSTableData));
LPBYTE pCurrentData = reinterpret_cast<LPBYTE>(&(pDMIData->SMBIOSTableData));
LPBYTE prevDataP = pCurrentData;
SIZE_T blockSize = 0;
SIZE_T exBlockSize = 0;
size_t counterchecker = 0;
char* FakeData = x128_data.GetData();
if (request_generate_new_data || always_generate_new_data) {
x128_data.RegenerateData();
request_generate_new_data = false;
}
if (faking_firmware_data_is_enabled)
{
if (stupid_randomise_whole_data)
{
while (pCurrentData <= pEOFData)
{
if (pCurrentData[0] == 0 && pCurrentData[1] == 0 && pCurrentData[2] != 0)
{
prevDataP = pCurrentData;
while (blockSize != 0)
{
prevDataP--;
if (*prevDataP) { *prevDataP = RANDBYTE; }
blockSize--;
}
pCurrentData += 2;
blockSize = 0;
}
pCurrentData++;
blockSize++;
}
}
else {
while (pCurrentData <= pEOFData)
{
if (pCurrentData[0] == 0 && pCurrentData[1] == 0 && pCurrentData[2] != 0 /* EOData p[2] is next header, header is non-unique*/)
{
if (pCurrentData[2] == 1 + 1 || pCurrentData[2] == 2 + 1 || pCurrentData[2] == 11 + 1)
{
exBlockSize = blockSize;
prevDataP = pCurrentData;
WCWOUT(L"GSFT: blocksize->", std::dec, blockSize);
while (blockSize != 0)
{
prevDataP--;
blockSize--;
}
if (exBlockSize > 50) {
while (prevDataP < pCurrentData)
{
if (::isalnum(prevDataP[0]) && ::isalnum(prevDataP[1]) && ::isalnum(prevDataP[2]))
{
break;
}
prevDataP++;
}
if (prevDataP < pCurrentData) {
FakeData = x128_data.GetData();
for (counterchecker = 0; counterchecker < x128_data.GetSZ() && *prevDataP; counterchecker++)
{
*prevDataP = FakeData[counterchecker];
prevDataP++;
}
}
while (prevDataP < pCurrentData)
{
prevDataP++;
}
while (exBlockSize != 0)
{
prevDataP--;
exBlockSize--;
}
wstream.clear();
wstream.str(L"");
while (prevDataP < pCurrentData)
{
wstream << (wchar_t)*prevDataP;
prevDataP++;
}
WCWOUT(L"Firmware: ", wstream.str());
}
else
{
while (prevDataP < pCurrentData)
{
/* modifying header's data here */
/* end */
prevDataP++;
}
}
}
pCurrentData += 2;
blockSize = 0;
}
pCurrentData++;
blockSize++;
}
}
}
return ret;
}
else
{
return 0;
}
}

16
ultimateteknotool.v2/JMPHook_sysinfoapi_functions.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include <stdint.h>
#include "Hooker_JMP.h"
#include "debugconsole.h"
namespace hooks
{
namespace sysinfoapi_functions
{
bool JMPHook_GetSystemFirmwareTable(uint32_t addr, uint8_t asmlen);
void GetSystemFirmwareTable_SetState_GenerateNewData();
void GetSystemFirmwareTable_SetState_FakingDataEnabled(const bool& state);
void GetSystemFirmwareTable_SetState_AlwaysGenerateNewDataEnabled(const bool& state);
void GetSystemFirmwareTable_SetState_RandomiseAllDataEnabled(const bool& state);
};
};

94
ultimateteknotool.v2/JMP_iw5mp_functions.cpp Normal file
View File

@ -0,0 +1,94 @@
#include "pch.h"
#include "JMP_iw5mp_functions.h"
#include "windows_accountpage.h"
namespace hooks
{
namespace iw5mp_functions
{
namespace ns_GetChallengeS2
{
typedef uint32_t* (*getChallengeS2_t)(void);
getChallengeS2_t OriginalFunction = nullptr;
uint32_t* hooked_GetChallengeS2();
struct SChallengeS2
{
uint32_t p1;
uint32_t p2;
uint32_t p3;
uint32_t p4;
void Set(uint32_t* addr)
{
this->p1 = addr[0];
this->p2 = addr[1];
this->p3 = addr[2];
this->p4 = addr[3];
}
};
SChallengeS2 currentData = { 0 };
SChallengeS2 newData = { 0 };
};
};
};
bool hooks::iw5mp_functions::JMPHook_GetChallengeS2(uint32_t addr, uint8_t asmlen)
{
return Hooker_JMP::Hook32<ns_GetChallengeS2::getChallengeS2_t, decltype(ns_GetChallengeS2::hooked_GetChallengeS2)>(
addr,
ns_GetChallengeS2::hooked_GetChallengeS2,
asmlen,
ns_GetChallengeS2::OriginalFunction
);
}
uint32_t* hooks::iw5mp_functions::ns_GetChallengeS2::hooked_GetChallengeS2()
{
uint32_t* ret = OriginalFunction();
if (newData.p1) { ret[0] = newData.p1; }
if (newData.p2) { ret[1] = newData.p2; }
if (newData.p3) { ret[2] = newData.p3; }
if (newData.p4) { ret[3] = newData.p4; }
currentData.Set(ret);
windows_accountpage::UpdateCurrentChallengeS2();
return ret;
}
uint32_t hooks::iw5mp_functions::ns_GetChallengeS2::Get_P1() noexcept
{
return currentData.p1;
}
uint32_t hooks::iw5mp_functions::ns_GetChallengeS2::Get_P2() noexcept
{
return currentData.p2;
}
uint32_t hooks::iw5mp_functions::ns_GetChallengeS2::Get_P3() noexcept
{
return currentData.p3;
}
uint32_t hooks::iw5mp_functions::ns_GetChallengeS2::Get_P4() noexcept
{
return currentData.p4;
}
void hooks::iw5mp_functions::ns_GetChallengeS2::Set_P1(uint32_t nv) noexcept
{
newData.p1 = nv;
}
void hooks::iw5mp_functions::ns_GetChallengeS2::Set_P2(uint32_t nv) noexcept
{
newData.p2 = nv;
}
void hooks::iw5mp_functions::ns_GetChallengeS2::Set_P3(uint32_t nv) noexcept
{
newData.p3 = nv;
}
void hooks::iw5mp_functions::ns_GetChallengeS2::Set_P4(uint32_t nv) noexcept
{
newData.p4 = nv;
}

23
ultimateteknotool.v2/JMP_iw5mp_functions.h Normal file
View File

@ -0,0 +1,23 @@
#pragma once
#include <stdint.h>
#include "Hooker_JMP.h"
namespace hooks
{
namespace iw5mp_functions
{
bool JMPHook_GetChallengeS2(uint32_t addr, uint8_t asmlen);
namespace ns_GetChallengeS2
{
uint32_t Get_P1() noexcept;
uint32_t Get_P2() noexcept;
uint32_t Get_P3() noexcept;
uint32_t Get_P4() noexcept;
void Set_P1(uint32_t nv) noexcept;
void Set_P2(uint32_t nv) noexcept;
void Set_P3(uint32_t nv) noexcept;
void Set_P4(uint32_t nv) noexcept;
};
};
};

2
ultimateteknotool.v2/LazyBuffer.cpp Normal file
View File

@ -0,0 +1,2 @@
#include "pch.h"
#include "LazyBuffer.h"

279
ultimateteknotool.v2/LazyBuffer.h Normal file
View File

@ -0,0 +1,279 @@
#pragma once
#include <vector>
#include "debugconsole.h"
#include "DRM/DRM_DllUnloadThread.h"
template<typename T1, unsigned short SIZE>
class LazyBuffer
{
private:
std::vector<T1> m_vec;
unsigned short m_currentNullPos = 0;
public:
LazyBuffer():m_vec(SIZE+4, 0)
{
}
~LazyBuffer() = default;
T1* GetNulledMem(unsigned short sz)
{
if (sz > SIZE)
{
throw 1;
}
if (sz + m_currentNullPos > SIZE)
{
for (auto& x : this->m_vec) { x = 0; }
this->m_currentNullPos = 0;
this->m_currentNullPos += sz;
return &(this->m_vec[0]);
}
else
{
this->m_currentNullPos += sz;
return this->m_vec.data() + (this->m_currentNullPos - sz);
}
}
#ifdef UTT2_DEBUG
void fill(T1* p, unsigned short sz, T1 value = 1)
{
for (unsigned short i = 0; i < sz; i++)
{
p[i] = value;
}
}
bool checvalid()
{
// asked sz -> next byte/wchar_t must be null
unsigned short verifyer = this->m_currentNullPos;
while (verifyer < SIZE+1)
{
if (*(this->m_vec.data() + verifyer) != 0)
{
WCWOUT(std::dec,L"Check failed at this->m_vec[",verifyer,L"]");
return false;
}
verifyer++;
}
return true;
}
bool Test()
{
T1* p = nullptr;
unsigned short sz = SIZE / 2;
p = this->GetNulledMem(sz);
fill(p, sz);
if (!checvalid()) { return false; }
p = this->GetNulledMem(sz);
fill(p, sz);
if (!checvalid()) { return false; };
p = this->GetNulledMem(sz);
fill(p, sz);
if (!checvalid()) { return false; }
p = this->GetNulledMem(sz+1);
fill(p, sz);
if (!checvalid()) { return false; }
sz = 100;
p = this->GetNulledMem(sz);
fill(p, sz);
if (!checvalid()) { return false; }
p = this->GetNulledMem(sz);
fill(p, sz);
if (!checvalid()) { return false; }
p = this->GetNulledMem(sz);
fill(p, sz);
if (!checvalid()) { return false; }
p = this->GetNulledMem(sz);
fill(p, sz);
if (!checvalid()) { return false; }
p = this->GetNulledMem(sz);
fill(p, sz);
if (!checvalid()) { return false; }
p = this->GetNulledMem(sz);
fill(p, sz);
if (!checvalid()) { return false; }
sz = SIZE - 1;
p = this->GetNulledMem(sz);
fill(p, sz);
if (!checvalid()) { return false; }
sz = 1;
p = this->GetNulledMem(sz);
fill(p, sz);
if (!checvalid()) { return false; }
sz = SIZE - 1;
p = this->GetNulledMem(sz);
fill(p, sz);
if (!checvalid()) { return false; }
sz = 2;
p = this->GetNulledMem(sz);
fill(p, sz);
if (!checvalid()) { return false; }
return true;
}
#endif
};
template<unsigned short SIZE>
using LazyBuffer_wchart = LazyBuffer<wchar_t, SIZE>;
template<unsigned short SIZE>
using LazyBuffer_char = LazyBuffer<char, SIZE>;
template<typename T1, unsigned short SECTIONSIZE, unsigned char NUMBEROFSECTIONS>
class LazySectionBuffer
{
private:
std::vector<T1> m_vec;
T1* retAddr[NUMBEROFSECTIONS] = { nullptr };
public:
LazySectionBuffer():m_vec(SECTIONSIZE * NUMBEROFSECTIONS + 4, 0)
{
for(unsigned char i = 0; i < NUMBEROFSECTIONS; i++)
{
this->retAddr[i] = this->m_vec.data() + SECTIONSIZE * i;
}
}
~LazySectionBuffer() = default;
T1* GetNulledMem(unsigned short sz, unsigned char section_id)
{
if (sz > SECTIONSIZE || section_id >= NUMBEROFSECTIONS)
{
throw 1;
}
//WCWOUT(L"ret[", std::dec, section_id, L"] = &(this->m_vec[", retAddr[section_id] - this->m_vec.data(), L"]) when size = ", sz);
if (retAddr[section_id] + sz > this->m_vec.data() + SECTIONSIZE * section_id + SECTIONSIZE)
{
retAddr[section_id] = this->m_vec.data() + SECTIONSIZE * section_id;
for (size_t i = 0; i < SECTIONSIZE; i++)
{
retAddr[section_id][i] = 0x00;
}
retAddr[section_id] += sz;
//WCWOUT(L"return = ", std::dec, retAddr[section_id] - this->m_vec.data() - sz);
return retAddr[section_id] - sz;
}
else
{
retAddr[section_id] += sz;
//WCWOUT(L"return = ", std::dec, retAddr[section_id] - this->m_vec.data() - sz );
return retAddr[section_id] - sz;
}
}
#ifdef UTT2_DEBUG
bool VerifyMem_OnlyOneSection(unsigned char secID)
{
T1* vecData = this->m_vec.data() + SECTIONSIZE * secID;
size_t SZ = retAddr[secID] - vecData;
if (SZ > SECTIONSIZE)
{
WCWOUT(L"LazySectionBuffer->VerifyMem(): false->SZ > SECTIONSIZE");
return false;
}
for (size_t i = SZ; i < SECTIONSIZE; i++)
{
if (retAddr[secID][i] != 0)
{
WCWOUT(L"LazySectionBuffer->VerifyMem(): false->retAddr[", std::dec, secID, L"][", i , L"] != 0" );
return false;
}
}
if ((this->m_vec.data() + SECTIONSIZE * secID)[SECTIONSIZE] != 0)
{
WCWOUT(L"LazySectionBuffer->VerifyMem(): false->(this->m_vec.data() + SECTIONSIZE * secID)[SECTIONSIZE] != 0");
return false;
}
return true;
}
bool VerifyMem_allfilled(unsigned char secID, unsigned short size)
{
T1* vecData = this->m_vec.data() + secID * SECTIONSIZE;
size_t SZ = retAddr[secID] - vecData;
if (SZ != size)
{
WCWOUT(L"LazySectionBuffer->VerifyMem_allfilled(): false->wrong pointer, size is ", SZ, L" when expect ", size);
return false;
}
for (size_t i = 0; i < size; i++)
{
if (vecData[i] == 0)
{
WCWOUT(L"LazySectionBuffer->VerifyMem(): false->not filled");
return false;
}
}
return true;
}
void fill(T1* p, unsigned short sz, T1 value = 1)
{
if (p == nullptr)
{
WCWOUT(L"LazySectionBuffer->fill(): nullptr?");
}
else {
for (unsigned short i = 0; i < sz; i++)
{
p[i] = value;
}
}
}
bool Test1()
{
unsigned short memSize = SECTIONSIZE / 2;
T1* pData = this->GetNulledMem(memSize, 0); this->fill(pData, memSize);
if (VerifyMem_OnlyOneSection(0))
{
pData = this->GetNulledMem(memSize, 0); this->fill(pData, memSize);
if (VerifyMem_OnlyOneSection(0))
{
return true;
}
}
return false;
}
bool Test2()
{
unsigned short memSize = SECTIONSIZE / 2;
T1* pData = nullptr;
for (auto& x : this->m_vec) { x = 0; }
for (unsigned char i = 0; i < NUMBEROFSECTIONS; i++)
{
pData = this->GetNulledMem(memSize, i);
this->fill(pData, memSize);
pData = this->GetNulledMem(memSize, i);
this->fill(pData, memSize);
if (VerifyMem_allfilled(i, memSize * 2) == false || VerifyMem_OnlyOneSection(i) == false) { return false; }
}
memSize = 1;
if (SECTIONSIZE - memSize * 2)
{
memSize = 2;
}
for (unsigned char i = 0; i < NUMBEROFSECTIONS; i++)
{
pData = this->GetNulledMem(memSize, i);
this->fill(pData, memSize);
pData = this->GetNulledMem(memSize, i);
this->fill(pData, memSize);
if (VerifyMem_allfilled(i, memSize * 2) == false) { return false; }
}
memSize = SECTIONSIZE / 2 + 1;
for (unsigned char i = 0; i < NUMBEROFSECTIONS; i++)
{
pData = this->GetNulledMem(memSize, i);
this->fill(pData, memSize);
pData = this->GetNulledMem(memSize, i);
this->fill(pData, memSize);
if (VerifyMem_allfilled(i, memSize) == false) { return false; }
}
return true;
}
#endif
};
template<unsigned short SECTIONSIZE, unsigned char NUMBEROFSECTIONS>
using LazySectionBuffer_wchart = LazySectionBuffer<wchar_t, SECTIONSIZE, NUMBEROFSECTIONS>;
template<unsigned short SECTIONSIZE, unsigned char NUMBEROFSECTIONS>
using LazySectionBuffer_char = LazySectionBuffer<char, SECTIONSIZE, NUMBEROFSECTIONS>;

5
ultimateteknotool.v2/LazyBuffer_512wchart.cpp Normal file
View File

@ -0,0 +1,5 @@
#include "pch.h"
#include "LazyBuffer_512wchart.h"
//LazyBuffer_wchart<512>lazybuffer512wchart;
LazySectionBuffer_wchart<512, 3> lazysectionbuffer_3x512;

5
ultimateteknotool.v2/LazyBuffer_512wchart.h Normal file
View File

@ -0,0 +1,5 @@
#pragma once
#include "LazyBuffer.h"
//extern LazyBuffer_wchart<512>lazybuffer512wchart;
extern LazySectionBuffer_wchart<512, 3> lazysectionbuffer_3x512;

7
ultimateteknotool.v2/MainWindowSizes.cpp Normal file
View File

@ -0,0 +1,7 @@
#include "pch.h"
namespace MainWindowSizes
{
constexpr int width = 620;
constexpr int height = 450 + 6;
};

34
ultimateteknotool.v2/ParserRandMask.cpp Normal file
View File

@ -0,0 +1,34 @@
#include "pch.h"
#include "ParserRandMask.h"
#include "Randomizer.h"
void parsers::ParseRandMaskTextW(const wchar_t* randmask, const size_t randmask_sz, wchar_t* output, const size_t output_sz)
{
for (size_t i = 0; i < randmask_sz && i < output_sz; i++)
{
if (randmask[i] == 'd')
{
output[i] = static_cast<wchar_t>(RANDANSIDIGIT);
}
else if (randmask[i] == 'u')
{
output[i] = static_cast<wchar_t>(RANDANSIUPPERCASE);
}
else if (randmask[i] == 'l')
{
output[i] = static_cast<wchar_t>(RANDANSILOWCASE);
}
else if (randmask[i] == 'c')
{
output[i] = static_cast<wchar_t>(RANDANSICHAR);
}
else if (randmask[i] == 'h')
{
output[i] = static_cast<wchar_t>(RANDHEXSYMBOL);
}
else
{
output[i] = randmask[i];
}
}
}

7
ultimateteknotool.v2/ParserRandMask.h Normal file
View File

@ -0,0 +1,7 @@
#pragma once
namespace parsers
{
typedef void (parserfunction_t)(const wchar_t* randmask, const size_t randmask_sz, wchar_t* output, const size_t output_sz);
void ParseRandMaskTextW(const wchar_t* randmask, const size_t randmask_sz, wchar_t* output, const size_t output_sz);
};

176
ultimateteknotool.v2/PatternSearcher.cpp Normal file
View File

@ -0,0 +1,176 @@
#include "pch.h"
#include "PatternSearcher.h"
static_assert(0xFF == (0x0F | 0xF0), "");
static_assert(0xFF == (0xF0 | 0x0F), "");
static constexpr uint8_t PATTERN_MAXSIZE_BYTES = 16;
struct SmartByte
{
uint8_t value = 0;
uint8_t mustbeskipped = 0;
};
uint8_t ConvertCharToByte(char left, char right)
{
uint8_t ret = 0;
switch (left)
{
case '0':
ret = 0x00;
break;
case '1':
ret = 0x10;
break;
case '2':
ret = 0x20;
break;
case '3':
ret = 0x30;
break;
case '4':
ret = 0x40;
break;
case '5':
ret = 0x50;
break;
case '6':
ret = 0x60;
break;
case '7':
ret = 0x70;
break;
case '8':
ret = 0x80;
break;
case '9':
ret = 0x90;
break;
case 'A':
ret = 0xA0;
break;
case 'B':
ret = 0xB0;
break;
case 'C':
ret = 0xC0;
break;
case 'D':
ret = 0xD0;
break;
case 'E':
ret = 0xE0;
break;
case 'F':
ret = 0xF0;
break;
default:
break;
}
switch (right)
{
case '0':
ret = ret | 0x00;
break;
case '1':
ret = ret | 0x01;
break;
case '2':
ret = ret | 0x02;
break;
case '3':
ret = ret | 0x03;
break;
case '4':
ret = ret | 0x04;
break;
case '5':
ret = ret | 0x05;
break;
case '6':
ret = ret | 0x06;
break;
case '7':
ret = ret | 0x07;
break;
case '8':
ret = ret | 0x08;
break;
case '9':
ret = ret | 0x09;
break;
case 'A':
ret = ret | 0x0A;
break;
case 'B':
ret = ret | 0x0B;
break;
case 'C':
ret = ret | 0x0C;
break;
case 'D':
ret = ret | 0x0D;
break;
case 'E':
ret = ret | 0x0E;
break;
case 'F':
ret = ret | 0x0F;
break;
default:
break;
}
return ret;
}
uint32_t patternsearcher::PatternSearch(char* pattern, uint32_t start_address, uint32_t maxdeep)
{
SmartByte BYTES[PATTERN_MAXSIZE_BYTES] = { 0 };
uint8_t counter = 0;
uint8_t bytepos = 0;
for (; pattern[counter] && pattern[counter + 1] && counter/2 < PATTERN_MAXSIZE_BYTES;)
{
if (pattern[counter] == '?' && pattern[counter + 1] == '?')
{
BYTES[counter/2].mustbeskipped = 0x01;
}
else
{
BYTES[counter/2].value = ConvertCharToByte(pattern[counter], pattern[counter + 1]);
}
counter += 2;
}
counter = counter / 2;
uint32_t RET = start_address;
uint8_t verify = 0;
for (; RET < (start_address + maxdeep);)
{
if (*reinterpret_cast<uint8_t*>(RET) == BYTES[0].value)
{
for (verify = 1; verify < counter; verify++)
{
RET++;
if (BYTES[verify].mustbeskipped == 0x00) {
if (*reinterpret_cast<uint8_t*>(RET) != BYTES[verify].value)
{
break;
}
else
{
continue;
}
}
else
{
continue;
}
}
if (verify == counter) {
return RET - verify + 1; }
}
RET++;
}
return 0;
}

6
ultimateteknotool.v2/PatternSearcher.h Normal file
View File

@ -0,0 +1,6 @@
#pragma once
#include "debugconsole.h"
#include <stdint.h>
namespace patternsearcher {
uint32_t PatternSearch(char* pattern, uint32_t start_address, uint32_t maxdeep);
};

50
ultimateteknotool.v2/ProcessController.h Normal file
View File

@ -0,0 +1,50 @@
#pragma once
#include <windows.h>
#include <tlhelp32.h>
namespace ProcessController
{
/* following Raymond, 2006 microsoft devblog */
void SuspendThreads(bool suspend)
{
DWORD ProcId = 0;
DWORD ThreadId = 0;
ProcId = ::GetCurrentProcessId();
ThreadId = ::GetCurrentThreadId();
HANDLE snapthreads = ::CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
if (snapthreads == INVALID_HANDLE_VALUE) { return; }
else
{
THREADENTRY32 threadentry = { 0 };
threadentry.dwSize = sizeof(THREADENTRY32);
if (::Thread32First(snapthreads, &threadentry) == TRUE)
{
HANDLE threadhandle = NULL;
do
{
if (threadentry.dwSize >= FIELD_OFFSET(THREADENTRY32, th32OwnerProcessID) +
sizeof(threadentry.th32OwnerProcessID))
{
if (threadentry.th32OwnerProcessID == ProcId) {
if (threadentry.th32ThreadID == ThreadId) {}
else {
threadhandle = ::OpenThread(THREAD_ALL_ACCESS, FALSE, threadentry.th32ThreadID);
if (threadhandle != NULL && threadhandle != INVALID_HANDLE_VALUE)
{
if (suspend) { ::SuspendThread(threadhandle); }
else { ::ResumeThread(threadhandle); }
::CloseHandle(threadhandle);
}
}
}
}
threadentry.dwSize = sizeof(threadentry);
}
while (::Thread32Next(snapthreads, &threadentry));
}
::CloseHandle(snapthreads);
}
}
};

78
ultimateteknotool.v2/Randomizer.cpp Normal file
View File

@ -0,0 +1,78 @@
#include "pch.h"
#include "Randomizer.h"
std::once_flag Randomizer::m_createonceflag;
std::unique_ptr<Randomizer> Randomizer::m_pInstance;
XORShiftSeeder Randomizer::m_xorshift;
std::uniform_int_distribution<unsigned int> Randomizer::m_distrByte;
std::uniform_int_distribution<unsigned int> Randomizer::m_distrByteHighBit_1;
std::uniform_int_distribution<unsigned int> Randomizer::m_distrByteHighBit_0;
std::uniform_int_distribution<unsigned int> Randomizer::m_ANSIdigit;
std::uniform_int_distribution<unsigned int> Randomizer::m_ANSIuppercase;
std::uniform_int_distribution<unsigned int> Randomizer::m_ANSIlowcase;
std::uniform_int_distribution<unsigned int> Randomizer::m_ANSIchar;
std::uniform_int_distribution<unsigned int> Randomizer::m_ANSIfromAtoF;
std::uniform_int_distribution<unsigned int> Randomizer::m_ANSIfromAtoF_lower;
Randomizer & Randomizer::GetInstance()
{
std::call_once(Randomizer::m_createonceflag, [] {
Randomizer::m_pInstance.reset(new Randomizer);
});
return *Randomizer::m_pInstance.get();
}
uint8_t Randomizer::GetSingleByte(Randomizer::FillType type)
{
switch (type)
{
case Randomizer::FillType::_0_to_127:
return static_cast<uint8_t>(Randomizer::m_distrByteHighBit_0(Randomizer::m_xorshift));
case Randomizer::FillType::_128_to_255:
return static_cast<uint8_t>(Randomizer::m_distrByteHighBit_1(Randomizer::m_xorshift));
case Randomizer::FillType::_0_to_255:
return static_cast<uint8_t>(Randomizer::m_distrByte(Randomizer::m_xorshift));
case Randomizer::FillType::ANSIchar:
return static_cast<uint8_t>(Randomizer::m_ANSIchar(Randomizer::m_xorshift));
case Randomizer::FillType::ANSIdigit:
return static_cast<uint8_t>(Randomizer::m_ANSIdigit(Randomizer::m_xorshift));
case Randomizer::FillType::ANSIlowcase:
return static_cast<uint8_t>(Randomizer::m_ANSIlowcase(Randomizer::m_xorshift));
case Randomizer::FillType::ANSIuppercase:
return static_cast<uint8_t>(Randomizer::m_ANSIuppercase(Randomizer::m_xorshift));
case Randomizer::FillType::ANSIfromAtoF:
return static_cast<uint8_t>(Randomizer::m_ANSIfromAtoF(Randomizer::m_xorshift));
case Randomizer::FillType::ANSIfromAtoF_lower:
return static_cast<uint8_t>(Randomizer::m_ANSIfromAtoF_lower(Randomizer::m_xorshift));
default:
return static_cast<uint8_t>(Randomizer::m_distrByte(Randomizer::m_xorshift));
}
}
Randomizer::Randomizer()
{
std::random_device randomdevice;
Randomizer::m_xorshift = XORShiftSeeder(randomdevice);
Randomizer::m_distrByte = std::uniform_int_distribution<unsigned int>(0, 255);
Randomizer::m_distrByteHighBit_1 = std::uniform_int_distribution<unsigned int>(128, 255);
Randomizer::m_distrByteHighBit_0 = std::uniform_int_distribution<unsigned int>(0, 127);
Randomizer::m_ANSIdigit = std::uniform_int_distribution<unsigned int>(48, 57);
Randomizer::m_ANSIuppercase = std::uniform_int_distribution<unsigned int>(65, 90);
Randomizer::m_ANSIlowcase = std::uniform_int_distribution<unsigned int>(97, 122);
Randomizer::m_ANSIchar = std::uniform_int_distribution<unsigned int>(33, 126);
Randomizer::m_ANSIfromAtoF = std::uniform_int_distribution<unsigned int>(65, 70);
Randomizer::m_ANSIfromAtoF_lower = std::uniform_int_distribution<unsigned int>('a', 'f');
}
bool operator==(XORShiftSeeder const& lhs, XORShiftSeeder const& rhs)
{
return lhs.m_seed == rhs.m_seed;
}
bool operator!=(XORShiftSeeder const& lhs, XORShiftSeeder const& rhs)
{
return lhs.m_seed != rhs.m_seed;
}

89
ultimateteknotool.v2/Randomizer.h Normal file
View File

@ -0,0 +1,89 @@
#pragma once
#include <memory>
#include <mutex>
#include <random>
class XORShiftSeeder; // stolen from https://arvid.io/2018/07/02/better-cxx-prng/
class Randomizer
{
public:
~Randomizer() = default;
static Randomizer& GetInstance();
enum FillType { _0_to_255, _0_to_127, _128_to_255, ANSIdigit, ANSIuppercase, ANSIlowcase, ANSIchar, ANSIfromAtoF, ANSIfromAtoF_lower
};
uint8_t GetSingleByte(FillType type);
private:
Randomizer();
static std::once_flag m_createonceflag;
static std::unique_ptr<Randomizer> m_pInstance;
Randomizer(const Randomizer&) = delete;
Randomizer(Randomizer&&) = delete;
Randomizer& operator=(const Randomizer&) = delete;
Randomizer& operator=(Randomizer&&) = delete;
static XORShiftSeeder m_xorshift;
static std::uniform_int_distribution<unsigned int> m_distrByte;
static std::uniform_int_distribution<unsigned int> m_distrByteHighBit_1;
static std::uniform_int_distribution<unsigned int> m_distrByteHighBit_0;
static std::uniform_int_distribution<unsigned int> m_ANSIdigit;
static std::uniform_int_distribution<unsigned int> m_ANSIuppercase;
static std::uniform_int_distribution<unsigned int> m_ANSIlowcase;
static std::uniform_int_distribution<unsigned int> m_ANSIchar;
static std::uniform_int_distribution<unsigned int> m_ANSIfromAtoF;
static std::uniform_int_distribution<unsigned int> m_ANSIfromAtoF_lower;
};
#define RANDBYTE Randomizer::GetInstance().GetSingleByte(Randomizer::FillType::_0_to_255)
#define RANDBYTEH0 Randomizer::GetInstance().GetSingleByte(Randomizer::FillType::_0_to_127)
#define RANDBYTEH1 Randomizer::GetInstance().GetSingleByte(Randomizer::FillType::_128_to_255)
#define RANDANSIDIGIT Randomizer::GetInstance().GetSingleByte(Randomizer::FillType::ANSIdigit)
#define RANDANSIUPPERCASE Randomizer::GetInstance().GetSingleByte(Randomizer::FillType::ANSIuppercase)
#define RANDANSILOWCASE Randomizer::GetInstance().GetSingleByte(Randomizer::FillType::ANSIlowcase)
#define RANDANSICHAR Randomizer::GetInstance().GetSingleByte(Randomizer::FillType::ANSIchar)
#define RANDHEXSYMBOL (Randomizer::GetInstance().GetSingleByte(Randomizer::FillType::_0_to_127) < 64) ? \
Randomizer::GetInstance().GetSingleByte(Randomizer::FillType::ANSIfromAtoF_lower) : RANDANSIDIGIT
#define RANDALNUM RANDBYTEH0 < 64 ? RANDANSIUPPERCASE : (RANDBYTEH0 < 64 ? RANDANSILOWCASE : RANDANSIDIGIT)
class XORShiftSeeder
{
public:
using result_type = uint32_t;
static constexpr result_type(min)() { return 0; }
static constexpr result_type(max)() { return UINT32_MAX; }
friend bool operator==(XORShiftSeeder const &, XORShiftSeeder const &);
friend bool operator!=(XORShiftSeeder const &, XORShiftSeeder const &);
XORShiftSeeder() : m_seed(0xc1f651c67c62c6e0ull) {}
explicit XORShiftSeeder(std::random_device &rd)
{
seed(rd);
}
void seed(std::random_device &rd)
{
m_seed = uint64_t(rd()) << 31 | uint64_t(rd());
}
result_type operator()()
{
uint64_t result = m_seed * 0xd989bcaef137dcd5ull;
m_seed ^= m_seed >> 11;
m_seed ^= m_seed << 31;
m_seed ^= m_seed >> 18;
return uint32_t(result >> 32ull);
}
void discard(unsigned long long n)
{
for (unsigned long long i = 0; i < n; ++i)
operator()();
}
private:
uint64_t m_seed;
};

79
ultimateteknotool.v2/Serializers.cpp Normal file
View File

@ -0,0 +1,79 @@
#include "pch.h"
#include "Serializers.h"
size_t serializer::SerialTextW(const wchar_t* input, const size_t input_sz, wchar_t* output, const size_t sz)
{
size_t i = 0;
for (; i < sz && i < input_sz; i++)
{
if (!input[i])
{
output[i] = serializer::constants::WDelimeter;
return i + 1;
}
output[i] = input[i];
}
i--;
output[i] = serializer::constants::WDelimeter;
return i + 1;
}
size_t serializer::SerialButtonStateW(bool state, ButtonStateWDescriptor& desc)
{
desc.SetState(state);
return desc.RetSize();
}
size_t serializer::SerialButtonStateW(bool state, wchar_t* output, const size_t sz)
{
ButtonStateWDescriptor desc = { 0 };
desc.SetState(state);
if (desc.RetSize() > sz) { return 0; }
else
{
static_assert(ButtonStateWDescriptor::SIZE == 2, "ButtonStateWDescriptor::SIZE is not 2");
output[0] = desc.text[0];
output[1] = desc.text[1];
return desc.RetSize();
}
}
size_t serializer::DeserialTextW(const wchar_t* inputdata, const size_t& inputsize, wchar_t* outputdata, const size_t& outputsize)
{
decltype(inputsize + outputsize)i = 0;
for (; i < inputsize && i < outputsize; i++)
{
if (inputdata[i] == serializer::constants::WDelimeter)
{
return i + 1;
}
outputdata[i] = inputdata[i];
}
return 0u;
}
size_t serializer::DeserialButtonStateW(const wchar_t* inputdata, const size_t& inputsize, bool& state)
{
if (inputsize < 2) { return 0u; }
if (inputdata[0] == serializer::constants::WButtonPressed)
{
state = true;
}
else if(inputdata[0] == serializer::constants::WButtonIsNotPressed)
{
state = false;
}
else
{
return 0u;
}
if (inputdata[1] == serializer::constants::WDelimeter)
{
return 2;
}
else
{
return 0u;
}
}

30
ultimateteknotool.v2/Serializers.h Normal file
View File

@ -0,0 +1,30 @@
#pragma once
namespace serializer
{
namespace constants
{
constexpr wchar_t WDelimeter = 0x2049;
constexpr wchar_t WButtonPressed = L'1';
constexpr wchar_t WButtonIsNotPressed = L'0';
};
struct ButtonStateWDescriptor
{
static constexpr unsigned short SIZE = 2;
wchar_t text[SIZE] = { 0 , 0 };
void SetState(bool state)
{
if (state) { text[0] = constants::WButtonPressed; }
else {
text[0] = constants::WButtonIsNotPressed;
}
text[SIZE - 1] = constants::WDelimeter;
}
size_t RetSize() const { return SIZE; }
// state, delimeter
};
size_t SerialTextW(const wchar_t* input, const size_t input_sz, wchar_t* output, const size_t sz);
size_t SerialButtonStateW(bool state, ButtonStateWDescriptor& desc);
size_t SerialButtonStateW(bool state, wchar_t* output, const size_t sz);
size_t DeserialTextW(const wchar_t* inputdata, const size_t& inputsize, wchar_t* outputdata, const size_t& outputsize);
size_t DeserialButtonStateW(const wchar_t* inputdata, const size_t& inputsize, bool& state);
};

68
ultimateteknotool.v2/SystemFunctionXRefRemover.h Normal file
View File

@ -0,0 +1,68 @@
#pragma once
#include <stdint.h>
#include "debugconsole.h"
template<size_t BFSZ>
struct XRefRemover_SysFunctionUI32
{
uint32_t _pointers[BFSZ];
XRefRemover_SysFunctionUI32()
{
if (BFSZ < 4) { throw 1; }
_pointers[0] = 0x00;
for (size_t sz = 1; sz < BFSZ; sz++)
{
_pointers[sz] = _pointers[0];
}
}
~XRefRemover_SysFunctionUI32() = default;
#define XRefRemover_FAKEADR(index) index + fake_address - xfake_address
#pragma optimize("" ,off)
template<uint32_t fake_address>
void AddNewFunction(void* addr, uint32_t xfake_address)
{
_pointers[XRefRemover_FAKEADR(0)] = *reinterpret_cast<uint32_t*>(addr);
_pointers[XRefRemover_FAKEADR(1)] = reinterpret_cast<uint32_t>(addr) ^ _pointers[0];
_pointers[XRefRemover_FAKEADR(2)] = *(reinterpret_cast<uint32_t*>(addr) + 1);
}
template<uint32_t fake_address>
void* GetFunction(uint32_t xfake_address) const
{
return reinterpret_cast<void*>(_pointers[XRefRemover_FAKEADR(1)] ^ _pointers[XRefRemover_FAKEADR(0)]);
}
void VerifyFunction() const
{
uint32_t addr = 0x00;
if (
*reinterpret_cast<uint32_t*>(_pointers[1] ^ _pointers[0]) != _pointers[0]
)
{
addr = 0x7F340000;
__asm {
jmp [addr];
}
}
else if (*(reinterpret_cast<uint32_t*>(_pointers[1] ^ _pointers[0]) + 1) != _pointers[2])
{
addr = 0x0010AB00;
__asm {
jmp [addr];
}
}
else
{
}
}
template<uint32_t fake_address>
void* GetVerifiedFunction(uint32_t xfake_address) const
{
this->VerifyFunction();
return this->GetFunction<fake_address>(xfake_address);
}
size_t Size() const noexcept { return BFSZ; }
#undef XRefRemover_FAKEADR
#pragma optimize("" ,on)
};

209
ultimateteknotool.v2/TextConvertors.cpp Normal file
View File

@ -0,0 +1,209 @@
#include "pch.h"
#include "TextConvertors.h"
static std::wistringstream inputWstringstream;
static std::wostringstream outputWstringstream(L"");
static std::wstring aaaaaa;
static LazyBuffer_wchart<256> LazyW256;
static LazyBuffer_char<256> LazyC256;
uint32_t textconvertors::ConvertWTextHexTypeToU32(const wchar_t* text)
{
inputWstringstream.clear();
inputWstringstream.str(text);
uint32_t ret = 0;
if (inputWstringstream >> std::hex >> ret)
{
return ret;
}
else
{
return 0;
}
}
uint32_t textconvertors::ConvertWTextDecTypeToU32(const wchar_t* text)
{
inputWstringstream.clear();
inputWstringstream.str(text);
uint32_t ret = 0;
if (inputWstringstream >> std::dec >> ret)
{
return ret;
}
else
{
return 0;
}
}
const wchar_t* textconvertors::ConvertHexTypeU32ToWText(const uint32_t value)
{
//greatstringstream.clear();
outputWstringstream.str(L"00000000");
outputWstringstream << std::hex << value;
aaaaaa = outputWstringstream.str();
return aaaaaa.c_str();
}
const wchar_t* textconvertors::ConvertDecTypeU32ToWText(const uint32_t value)
{
//greatstringstream.clear();
outputWstringstream.str(L"0");
outputWstringstream << std::dec << value;
aaaaaa = outputWstringstream.str();
return aaaaaa.c_str();
}
uint16_t textconvertors::ConvertWTextDecTypeToU16(const wchar_t* text)
{
inputWstringstream.clear();
inputWstringstream.str(text);
uint16_t PortInput = 0;
if (inputWstringstream >> std::dec >> PortInput) {
return PortInput;
}
else
{
return 0;
}
}
const wchar_t* textconvertors::ConvertDecTypeToU16ToWText(const uint16_t value)
{
outputWstringstream.str(L"0");
outputWstringstream << std::dec << value;
aaaaaa = outputWstringstream.str();
return aaaaaa.c_str();
}
void textconvertors::ConvertWTextToIP(const wchar_t* text, uint8_t NewIP[4])
{
inputWstringstream.clear();
inputWstringstream.str(text);
wchar_t ignore;
uint32_t NewIPinput[4];
if (inputWstringstream >> std::dec >> NewIPinput[0] >> ignore >> NewIPinput[1] >> ignore >> NewIPinput[2] >> ignore >> NewIPinput[3])
{
NewIPinput[0] <<= 24; NewIPinput[1] <<= 24; NewIPinput[2] <<= 24; NewIPinput[3] <<= 24;
NewIP[0] = ((NewIPinput[0] >> 24) & 0xFF);
NewIP[1] = ((NewIPinput[1] >> 24) & 0xFF);
NewIP[2] = ((NewIPinput[2] >> 24) & 0xFF);
NewIP[3] = ((NewIPinput[3] >> 24) & 0xFF);
}
else
{
NewIP[0] = 0;
NewIP[1] = 0;
NewIP[2] = 0;
NewIP[3] = 0;
}
}
const wchar_t* textconvertors::ConvertIPToWText(const uint8_t NewIP[4])
{
outputWstringstream.str(L"");
outputWstringstream << std::dec <<
static_cast<uint16_t>(NewIP[0]) << L'.' <<
static_cast<uint16_t>(NewIP[1]) << L'.' <<
static_cast<uint16_t>(NewIP[2]) << L'.' <<
static_cast<uint16_t>(NewIP[3]);
aaaaaa = outputWstringstream.str();
return aaaaaa.c_str();
}
const wchar_t* textconvertors::ConvertU8TextToWText_StupidButFast(const uint8_t* data, unsigned short sz)
{
wchar_t* diesoon = LazyW256.GetNulledMem(sz + 2);
for (size_t i = 0; i < sz && data[i]; i++)
{
diesoon[i] = static_cast<wchar_t>(data[i]);
}
return diesoon;
}
const wchar_t* textconvertors::ConvertU8TextToWText_StupidButFast_graphNspace(const uint8_t* data, unsigned short sz)
{
wchar_t* diesoon = LazyW256.GetNulledMem(sz + 2);
for (size_t i = 0; i < sz && (::isgraph(data[i]) || data[i] == static_cast<uint8_t>(' ')); i++)
{
diesoon[i] = static_cast<wchar_t>(data[i]);
}
return diesoon;
}
const wchar_t* textconvertors::ConvertCharTextToWText_StupidButFast(const char* data, unsigned short sz)
{
wchar_t* diesoon = LazyW256.GetNulledMem(sz + 2);
for (size_t i = 0; i < sz && data[i]; i++)
{
diesoon[i] = static_cast<wchar_t>(data[i]);
}
return diesoon;
}
static_assert(sizeof(wchar_t) == sizeof(char) * 2, "size of wchar_t is not equal to size of two char");
static_assert(sizeof(wchar_t) == sizeof(uint8_t) * 2, "size of wchar_t is not equal to size of two uint8_t");
static_assert(sizeof(char) == sizeof(uint8_t), "size of char is not equal to size of uint8_t");
const uint8_t* textconvertors::ConvertWTextToU8Text(const wchar_t* src, unsigned short sz)
{
uint8_t* diesoon = reinterpret_cast<uint8_t*>(LazyC256.GetNulledMem(sz + 2));
const uint8_t* txtp = reinterpret_cast<const uint8_t*>(src);
for (decltype(sz) i = 0; i < sz && txtp[2*i]; i++)
{
diesoon[i] = txtp[2 * i];
}
return diesoon;
}
const char* textconvertors::ConvertWTextToCharText(const wchar_t* src, unsigned short sz)
{
char* diesoon = LazyC256.GetNulledMem(sz + 2);
const char* txtp = reinterpret_cast<const char*>(src);
for (decltype(sz) i = 0; i < sz && txtp[2 * i]; i++)
{
diesoon[i] = txtp[2 * i];
}
return diesoon;
}
const std::wstring& textconvertors::ret_stdstring::ConvertDecTypeU32ToWText(const uint32_t v)
{
outputWstringstream.str(L"0");
outputWstringstream << std::dec << v;
aaaaaa = outputWstringstream.str();
return aaaaaa;
}
const std::wstring& textconvertors::ret_stdstring::ConvertHexTypeU32ToWText(const uint32_t v)
{
outputWstringstream.str(L"0");
outputWstringstream << std::hex << v;
aaaaaa = outputWstringstream.str();
return aaaaaa;
}
const std::wstring& textconvertors::ret_stdstring::ConvertDecTypeU16ToWText(const uint16_t v)
{
outputWstringstream.str(L"0");
outputWstringstream << std::dec << v;
aaaaaa = outputWstringstream.str();
return aaaaaa;
}
const std::wstring& textconvertors::ret_stdstring::ConvertIPToWText(const uint8_t NewIP[4])
{
outputWstringstream.str(L"");
outputWstringstream << std::dec <<
static_cast<uint16_t>(NewIP[0]) << L'.' <<
static_cast<uint16_t>(NewIP[1]) << L'.' <<
static_cast<uint16_t>(NewIP[2]) << L'.' <<
static_cast<uint16_t>(NewIP[3]);
aaaaaa = outputWstringstream.str();
return aaaaaa;
}

37
ultimateteknotool.v2/TextConvertors.h Normal file
View File

@ -0,0 +1,37 @@
#pragma once
#include <stdint.h>
#include <sstream>
#include "LazyBuffer.h"
namespace textconvertors
{
/* never hold returned pointers if you don't know what you exactly do */
uint32_t ConvertWTextHexTypeToU32(const wchar_t* text);
uint32_t ConvertWTextDecTypeToU32(const wchar_t* text);
const wchar_t* ConvertHexTypeU32ToWText(const uint32_t v);
const wchar_t* ConvertDecTypeU32ToWText(const uint32_t v);
uint16_t ConvertWTextDecTypeToU16(const wchar_t* text);
const wchar_t* ConvertDecTypeToU16ToWText(const uint16_t v);
void ConvertWTextToIP(const wchar_t* text, uint8_t NewIP[4]);
const wchar_t* ConvertIPToWText(const uint8_t NewIP[4]);
const wchar_t* ConvertU8TextToWText_StupidButFast(const uint8_t* data, unsigned short sz);
const wchar_t* ConvertU8TextToWText_StupidButFast_graphNspace(const uint8_t* data, unsigned short sz);
const wchar_t* ConvertCharTextToWText_StupidButFast(const char* data, unsigned short sz);
const uint8_t* ConvertWTextToU8Text(const wchar_t* src, unsigned short sz);
const char* ConvertWTextToCharText(const wchar_t* src, unsigned short sz);
namespace ret_stdstring
{
const std::wstring& ConvertDecTypeU32ToWText(const uint32_t v);
const std::wstring& ConvertHexTypeU32ToWText(const uint32_t v);
const std::wstring& ConvertDecTypeU16ToWText(const uint16_t v);
const std::wstring& ConvertIPToWText(const uint8_t NewIP[4]);
};
};

60
ultimateteknotool.v2/TheWinMain.cpp Normal file
View File

@ -0,0 +1,60 @@
#include "pch.h"
#include "constexprcolorcodes.h"
#include "TheWinMain.h"
#include "WinMainProc.h"
#include "MainWindowSizes.cpp"
static HWND MainHwnd = NULL;
bool windowsMain::WinStart()
{
HBRUSH hbkgrbrush = CreateSolidBrush(constexprcolorcodes::Color_00FAFAFF);
HICON hIconLarge = NULL;
HICON hIconSmall = NULL;
UINT ExtactRetL = 0;
UINT ExtactRetS = 0;
ExtactRetL = ::ExtractIconExA("iw5mp.exe", 0, &hIconLarge, 0, 1);
ExtactRetS = ::ExtractIconExA("iw5mp.exe", 0, 0, &hIconSmall, 1);
WNDCLASSEXW WClass;
WClass.cbSize = sizeof(WNDCLASSEXW);
WClass.style = CS_VREDRAW | CS_HREDRAW | CS_OWNDC | CS_DBLCLKS;
WClass.lpfnWndProc = windowsMain::MainWinProc;
WClass.cbClsExtra = 0;
WClass.cbWndExtra = 0;
WClass.hInstance = ::GetModuleHandle(NULL);
if (ExtactRetL) WClass.hIcon = hIconLarge;
else WClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
WClass.hCursor = LoadCursor(NULL, IDC_ARROW);
WClass.hbrBackground = hbkgrbrush;
WClass.lpszMenuName = NULL;
WClass.lpszClassName = classname;
if (ExtactRetS) WClass.hIconSm = hIconSmall;
else WClass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
if (!::RegisterClassEx(&WClass))
{
return false;
}
int v1 = ::GetSystemMetrics(SM_CXFULLSCREEN);
int v2 = ::GetSystemMetrics(SM_CYFULLSCREEN);
RECT rect = { 0, 0 , MainWindowSizes::width , MainWindowSizes::height };
MainHwnd = ::CreateWindowExW(0, classname, L"iw5mp", WS_OVERLAPPEDWINDOW & ~WS_THICKFRAME & ~WS_MAXIMIZEBOX | WS_VISIBLE,
(v1 - MainWindowSizes::width) / 2, (v2 - MainWindowSizes::height) / 2,
MainWindowSizes::width, MainWindowSizes::height, NULL, 0, ::GetModuleHandle(NULL), 0);
if (!MainHwnd)
{
return false;
}
ShowWindow(MainHwnd, SW_SHOWDEFAULT);
UpdateWindow(MainHwnd);
MSG msg;
ZeroMemory(&msg, sizeof(msg));
while (GetMessage(&msg, NULL, 0, 0))
{
//WinMainLoop();
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return true;
}

9
ultimateteknotool.v2/TheWinMain.h Normal file
View File

@ -0,0 +1,9 @@
#pragma once
#include <windows.h>
#include <shellapi.h>
namespace windowsMain
{
constexpr wchar_t classname[] = L"iw5mpx";
bool WinStart();
};

Some files were not shown because too many files have changed in this diff Show More