commit cd5ffe60a58821efe31efb397109f987f25b5cf0 Author: 1 1 Date: Thu Dec 31 15:35:46 2020 +0300 release diff --git a/Release/TeknoMW3C.dll b/Release/TeknoMW3C.dll new file mode 100644 index 0000000..7aa7daa Binary files /dev/null and b/Release/TeknoMW3C.dll differ diff --git a/Release/ultimateteknotool.v2.dll b/Release/ultimateteknotool.v2.dll new file mode 100644 index 0000000..9ff94a5 Binary files /dev/null and b/Release/ultimateteknotool.v2.dll differ diff --git a/Release/ultimateteknotool.v2.iobj b/Release/ultimateteknotool.v2.iobj new file mode 100644 index 0000000..d8eebee Binary files /dev/null and b/Release/ultimateteknotool.v2.iobj differ diff --git a/Release/ultimateteknotool.v2.ipdb b/Release/ultimateteknotool.v2.ipdb new file mode 100644 index 0000000..e1d389b Binary files /dev/null and b/Release/ultimateteknotool.v2.ipdb differ diff --git a/Release/ultimateteknotool.v2.pdb b/Release/ultimateteknotool.v2.pdb new file mode 100644 index 0000000..da37432 Binary files /dev/null and b/Release/ultimateteknotool.v2.pdb differ diff --git a/libtom/libtomcrypt/include/tomcrypt.h b/libtom/libtomcrypt/include/tomcrypt.h new file mode 100644 index 0000000..00392c3 --- /dev/null +++ b/libtom/libtomcrypt/include/tomcrypt.h @@ -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 +#include +#include +#include +#include +#include +#include +#include + +/* use configuration data */ +#include + +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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 */ diff --git a/libtom/libtomcrypt/include/tomcrypt_argchk.h b/libtom/libtomcrypt/include/tomcrypt_argchk.h new file mode 100644 index 0000000..980b924 --- /dev/null +++ b/libtom/libtomcrypt/include/tomcrypt_argchk.h @@ -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 + +/* 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 */ diff --git a/libtom/libtomcrypt/include/tomcrypt_cfg.h b/libtom/libtomcrypt/include/tomcrypt_cfg.h new file mode 100644 index 0000000..888893f --- /dev/null +++ b/libtom/libtomcrypt/include/tomcrypt_cfg.h @@ -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 */ diff --git a/libtom/libtomcrypt/include/tomcrypt_cipher.h b/libtom/libtomcrypt/include/tomcrypt_cipher.h new file mode 100644 index 0000000..e3a0c4f --- /dev/null +++ b/libtom/libtomcrypt/include/tomcrypt_cipher.h @@ -0,0 +1,1008 @@ +/* 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. + */ + +/* ---- SYMMETRIC KEY STUFF ----- + * + * We put each of the ciphers scheduled keys in their own structs then we put all of + * the key formats in one union. This makes the function prototypes easier to use. + */ +#ifdef LTC_BLOWFISH +struct blowfish_key { + ulong32 S[4][256]; + ulong32 K[18]; +}; +#endif + +#ifdef LTC_RC5 +struct rc5_key { + int rounds; + ulong32 K[50]; +}; +#endif + +#ifdef LTC_RC6 +struct rc6_key { + ulong32 K[44]; +}; +#endif + +#ifdef LTC_SAFERP +struct saferp_key { + unsigned char K[33][16]; + long rounds; +}; +#endif + +#ifdef LTC_RIJNDAEL +struct rijndael_key { + ulong32 eK[60], dK[60]; + int Nr; +}; +#endif + +#ifdef LTC_KSEED +struct kseed_key { + ulong32 K[32], dK[32]; +}; +#endif + +#ifdef LTC_KASUMI +struct kasumi_key { + ulong32 KLi1[8], KLi2[8], + KOi1[8], KOi2[8], KOi3[8], + KIi1[8], KIi2[8], KIi3[8]; +}; +#endif + +#ifdef LTC_XTEA +struct xtea_key { + unsigned long A[32], B[32]; +}; +#endif + +#ifdef LTC_TWOFISH +#ifndef LTC_TWOFISH_SMALL + struct twofish_key { + ulong32 S[4][256], K[40]; + }; +#else + struct twofish_key { + ulong32 K[40]; + unsigned char S[32], start; + }; +#endif +#endif + +#ifdef LTC_SAFER +#define LTC_SAFER_K64_DEFAULT_NOF_ROUNDS 6 +#define LTC_SAFER_K128_DEFAULT_NOF_ROUNDS 10 +#define LTC_SAFER_SK64_DEFAULT_NOF_ROUNDS 8 +#define LTC_SAFER_SK128_DEFAULT_NOF_ROUNDS 10 +#define LTC_SAFER_MAX_NOF_ROUNDS 13 +#define LTC_SAFER_BLOCK_LEN 8 +#define LTC_SAFER_KEY_LEN (1 + LTC_SAFER_BLOCK_LEN * (1 + 2 * LTC_SAFER_MAX_NOF_ROUNDS)) +typedef unsigned char safer_block_t[LTC_SAFER_BLOCK_LEN]; +typedef unsigned char safer_key_t[LTC_SAFER_KEY_LEN]; +struct safer_key { safer_key_t key; }; +#endif + +#ifdef LTC_RC2 +struct rc2_key { unsigned xkey[64]; }; +#endif + +#ifdef LTC_DES +struct des_key { + ulong32 ek[32], dk[32]; +}; + +struct des3_key { + ulong32 ek[3][32], dk[3][32]; +}; +#endif + +#ifdef LTC_CAST5 +struct cast5_key { + ulong32 K[32], keylen; +}; +#endif + +#ifdef LTC_NOEKEON +struct noekeon_key { + ulong32 K[4], dK[4]; +}; +#endif + +#ifdef LTC_SKIPJACK +struct skipjack_key { + unsigned char key[10]; +}; +#endif + +#ifdef LTC_KHAZAD +struct khazad_key { + ulong64 roundKeyEnc[8 + 1]; + ulong64 roundKeyDec[8 + 1]; +}; +#endif + +#ifdef LTC_ANUBIS +struct anubis_key { + int keyBits; + int R; + ulong32 roundKeyEnc[18 + 1][4]; + ulong32 roundKeyDec[18 + 1][4]; +}; +#endif + +#ifdef LTC_MULTI2 +struct multi2_key { + int N; + ulong32 uk[8]; +}; +#endif + +#ifdef LTC_CAMELLIA +struct camellia_key { + int R; + ulong64 kw[4], k[24], kl[6]; +}; +#endif + +typedef union Symmetric_key { +#ifdef LTC_DES + struct des_key des; + struct des3_key des3; +#endif +#ifdef LTC_RC2 + struct rc2_key rc2; +#endif +#ifdef LTC_SAFER + struct safer_key safer; +#endif +#ifdef LTC_TWOFISH + struct twofish_key twofish; +#endif +#ifdef LTC_BLOWFISH + struct blowfish_key blowfish; +#endif +#ifdef LTC_RC5 + struct rc5_key rc5; +#endif +#ifdef LTC_RC6 + struct rc6_key rc6; +#endif +#ifdef LTC_SAFERP + struct saferp_key saferp; +#endif +#ifdef LTC_RIJNDAEL + struct rijndael_key rijndael; +#endif +#ifdef LTC_XTEA + struct xtea_key xtea; +#endif +#ifdef LTC_CAST5 + struct cast5_key cast5; +#endif +#ifdef LTC_NOEKEON + struct noekeon_key noekeon; +#endif +#ifdef LTC_SKIPJACK + struct skipjack_key skipjack; +#endif +#ifdef LTC_KHAZAD + struct khazad_key khazad; +#endif +#ifdef LTC_ANUBIS + struct anubis_key anubis; +#endif +#ifdef LTC_KSEED + struct kseed_key kseed; +#endif +#ifdef LTC_KASUMI + struct kasumi_key kasumi; +#endif +#ifdef LTC_MULTI2 + struct multi2_key multi2; +#endif +#ifdef LTC_CAMELLIA + struct camellia_key camellia; +#endif + void *data; +} symmetric_key; + +#ifdef LTC_ECB_MODE +/** A block cipher ECB structure */ +typedef struct { + /** The index of the cipher chosen */ + int cipher, + /** The block size of the given cipher */ + blocklen; + /** The scheduled key */ + symmetric_key key; +} symmetric_ECB; +#endif + +#ifdef LTC_CFB_MODE +/** A block cipher CFB structure */ +typedef struct { + /** The index of the cipher chosen */ + int cipher, + /** The block size of the given cipher */ + blocklen, + /** The padding offset */ + padlen; + /** The current IV */ + unsigned char IV[MAXBLOCKSIZE], + /** The pad used to encrypt/decrypt */ + pad[MAXBLOCKSIZE]; + /** The scheduled key */ + symmetric_key key; +} symmetric_CFB; +#endif + +#ifdef LTC_OFB_MODE +/** A block cipher OFB structure */ +typedef struct { + /** The index of the cipher chosen */ + int cipher, + /** The block size of the given cipher */ + blocklen, + /** The padding offset */ + padlen; + /** The current IV */ + unsigned char IV[MAXBLOCKSIZE]; + /** The scheduled key */ + symmetric_key key; +} symmetric_OFB; +#endif + +#ifdef LTC_CBC_MODE +/** A block cipher CBC structure */ +typedef struct { + /** The index of the cipher chosen */ + int cipher, + /** The block size of the given cipher */ + blocklen; + /** The current IV */ + unsigned char IV[MAXBLOCKSIZE]; + /** The scheduled key */ + symmetric_key key; +} symmetric_CBC; +#endif + + +#ifdef LTC_CTR_MODE +/** A block cipher CTR structure */ +typedef struct { + /** The index of the cipher chosen */ + int cipher, + /** The block size of the given cipher */ + blocklen, + /** The padding offset */ + padlen, + /** The mode (endianess) of the CTR, 0==little, 1==big */ + mode, + /** counter width */ + ctrlen; + + /** The counter */ + unsigned char ctr[MAXBLOCKSIZE], + /** The pad used to encrypt/decrypt */ + pad[MAXBLOCKSIZE]; + /** The scheduled key */ + symmetric_key key; +} symmetric_CTR; +#endif + + +#ifdef LTC_LRW_MODE +/** A LRW structure */ +typedef struct { + /** The index of the cipher chosen (must be a 128-bit block cipher) */ + int cipher; + + /** The current IV */ + unsigned char IV[16], + + /** the tweak key */ + tweak[16], + + /** The current pad, it's the product of the first 15 bytes against the tweak key */ + pad[16]; + + /** The scheduled symmetric key */ + symmetric_key key; + +#ifdef LTC_LRW_TABLES + /** The pre-computed multiplication table */ + unsigned char PC[16][256][16]; +#endif +} symmetric_LRW; +#endif + +#ifdef LTC_F8_MODE +/** A block cipher F8 structure */ +typedef struct { + /** The index of the cipher chosen */ + int cipher, + /** The block size of the given cipher */ + blocklen, + /** The padding offset */ + padlen; + /** The current IV */ + unsigned char IV[MAXBLOCKSIZE], + MIV[MAXBLOCKSIZE]; + /** Current block count */ + ulong32 blockcnt; + /** The scheduled key */ + symmetric_key key; +} symmetric_F8; +#endif + + +/** cipher descriptor table, last entry has "name == NULL" to mark the end of table */ +extern struct ltc_cipher_descriptor { + /** name of cipher */ + const char *name; + /** internal ID */ + unsigned char ID; + /** min keysize (octets) */ + int min_key_length, + /** max keysize (octets) */ + max_key_length, + /** block size (octets) */ + block_length, + /** default number of rounds */ + default_rounds; + /** Setup the cipher + @param key The input symmetric key + @param keylen The length of the input key (octets) + @param num_rounds The requested number of rounds (0==default) + @param skey [out] The destination of the scheduled key + @return CRYPT_OK if successful + */ + int (*setup)(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); + /** Encrypt a block + @param pt The plaintext + @param ct [out] The ciphertext + @param skey The scheduled key + @return CRYPT_OK if successful + */ + int (*ecb_encrypt)(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); + /** Decrypt a block + @param ct The ciphertext + @param pt [out] The plaintext + @param skey The scheduled key + @return CRYPT_OK if successful + */ + int (*ecb_decrypt)(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); + /** Test the block cipher + @return CRYPT_OK if successful, CRYPT_NOP if self-testing has been disabled + */ + int (*test)(void); + + /** Terminate the context + @param skey The scheduled key + */ + void (*done)(symmetric_key *skey); + + /** Determine a key size + @param keysize [in/out] The size of the key desired and the suggested size + @return CRYPT_OK if successful + */ + int (*keysize)(int *keysize); + +/** Accelerators **/ + /** Accelerated ECB encryption + @param pt Plaintext + @param ct Ciphertext + @param blocks The number of complete blocks to process + @param skey The scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_ecb_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, symmetric_key *skey); + + /** Accelerated ECB decryption + @param pt Plaintext + @param ct Ciphertext + @param blocks The number of complete blocks to process + @param skey The scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_ecb_decrypt)(const unsigned char *ct, unsigned char *pt, unsigned long blocks, symmetric_key *skey); + + /** Accelerated CBC encryption + @param pt Plaintext + @param ct Ciphertext + @param blocks The number of complete blocks to process + @param IV The initial value (input/output) + @param skey The scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_cbc_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, unsigned char *IV, symmetric_key *skey); + + /** Accelerated CBC decryption + @param pt Plaintext + @param ct Ciphertext + @param blocks The number of complete blocks to process + @param IV The initial value (input/output) + @param skey The scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_cbc_decrypt)(const unsigned char *ct, unsigned char *pt, unsigned long blocks, unsigned char *IV, symmetric_key *skey); + + /** Accelerated CTR encryption + @param pt Plaintext + @param ct Ciphertext + @param blocks The number of complete blocks to process + @param IV The initial value (input/output) + @param mode little or big endian counter (mode=0 or mode=1) + @param skey The scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_ctr_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, unsigned char *IV, int mode, symmetric_key *skey); + + /** Accelerated LRW + @param pt Plaintext + @param ct Ciphertext + @param blocks The number of complete blocks to process + @param IV The initial value (input/output) + @param tweak The LRW tweak + @param skey The scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_lrw_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, unsigned char *IV, const unsigned char *tweak, symmetric_key *skey); + + /** Accelerated LRW + @param ct Ciphertext + @param pt Plaintext + @param blocks The number of complete blocks to process + @param IV The initial value (input/output) + @param tweak The LRW tweak + @param skey The scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_lrw_decrypt)(const unsigned char *ct, unsigned char *pt, unsigned long blocks, unsigned char *IV, const unsigned char *tweak, symmetric_key *skey); + + /** Accelerated CCM packet (one-shot) + @param key The secret key to use + @param keylen The length of the secret key (octets) + @param uskey A previously scheduled key [optional can be NULL] + @param nonce The session nonce [use once] + @param noncelen The length of the nonce + @param header The header for the session + @param headerlen The length of the header (octets) + @param pt [out] The plaintext + @param ptlen The length of the plaintext (octets) + @param ct [out] The ciphertext + @param tag [out] The destination tag + @param taglen [in/out] The max size and resulting size of the authentication tag + @param direction Encrypt or Decrypt direction (0 or 1) + @return CRYPT_OK if successful + */ + int (*accel_ccm_memory)( + 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); + + /** Accelerated GCM packet (one shot) + @param key The secret key + @param keylen The length of the secret key + @param IV The initialization vector + @param IVlen The length of the initialization vector + @param adata The additional authentication data (header) + @param adatalen The length of the adata + @param pt The plaintext + @param ptlen The length of the plaintext (ciphertext length is the same) + @param ct The ciphertext + @param tag [out] The MAC tag + @param taglen [in/out] The MAC tag length + @param direction Encrypt or Decrypt mode (GCM_ENCRYPT or GCM_DECRYPT) + @return CRYPT_OK on success + */ + int (*accel_gcm_memory)( + 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); + + /** Accelerated one shot LTC_OMAC + @param key The secret key + @param keylen The key length (octets) + @param in The message + @param inlen Length of message (octets) + @param out [out] Destination for tag + @param outlen [in/out] Initial and final size of out + @return CRYPT_OK on success + */ + int (*omac_memory)( + const unsigned char *key, unsigned long keylen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); + + /** Accelerated one shot XCBC + @param key The secret key + @param keylen The key length (octets) + @param in The message + @param inlen Length of message (octets) + @param out [out] Destination for tag + @param outlen [in/out] Initial and final size of out + @return CRYPT_OK on success + */ + int (*xcbc_memory)( + const unsigned char *key, unsigned long keylen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); + + /** Accelerated one shot F9 + @param key The secret key + @param keylen The key length (octets) + @param in The message + @param inlen Length of message (octets) + @param out [out] Destination for tag + @param outlen [in/out] Initial and final size of out + @return CRYPT_OK on success + @remark Requires manual padding + */ + int (*f9_memory)( + const unsigned char *key, unsigned long keylen, + const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen); + + /** Accelerated XTS encryption + @param pt Plaintext + @param ct Ciphertext + @param blocks The number of complete blocks to process + @param tweak The 128-bit encryption tweak (input/output). + The tweak should not be encrypted on input, but + next tweak will be copied encrypted on output. + @param skey1 The first scheduled key context + @param skey2 The second scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_xts_encrypt)(const unsigned char *pt, unsigned char *ct, + unsigned long blocks, unsigned char *tweak, symmetric_key *skey1, + symmetric_key *skey2); + + /** Accelerated XTS decryption + @param ct Ciphertext + @param pt Plaintext + @param blocks The number of complete blocks to process + @param tweak The 128-bit encryption tweak (input/output). + The tweak should not be encrypted on input, but + next tweak will be copied encrypted on output. + @param skey1 The first scheduled key context + @param skey2 The second scheduled key context + @return CRYPT_OK if successful + */ + int (*accel_xts_decrypt)(const unsigned char *ct, unsigned char *pt, + unsigned long blocks, unsigned char *tweak, symmetric_key *skey1, + symmetric_key *skey2); +} cipher_descriptor[]; + +#ifdef LTC_BLOWFISH +int blowfish_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int blowfish_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int blowfish_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int blowfish_test(void); +void blowfish_done(symmetric_key *skey); +int blowfish_keysize(int *keysize); +extern const struct ltc_cipher_descriptor blowfish_desc; +#endif + +#ifdef LTC_RC5 +int rc5_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int rc5_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int rc5_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int rc5_test(void); +void rc5_done(symmetric_key *skey); +int rc5_keysize(int *keysize); +extern const struct ltc_cipher_descriptor rc5_desc; +#endif + +#ifdef LTC_RC6 +int rc6_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int rc6_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int rc6_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int rc6_test(void); +void rc6_done(symmetric_key *skey); +int rc6_keysize(int *keysize); +extern const struct ltc_cipher_descriptor rc6_desc; +#endif + +#ifdef LTC_RC2 +int rc2_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int rc2_setup_ex(const unsigned char *key, int keylen, int bits, int num_rounds, symmetric_key *skey); +int rc2_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int rc2_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int rc2_test(void); +void rc2_done(symmetric_key *skey); +int rc2_keysize(int *keysize); +extern const struct ltc_cipher_descriptor rc2_desc; +#endif + +#ifdef LTC_SAFERP +int saferp_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int saferp_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int saferp_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int saferp_test(void); +void saferp_done(symmetric_key *skey); +int saferp_keysize(int *keysize); +extern const struct ltc_cipher_descriptor saferp_desc; +#endif + +#ifdef LTC_SAFER +int safer_k64_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int safer_sk64_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int safer_k128_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int safer_sk128_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int safer_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *key); +int safer_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *key); +int safer_k64_test(void); +int safer_sk64_test(void); +int safer_sk128_test(void); +void safer_done(symmetric_key *skey); +int safer_64_keysize(int *keysize); +int safer_128_keysize(int *keysize); +extern const struct ltc_cipher_descriptor safer_k64_desc, safer_k128_desc, safer_sk64_desc, safer_sk128_desc; +#endif + +#ifdef LTC_RIJNDAEL + +/* make aes an alias */ +#define aes_setup rijndael_setup +#define aes_ecb_encrypt rijndael_ecb_encrypt +#define aes_ecb_decrypt rijndael_ecb_decrypt +#define aes_test rijndael_test +#define aes_done rijndael_done +#define aes_keysize rijndael_keysize + +#define aes_enc_setup rijndael_enc_setup +#define aes_enc_ecb_encrypt rijndael_enc_ecb_encrypt +#define aes_enc_keysize rijndael_enc_keysize + +int rijndael_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int rijndael_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int rijndael_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int rijndael_test(void); +void rijndael_done(symmetric_key *skey); +int rijndael_keysize(int *keysize); +int rijndael_enc_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int rijndael_enc_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +void rijndael_enc_done(symmetric_key *skey); +int rijndael_enc_keysize(int *keysize); +extern const struct ltc_cipher_descriptor rijndael_desc, aes_desc; +extern const struct ltc_cipher_descriptor rijndael_enc_desc, aes_enc_desc; +#endif + +#ifdef LTC_XTEA +int xtea_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int xtea_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int xtea_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int xtea_test(void); +void xtea_done(symmetric_key *skey); +int xtea_keysize(int *keysize); +extern const struct ltc_cipher_descriptor xtea_desc; +#endif + +#ifdef LTC_TWOFISH +int twofish_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int twofish_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int twofish_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int twofish_test(void); +void twofish_done(symmetric_key *skey); +int twofish_keysize(int *keysize); +extern const struct ltc_cipher_descriptor twofish_desc; +#endif + +#ifdef LTC_DES +int des_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int des_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int des_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int des_test(void); +void des_done(symmetric_key *skey); +int des_keysize(int *keysize); +int des3_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int des3_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int des3_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int des3_test(void); +void des3_done(symmetric_key *skey); +int des3_keysize(int *keysize); +extern const struct ltc_cipher_descriptor des_desc, des3_desc; +#endif + +#ifdef LTC_CAST5 +int cast5_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int cast5_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int cast5_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int cast5_test(void); +void cast5_done(symmetric_key *skey); +int cast5_keysize(int *keysize); +extern const struct ltc_cipher_descriptor cast5_desc; +#endif + +#ifdef LTC_NOEKEON +int noekeon_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int noekeon_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int noekeon_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int noekeon_test(void); +void noekeon_done(symmetric_key *skey); +int noekeon_keysize(int *keysize); +extern const struct ltc_cipher_descriptor noekeon_desc; +#endif + +#ifdef LTC_SKIPJACK +int skipjack_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int skipjack_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int skipjack_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int skipjack_test(void); +void skipjack_done(symmetric_key *skey); +int skipjack_keysize(int *keysize); +extern const struct ltc_cipher_descriptor skipjack_desc; +#endif + +#ifdef LTC_KHAZAD +int khazad_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int khazad_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int khazad_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int khazad_test(void); +void khazad_done(symmetric_key *skey); +int khazad_keysize(int *keysize); +extern const struct ltc_cipher_descriptor khazad_desc; +#endif + +#ifdef LTC_ANUBIS +int anubis_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int anubis_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int anubis_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int anubis_test(void); +void anubis_done(symmetric_key *skey); +int anubis_keysize(int *keysize); +extern const struct ltc_cipher_descriptor anubis_desc; +#endif + +#ifdef LTC_KSEED +int kseed_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int kseed_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int kseed_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int kseed_test(void); +void kseed_done(symmetric_key *skey); +int kseed_keysize(int *keysize); +extern const struct ltc_cipher_descriptor kseed_desc; +#endif + +#ifdef LTC_KASUMI +int kasumi_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int kasumi_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int kasumi_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int kasumi_test(void); +void kasumi_done(symmetric_key *skey); +int kasumi_keysize(int *keysize); +extern const struct ltc_cipher_descriptor kasumi_desc; +#endif + + +#ifdef LTC_MULTI2 +int multi2_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int multi2_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int multi2_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int multi2_test(void); +void multi2_done(symmetric_key *skey); +int multi2_keysize(int *keysize); +extern const struct ltc_cipher_descriptor multi2_desc; +#endif + +#ifdef LTC_CAMELLIA +int camellia_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); +int camellia_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); +int camellia_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); +int camellia_test(void); +void camellia_done(symmetric_key *skey); +int camellia_keysize(int *keysize); +extern const struct ltc_cipher_descriptor camellia_desc; +#endif + +#ifdef LTC_ECB_MODE +int ecb_start(int cipher, const unsigned char *key, + int keylen, int num_rounds, symmetric_ECB *ecb); +int ecb_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_ECB *ecb); +int ecb_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_ECB *ecb); +int ecb_done(symmetric_ECB *ecb); +#endif + +#ifdef LTC_CFB_MODE +int cfb_start(int cipher, const unsigned char *IV, const unsigned char *key, + int keylen, int num_rounds, symmetric_CFB *cfb); +int cfb_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_CFB *cfb); +int cfb_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_CFB *cfb); +int cfb_getiv(unsigned char *IV, unsigned long *len, symmetric_CFB *cfb); +int cfb_setiv(const unsigned char *IV, unsigned long len, symmetric_CFB *cfb); +int cfb_done(symmetric_CFB *cfb); +#endif + +#ifdef LTC_OFB_MODE +int ofb_start(int cipher, const unsigned char *IV, const unsigned char *key, + int keylen, int num_rounds, symmetric_OFB *ofb); +int ofb_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_OFB *ofb); +int ofb_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_OFB *ofb); +int ofb_getiv(unsigned char *IV, unsigned long *len, symmetric_OFB *ofb); +int ofb_setiv(const unsigned char *IV, unsigned long len, symmetric_OFB *ofb); +int ofb_done(symmetric_OFB *ofb); +#endif + +#ifdef LTC_CBC_MODE +int cbc_start(int cipher, const unsigned char *IV, const unsigned char *key, + int keylen, int num_rounds, symmetric_CBC *cbc); +int cbc_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_CBC *cbc); +int cbc_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_CBC *cbc); +int cbc_getiv(unsigned char *IV, unsigned long *len, symmetric_CBC *cbc); +int cbc_setiv(const unsigned char *IV, unsigned long len, symmetric_CBC *cbc); +int cbc_done(symmetric_CBC *cbc); +#endif + +#ifdef LTC_CTR_MODE + +#define CTR_COUNTER_LITTLE_ENDIAN 0x0000 +#define CTR_COUNTER_BIG_ENDIAN 0x1000 +#define LTC_CTR_RFC3686 0x2000 + +int ctr_start( int cipher, + const unsigned char *IV, + const unsigned char *key, int keylen, + int num_rounds, int ctr_mode, + symmetric_CTR *ctr); +int ctr_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_CTR *ctr); +int ctr_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_CTR *ctr); +int ctr_getiv(unsigned char *IV, unsigned long *len, symmetric_CTR *ctr); +int ctr_setiv(const unsigned char *IV, unsigned long len, symmetric_CTR *ctr); +int ctr_done(symmetric_CTR *ctr); +int ctr_test(void); +#endif + +#ifdef LTC_LRW_MODE + +#define LRW_ENCRYPT LTC_ENCRYPT +#define LRW_DECRYPT LTC_DECRYPT + +int lrw_start( int cipher, + const unsigned char *IV, + const unsigned char *key, int keylen, + const unsigned char *tweak, + int num_rounds, + symmetric_LRW *lrw); +int lrw_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_LRW *lrw); +int lrw_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_LRW *lrw); +int lrw_getiv(unsigned char *IV, unsigned long *len, symmetric_LRW *lrw); +int lrw_setiv(const unsigned char *IV, unsigned long len, symmetric_LRW *lrw); +int lrw_done(symmetric_LRW *lrw); +int lrw_test(void); + +/* don't call */ +int lrw_process(const unsigned char *pt, unsigned char *ct, unsigned long len, int mode, symmetric_LRW *lrw); +#endif + +#ifdef LTC_F8_MODE +int f8_start( int cipher, const unsigned char *IV, + const unsigned char *key, int keylen, + const unsigned char *salt_key, int skeylen, + int num_rounds, symmetric_F8 *f8); +int f8_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_F8 *f8); +int f8_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_F8 *f8); +int f8_getiv(unsigned char *IV, unsigned long *len, symmetric_F8 *f8); +int f8_setiv(const unsigned char *IV, unsigned long len, symmetric_F8 *f8); +int f8_done(symmetric_F8 *f8); +int f8_test_mode(void); +#endif + +#ifdef LTC_XTS_MODE +typedef struct { + symmetric_key key1, key2; + int cipher; +} symmetric_xts; + +int xts_start( int cipher, + const unsigned char *key1, + const unsigned char *key2, + unsigned long keylen, + int num_rounds, + symmetric_xts *xts); + +int xts_encrypt( + const unsigned char *pt, unsigned long ptlen, + unsigned char *ct, + unsigned char *tweak, + symmetric_xts *xts); +int xts_decrypt( + const unsigned char *ct, unsigned long ptlen, + unsigned char *pt, + unsigned char *tweak, + symmetric_xts *xts); + +void xts_done(symmetric_xts *xts); +int xts_test(void); +void xts_mult_x(unsigned char *I); +#endif + +int find_cipher(const char *name); +int find_cipher_any(const char *name, int blocklen, int keylen); +int find_cipher_id(unsigned char ID); +int register_cipher(const struct ltc_cipher_descriptor *cipher); +int unregister_cipher(const struct ltc_cipher_descriptor *cipher); +int register_all_ciphers(void); +int cipher_is_valid(int idx); + +LTC_MUTEX_PROTO(ltc_cipher_mutex) + +/* ---- stream ciphers ---- */ + +#ifdef LTC_CHACHA + +typedef struct { + ulong32 input[16]; + unsigned char kstream[64]; + unsigned long ksleft; + unsigned long ivlen; + int rounds; +} chacha_state; + +int chacha_setup(chacha_state *st, const unsigned char *key, unsigned long keylen, int rounds); +int chacha_ivctr32(chacha_state *st, const unsigned char *iv, unsigned long ivlen, ulong32 counter); +int chacha_ivctr64(chacha_state *st, const unsigned char *iv, unsigned long ivlen, ulong64 counter); +int chacha_crypt(chacha_state *st, const unsigned char *in, unsigned long inlen, unsigned char *out); +int chacha_keystream(chacha_state *st, unsigned char *out, unsigned long outlen); +int chacha_done(chacha_state *st); +int chacha_test(void); + +#endif /* LTC_CHACHA */ + +#ifdef LTC_RC4_STREAM + +typedef struct { + unsigned int x, y; + unsigned char buf[256]; +} rc4_state; + +int rc4_stream_setup(rc4_state *st, const unsigned char *key, unsigned long keylen); +int rc4_stream_crypt(rc4_state *st, const unsigned char *in, unsigned long inlen, unsigned char *out); +int rc4_stream_keystream(rc4_state *st, unsigned char *out, unsigned long outlen); +int rc4_stream_done(rc4_state *st); +int rc4_stream_test(void); + +#endif /* LTC_RC4_STREAM */ + +#ifdef LTC_SOBER128_STREAM + +typedef struct { + ulong32 R[17], /* Working storage for the shift register */ + initR[17], /* saved register contents */ + konst, /* key dependent constant */ + sbuf; /* partial word encryption buffer */ + int nbuf; /* number of part-word stream bits buffered */ +} sober128_state; + +int sober128_stream_setup(sober128_state *st, const unsigned char *key, unsigned long keylen); +int sober128_stream_setiv(sober128_state *st, const unsigned char *iv, unsigned long ivlen); +int sober128_stream_crypt(sober128_state *st, const unsigned char *in, unsigned long inlen, unsigned char *out); +int sober128_stream_keystream(sober128_state *st, unsigned char *out, unsigned long outlen); +int sober128_stream_done(sober128_state *st); +int sober128_stream_test(void); + +#endif /* LTC_SOBER128_STREAM */ + +/* ref: HEAD -> master, tag: v1.18.0 */ +/* git commit: 0676c9aec7299f5c398d96cbbb64f7e38f67d73f */ +/* commit time: 2017-10-10 15:51:36 +0200 */ diff --git a/libtom/libtomcrypt/include/tomcrypt_custom.h b/libtom/libtomcrypt/include/tomcrypt_custom.h new file mode 100644 index 0000000..81f98af --- /dev/null +++ b/libtom/libtomcrypt/include/tomcrypt_custom.h @@ -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 + +#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 */ diff --git a/libtom/libtomcrypt/include/tomcrypt_hash.h b/libtom/libtomcrypt/include/tomcrypt_hash.h new file mode 100644 index 0000000..4a0df05 --- /dev/null +++ b/libtom/libtomcrypt/include/tomcrypt_hash.h @@ -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 */ diff --git a/libtom/libtomcrypt/include/tomcrypt_mac.h b/libtom/libtomcrypt/include/tomcrypt_mac.h new file mode 100644 index 0000000..53f479f --- /dev/null +++ b/libtom/libtomcrypt/include/tomcrypt_mac.h @@ -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 */ diff --git a/libtom/libtomcrypt/include/tomcrypt_macros.h b/libtom/libtomcrypt/include/tomcrypt_macros.h new file mode 100644 index 0000000..b31a887 --- /dev/null +++ b/libtom/libtomcrypt/include/tomcrypt_macros.h @@ -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 +#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 */ diff --git a/libtom/libtomcrypt/include/tomcrypt_math.h b/libtom/libtomcrypt/include/tomcrypt_math.h new file mode 100644 index 0000000..45b695f --- /dev/null +++ b/libtom/libtomcrypt/include/tomcrypt_math.h @@ -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 */ diff --git a/libtom/libtomcrypt/include/tomcrypt_misc.h b/libtom/libtomcrypt/include/tomcrypt_misc.h new file mode 100644 index 0000000..1650d52 --- /dev/null +++ b/libtom/libtomcrypt/include/tomcrypt_misc.h @@ -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 */ diff --git a/libtom/libtomcrypt/include/tomcrypt_pk.h b/libtom/libtomcrypt/include/tomcrypt_pk.h new file mode 100644 index 0000000..59831ad --- /dev/null +++ b/libtom/libtomcrypt/include/tomcrypt_pk.h @@ -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 */ +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 +#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 */ diff --git a/libtom/libtomcrypt/include/tomcrypt_pkcs.h b/libtom/libtomcrypt/include/tomcrypt_pkcs.h new file mode 100644 index 0000000..48a0a06 --- /dev/null +++ b/libtom/libtomcrypt/include/tomcrypt_pkcs.h @@ -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 */ diff --git a/libtom/libtomcrypt/include/tomcrypt_private.h b/libtom/libtomcrypt/include/tomcrypt_private.h new file mode 100644 index 0000000..3ed2b8e --- /dev/null +++ b/libtom/libtomcrypt/include/tomcrypt_private.h @@ -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 */ diff --git a/libtom/libtomcrypt/include/tomcrypt_prng.h b/libtom/libtomcrypt/include/tomcrypt_prng.h new file mode 100644 index 0000000..c67c4c3 --- /dev/null +++ b/libtom/libtomcrypt/include/tomcrypt_prng.h @@ -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 */ diff --git a/libtom/libtomcrypt/lib/tomcrypt.lib b/libtom/libtomcrypt/lib/tomcrypt.lib new file mode 100644 index 0000000..0b64b47 Binary files /dev/null and b/libtom/libtomcrypt/lib/tomcrypt.lib differ diff --git a/libtom/libtommath/include/tommath.h b/libtom/libtommath/include/tommath.h new file mode 100644 index 0000000..e87bb08 --- /dev/null +++ b/libtom/libtommath/include/tommath.h @@ -0,0 +1,781 @@ +/* LibTomMath, multiple-precision integer library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +#ifndef BN_H_ +#define BN_H_ + +#include +#include +#include + +#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 +#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 diff --git a/libtom/libtommath/include/tommath_class.h b/libtom/libtommath/include/tommath_class.h new file mode 100644 index 0000000..52ba585 --- /dev/null +++ b/libtom/libtommath/include/tommath_class.h @@ -0,0 +1,1319 @@ +/* LibTomMath, multiple-precision integer library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +#if !(defined(LTM1) && defined(LTM2) && defined(LTM3)) +#define LTM_INSIDE +#if defined(LTM2) +# define LTM3 +#endif +#if defined(LTM1) +# define LTM2 +#endif +#define LTM1 +#if defined(LTM_ALL) +# define BN_CUTOFFS_C +# define BN_DEPRECATED_C +# define BN_MP_2EXPT_C +# define BN_MP_ABS_C +# define BN_MP_ADD_C +# define BN_MP_ADD_D_C +# define BN_MP_ADDMOD_C +# define BN_MP_AND_C +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_CMP_MAG_C +# define BN_MP_CNT_LSB_C +# define BN_MP_COMPLEMENT_C +# define BN_MP_COPY_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DECR_C +# define BN_MP_DIV_C +# define BN_MP_DIV_2_C +# define BN_MP_DIV_2D_C +# define BN_MP_DIV_3_C +# define BN_MP_DIV_D_C +# define BN_MP_DR_IS_MODULUS_C +# define BN_MP_DR_REDUCE_C +# define BN_MP_DR_SETUP_C +# define BN_MP_ERROR_TO_STRING_C +# define BN_MP_EXCH_C +# define BN_MP_EXPT_U32_C +# define BN_MP_EXPTMOD_C +# define BN_MP_EXTEUCLID_C +# define BN_MP_FREAD_C +# define BN_MP_FROM_SBIN_C +# define BN_MP_FROM_UBIN_C +# define BN_MP_FWRITE_C +# define BN_MP_GCD_C +# define BN_MP_GET_DOUBLE_C +# define BN_MP_GET_I32_C +# define BN_MP_GET_I64_C +# define BN_MP_GET_L_C +# define BN_MP_GET_LL_C +# define BN_MP_GET_MAG_U32_C +# define BN_MP_GET_MAG_U64_C +# define BN_MP_GET_MAG_UL_C +# define BN_MP_GET_MAG_ULL_C +# define BN_MP_GROW_C +# define BN_MP_INCR_C +# define BN_MP_INIT_C +# define BN_MP_INIT_COPY_C +# define BN_MP_INIT_I32_C +# define BN_MP_INIT_I64_C +# define BN_MP_INIT_L_C +# define BN_MP_INIT_LL_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_INIT_SET_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_INIT_U32_C +# define BN_MP_INIT_U64_C +# define BN_MP_INIT_UL_C +# define BN_MP_INIT_ULL_C +# define BN_MP_INVMOD_C +# define BN_MP_IS_SQUARE_C +# define BN_MP_ISEVEN_C +# define BN_MP_ISODD_C +# define BN_MP_KRONECKER_C +# define BN_MP_LCM_C +# define BN_MP_LOG_U32_C +# define BN_MP_LSHD_C +# define BN_MP_MOD_C +# define BN_MP_MOD_2D_C +# define BN_MP_MOD_D_C +# define BN_MP_MONTGOMERY_CALC_NORMALIZATION_C +# define BN_MP_MONTGOMERY_REDUCE_C +# define BN_MP_MONTGOMERY_SETUP_C +# define BN_MP_MUL_C +# define BN_MP_MUL_2_C +# define BN_MP_MUL_2D_C +# define BN_MP_MUL_D_C +# define BN_MP_MULMOD_C +# define BN_MP_NEG_C +# define BN_MP_OR_C +# define BN_MP_PACK_C +# define BN_MP_PACK_COUNT_C +# define BN_MP_PRIME_FERMAT_C +# define BN_MP_PRIME_FROBENIUS_UNDERWOOD_C +# define BN_MP_PRIME_IS_PRIME_C +# define BN_MP_PRIME_MILLER_RABIN_C +# define BN_MP_PRIME_NEXT_PRIME_C +# define BN_MP_PRIME_RABIN_MILLER_TRIALS_C +# define BN_MP_PRIME_RAND_C +# define BN_MP_PRIME_STRONG_LUCAS_SELFRIDGE_C +# define BN_MP_RADIX_SIZE_C +# define BN_MP_RADIX_SMAP_C +# define BN_MP_RAND_C +# define BN_MP_READ_RADIX_C +# define BN_MP_REDUCE_C +# define BN_MP_REDUCE_2K_C +# define BN_MP_REDUCE_2K_L_C +# define BN_MP_REDUCE_2K_SETUP_C +# define BN_MP_REDUCE_2K_SETUP_L_C +# define BN_MP_REDUCE_IS_2K_C +# define BN_MP_REDUCE_IS_2K_L_C +# define BN_MP_REDUCE_SETUP_C +# define BN_MP_ROOT_U32_C +# define BN_MP_RSHD_C +# define BN_MP_SBIN_SIZE_C +# define BN_MP_SET_C +# define BN_MP_SET_DOUBLE_C +# define BN_MP_SET_I32_C +# define BN_MP_SET_I64_C +# define BN_MP_SET_L_C +# define BN_MP_SET_LL_C +# define BN_MP_SET_U32_C +# define BN_MP_SET_U64_C +# define BN_MP_SET_UL_C +# define BN_MP_SET_ULL_C +# define BN_MP_SHRINK_C +# define BN_MP_SIGNED_RSH_C +# define BN_MP_SQR_C +# define BN_MP_SQRMOD_C +# define BN_MP_SQRT_C +# define BN_MP_SQRTMOD_PRIME_C +# define BN_MP_SUB_C +# define BN_MP_SUB_D_C +# define BN_MP_SUBMOD_C +# define BN_MP_TO_RADIX_C +# define BN_MP_TO_SBIN_C +# define BN_MP_TO_UBIN_C +# define BN_MP_UBIN_SIZE_C +# define BN_MP_UNPACK_C +# define BN_MP_XOR_C +# define BN_MP_ZERO_C +# define BN_PRIME_TAB_C +# define BN_S_MP_ADD_C +# define BN_S_MP_BALANCE_MUL_C +# define BN_S_MP_EXPTMOD_C +# define BN_S_MP_EXPTMOD_FAST_C +# define BN_S_MP_GET_BIT_C +# define BN_S_MP_INVMOD_FAST_C +# define BN_S_MP_INVMOD_SLOW_C +# define BN_S_MP_KARATSUBA_MUL_C +# define BN_S_MP_KARATSUBA_SQR_C +# define BN_S_MP_MONTGOMERY_REDUCE_FAST_C +# define BN_S_MP_MUL_DIGS_C +# define BN_S_MP_MUL_DIGS_FAST_C +# define BN_S_MP_MUL_HIGH_DIGS_C +# define BN_S_MP_MUL_HIGH_DIGS_FAST_C +# define BN_S_MP_PRIME_IS_DIVISIBLE_C +# define BN_S_MP_RAND_JENKINS_C +# define BN_S_MP_RAND_PLATFORM_C +# define BN_S_MP_REVERSE_C +# define BN_S_MP_SQR_C +# define BN_S_MP_SQR_FAST_C +# define BN_S_MP_SUB_C +# define BN_S_MP_TOOM_MUL_C +# define BN_S_MP_TOOM_SQR_C +#endif +#endif +#if defined(BN_CUTOFFS_C) +#endif + +#if defined(BN_DEPRECATED_C) +# define BN_FAST_MP_INVMOD_C +# define BN_FAST_MP_MONTGOMERY_REDUCE_C +# define BN_FAST_S_MP_MUL_DIGS_C +# define BN_FAST_S_MP_MUL_HIGH_DIGS_C +# define BN_FAST_S_MP_SQR_C +# define BN_MP_AND_C +# define BN_MP_BALANCE_MUL_C +# define BN_MP_CMP_D_C +# define BN_MP_EXPORT_C +# define BN_MP_EXPTMOD_FAST_C +# define BN_MP_EXPT_D_C +# define BN_MP_EXPT_D_EX_C +# define BN_MP_EXPT_U32_C +# define BN_MP_FROM_SBIN_C +# define BN_MP_FROM_UBIN_C +# define BN_MP_GET_BIT_C +# define BN_MP_GET_INT_C +# define BN_MP_GET_LONG_C +# define BN_MP_GET_LONG_LONG_C +# define BN_MP_GET_MAG_U32_C +# define BN_MP_GET_MAG_ULL_C +# define BN_MP_GET_MAG_UL_C +# define BN_MP_IMPORT_C +# define BN_MP_INIT_SET_INT_C +# define BN_MP_INIT_U32_C +# define BN_MP_INVMOD_SLOW_C +# define BN_MP_JACOBI_C +# define BN_MP_KARATSUBA_MUL_C +# define BN_MP_KARATSUBA_SQR_C +# define BN_MP_KRONECKER_C +# define BN_MP_N_ROOT_C +# define BN_MP_N_ROOT_EX_C +# define BN_MP_OR_C +# define BN_MP_PACK_C +# define BN_MP_PRIME_IS_DIVISIBLE_C +# define BN_MP_PRIME_RANDOM_EX_C +# define BN_MP_RAND_DIGIT_C +# define BN_MP_READ_SIGNED_BIN_C +# define BN_MP_READ_UNSIGNED_BIN_C +# define BN_MP_ROOT_U32_C +# define BN_MP_SBIN_SIZE_C +# define BN_MP_SET_INT_C +# define BN_MP_SET_LONG_C +# define BN_MP_SET_LONG_LONG_C +# define BN_MP_SET_U32_C +# define BN_MP_SET_U64_C +# define BN_MP_SIGNED_BIN_SIZE_C +# define BN_MP_SIGNED_RSH_C +# define BN_MP_TC_AND_C +# define BN_MP_TC_DIV_2D_C +# define BN_MP_TC_OR_C +# define BN_MP_TC_XOR_C +# define BN_MP_TOOM_MUL_C +# define BN_MP_TOOM_SQR_C +# define BN_MP_TORADIX_C +# define BN_MP_TORADIX_N_C +# define BN_MP_TO_RADIX_C +# define BN_MP_TO_SBIN_C +# define BN_MP_TO_SIGNED_BIN_C +# define BN_MP_TO_SIGNED_BIN_N_C +# define BN_MP_TO_UBIN_C +# define BN_MP_TO_UNSIGNED_BIN_C +# define BN_MP_TO_UNSIGNED_BIN_N_C +# define BN_MP_UBIN_SIZE_C +# define BN_MP_UNPACK_C +# define BN_MP_UNSIGNED_BIN_SIZE_C +# define BN_MP_XOR_C +# define BN_S_MP_BALANCE_MUL_C +# define BN_S_MP_EXPTMOD_FAST_C +# define BN_S_MP_GET_BIT_C +# define BN_S_MP_INVMOD_FAST_C +# define BN_S_MP_INVMOD_SLOW_C +# define BN_S_MP_KARATSUBA_MUL_C +# define BN_S_MP_KARATSUBA_SQR_C +# define BN_S_MP_MONTGOMERY_REDUCE_FAST_C +# define BN_S_MP_MUL_DIGS_FAST_C +# define BN_S_MP_MUL_HIGH_DIGS_FAST_C +# define BN_S_MP_PRIME_IS_DIVISIBLE_C +# define BN_S_MP_PRIME_RANDOM_EX_C +# define BN_S_MP_RAND_SOURCE_C +# define BN_S_MP_REVERSE_C +# define BN_S_MP_SQR_FAST_C +# define BN_S_MP_TOOM_MUL_C +# define BN_S_MP_TOOM_SQR_C +#endif + +#if defined(BN_MP_2EXPT_C) +# define BN_MP_GROW_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_ABS_C) +# define BN_MP_COPY_C +#endif + +#if defined(BN_MP_ADD_C) +# define BN_MP_CMP_MAG_C +# define BN_S_MP_ADD_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_ADD_D_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +# define BN_MP_SUB_D_C +#endif + +#if defined(BN_MP_ADDMOD_C) +# define BN_MP_ADD_C +# define BN_MP_CLEAR_C +# define BN_MP_INIT_C +# define BN_MP_MOD_C +#endif + +#if defined(BN_MP_AND_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_CLAMP_C) +#endif + +#if defined(BN_MP_CLEAR_C) +#endif + +#if defined(BN_MP_CLEAR_MULTI_C) +# define BN_MP_CLEAR_C +#endif + +#if defined(BN_MP_CMP_C) +# define BN_MP_CMP_MAG_C +#endif + +#if defined(BN_MP_CMP_D_C) +#endif + +#if defined(BN_MP_CMP_MAG_C) +#endif + +#if defined(BN_MP_CNT_LSB_C) +#endif + +#if defined(BN_MP_COMPLEMENT_C) +# define BN_MP_NEG_C +# define BN_MP_SUB_D_C +#endif + +#if defined(BN_MP_COPY_C) +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_COUNT_BITS_C) +#endif + +#if defined(BN_MP_DECR_C) +# define BN_MP_INCR_C +# define BN_MP_SET_C +# define BN_MP_SUB_D_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_DIV_C) +# define BN_MP_ADD_C +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_CMP_C +# define BN_MP_CMP_MAG_C +# define BN_MP_COPY_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DIV_2D_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_C +# define BN_MP_INIT_COPY_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_LSHD_C +# define BN_MP_MUL_2D_C +# define BN_MP_MUL_D_C +# define BN_MP_RSHD_C +# define BN_MP_SUB_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_DIV_2_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_DIV_2D_C) +# define BN_MP_CLAMP_C +# define BN_MP_COPY_C +# define BN_MP_MOD_2D_C +# define BN_MP_RSHD_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_DIV_3_C) +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_SIZE_C +#endif + +#if defined(BN_MP_DIV_D_C) +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_COPY_C +# define BN_MP_DIV_2D_C +# define BN_MP_DIV_3_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_SIZE_C +#endif + +#if defined(BN_MP_DR_IS_MODULUS_C) +#endif + +#if defined(BN_MP_DR_REDUCE_C) +# define BN_MP_CLAMP_C +# define BN_MP_CMP_MAG_C +# define BN_MP_GROW_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_DR_SETUP_C) +#endif + +#if defined(BN_MP_ERROR_TO_STRING_C) +#endif + +#if defined(BN_MP_EXCH_C) +#endif + +#if defined(BN_MP_EXPT_U32_C) +# define BN_MP_CLEAR_C +# define BN_MP_INIT_COPY_C +# define BN_MP_MUL_C +# define BN_MP_SET_C +# define BN_MP_SQR_C +#endif + +#if defined(BN_MP_EXPTMOD_C) +# define BN_MP_ABS_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_DR_IS_MODULUS_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_INVMOD_C +# define BN_MP_REDUCE_IS_2K_C +# define BN_MP_REDUCE_IS_2K_L_C +# define BN_S_MP_EXPTMOD_C +# define BN_S_MP_EXPTMOD_FAST_C +#endif + +#if defined(BN_MP_EXTEUCLID_C) +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_COPY_C +# define BN_MP_DIV_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_MUL_C +# define BN_MP_NEG_C +# define BN_MP_SET_C +# define BN_MP_SUB_C +#endif + +#if defined(BN_MP_FREAD_C) +# define BN_MP_ADD_D_C +# define BN_MP_MUL_D_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_FROM_SBIN_C) +# define BN_MP_FROM_UBIN_C +#endif + +#if defined(BN_MP_FROM_UBIN_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +# define BN_MP_MUL_2D_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_FWRITE_C) +# define BN_MP_RADIX_SIZE_C +# define BN_MP_TO_RADIX_C +#endif + +#if defined(BN_MP_GCD_C) +# define BN_MP_ABS_C +# define BN_MP_CLEAR_C +# define BN_MP_CMP_MAG_C +# define BN_MP_CNT_LSB_C +# define BN_MP_DIV_2D_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_COPY_C +# define BN_MP_MUL_2D_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_GET_DOUBLE_C) +#endif + +#if defined(BN_MP_GET_I32_C) +# define BN_MP_GET_MAG_U32_C +#endif + +#if defined(BN_MP_GET_I64_C) +# define BN_MP_GET_MAG_U64_C +#endif + +#if defined(BN_MP_GET_L_C) +# define BN_MP_GET_MAG_UL_C +#endif + +#if defined(BN_MP_GET_LL_C) +# define BN_MP_GET_MAG_ULL_C +#endif + +#if defined(BN_MP_GET_MAG_U32_C) +#endif + +#if defined(BN_MP_GET_MAG_U64_C) +#endif + +#if defined(BN_MP_GET_MAG_UL_C) +#endif + +#if defined(BN_MP_GET_MAG_ULL_C) +#endif + +#if defined(BN_MP_GROW_C) +#endif + +#if defined(BN_MP_INCR_C) +# define BN_MP_ADD_D_C +# define BN_MP_DECR_C +# define BN_MP_SET_C +#endif + +#if defined(BN_MP_INIT_C) +#endif + +#if defined(BN_MP_INIT_COPY_C) +# define BN_MP_CLEAR_C +# define BN_MP_COPY_C +# define BN_MP_INIT_SIZE_C +#endif + +#if defined(BN_MP_INIT_I32_C) +# define BN_MP_INIT_C +# define BN_MP_SET_I32_C +#endif + +#if defined(BN_MP_INIT_I64_C) +# define BN_MP_INIT_C +# define BN_MP_SET_I64_C +#endif + +#if defined(BN_MP_INIT_L_C) +# define BN_MP_INIT_C +# define BN_MP_SET_L_C +#endif + +#if defined(BN_MP_INIT_LL_C) +# define BN_MP_INIT_C +# define BN_MP_SET_LL_C +#endif + +#if defined(BN_MP_INIT_MULTI_C) +# define BN_MP_CLEAR_C +# define BN_MP_INIT_C +#endif + +#if defined(BN_MP_INIT_SET_C) +# define BN_MP_INIT_C +# define BN_MP_SET_C +#endif + +#if defined(BN_MP_INIT_SIZE_C) +#endif + +#if defined(BN_MP_INIT_U32_C) +# define BN_MP_INIT_C +# define BN_MP_SET_U32_C +#endif + +#if defined(BN_MP_INIT_U64_C) +# define BN_MP_INIT_C +# define BN_MP_SET_U64_C +#endif + +#if defined(BN_MP_INIT_UL_C) +# define BN_MP_INIT_C +# define BN_MP_SET_UL_C +#endif + +#if defined(BN_MP_INIT_ULL_C) +# define BN_MP_INIT_C +# define BN_MP_SET_ULL_C +#endif + +#if defined(BN_MP_INVMOD_C) +# define BN_MP_CMP_D_C +# define BN_S_MP_INVMOD_FAST_C +# define BN_S_MP_INVMOD_SLOW_C +#endif + +#if defined(BN_MP_IS_SQUARE_C) +# define BN_MP_CLEAR_C +# define BN_MP_CMP_MAG_C +# define BN_MP_GET_I32_C +# define BN_MP_INIT_U32_C +# define BN_MP_MOD_C +# define BN_MP_MOD_D_C +# define BN_MP_SQRT_C +# define BN_MP_SQR_C +#endif + +#if defined(BN_MP_ISEVEN_C) +#endif + +#if defined(BN_MP_ISODD_C) +#endif + +#if defined(BN_MP_KRONECKER_C) +# define BN_MP_CLEAR_C +# define BN_MP_CMP_D_C +# define BN_MP_CNT_LSB_C +# define BN_MP_COPY_C +# define BN_MP_DIV_2D_C +# define BN_MP_INIT_C +# define BN_MP_INIT_COPY_C +# define BN_MP_MOD_C +#endif + +#if defined(BN_MP_LCM_C) +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_MAG_C +# define BN_MP_DIV_C +# define BN_MP_GCD_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_MUL_C +#endif + +#if defined(BN_MP_LOG_U32_C) +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_COPY_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_EXCH_C +# define BN_MP_EXPT_U32_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_MUL_C +# define BN_MP_SET_C +# define BN_MP_SQR_C +#endif + +#if defined(BN_MP_LSHD_C) +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_MOD_C) +# define BN_MP_ADD_C +# define BN_MP_CLEAR_C +# define BN_MP_DIV_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_SIZE_C +#endif + +#if defined(BN_MP_MOD_2D_C) +# define BN_MP_CLAMP_C +# define BN_MP_COPY_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_MOD_D_C) +# define BN_MP_DIV_D_C +#endif + +#if defined(BN_MP_MONTGOMERY_CALC_NORMALIZATION_C) +# define BN_MP_2EXPT_C +# define BN_MP_CMP_MAG_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_MUL_2_C +# define BN_MP_SET_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_MONTGOMERY_REDUCE_C) +# define BN_MP_CLAMP_C +# define BN_MP_CMP_MAG_C +# define BN_MP_GROW_C +# define BN_MP_RSHD_C +# define BN_S_MP_MONTGOMERY_REDUCE_FAST_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_MONTGOMERY_SETUP_C) +#endif + +#if defined(BN_MP_MUL_C) +# define BN_S_MP_BALANCE_MUL_C +# define BN_S_MP_KARATSUBA_MUL_C +# define BN_S_MP_MUL_DIGS_C +# define BN_S_MP_MUL_DIGS_FAST_C +# define BN_S_MP_TOOM_MUL_C +#endif + +#if defined(BN_MP_MUL_2_C) +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_MUL_2D_C) +# define BN_MP_CLAMP_C +# define BN_MP_COPY_C +# define BN_MP_GROW_C +# define BN_MP_LSHD_C +#endif + +#if defined(BN_MP_MUL_D_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_MULMOD_C) +# define BN_MP_CLEAR_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_MOD_C +# define BN_MP_MUL_C +#endif + +#if defined(BN_MP_NEG_C) +# define BN_MP_COPY_C +#endif + +#if defined(BN_MP_OR_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_PACK_C) +# define BN_MP_CLEAR_C +# define BN_MP_DIV_2D_C +# define BN_MP_INIT_COPY_C +# define BN_MP_PACK_COUNT_C +#endif + +#if defined(BN_MP_PACK_COUNT_C) +# define BN_MP_COUNT_BITS_C +#endif + +#if defined(BN_MP_PRIME_FERMAT_C) +# define BN_MP_CLEAR_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_EXPTMOD_C +# define BN_MP_INIT_C +#endif + +#if defined(BN_MP_PRIME_FROBENIUS_UNDERWOOD_C) +# define BN_MP_ADD_C +# define BN_MP_ADD_D_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_EXCH_C +# define BN_MP_GCD_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_KRONECKER_C +# define BN_MP_MOD_C +# define BN_MP_MUL_2_C +# define BN_MP_MUL_C +# define BN_MP_MUL_D_C +# define BN_MP_SET_C +# define BN_MP_SET_U32_C +# define BN_MP_SQR_C +# define BN_MP_SUB_C +# define BN_MP_SUB_D_C +# define BN_S_MP_GET_BIT_C +#endif + +#if defined(BN_MP_PRIME_IS_PRIME_C) +# define BN_MP_CLEAR_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DIV_2D_C +# define BN_MP_INIT_SET_C +# define BN_MP_IS_SQUARE_C +# define BN_MP_PRIME_MILLER_RABIN_C +# define BN_MP_PRIME_STRONG_LUCAS_SELFRIDGE_C +# define BN_MP_RAND_C +# define BN_MP_READ_RADIX_C +# define BN_MP_SET_C +# define BN_S_MP_PRIME_IS_DIVISIBLE_C +#endif + +#if defined(BN_MP_PRIME_MILLER_RABIN_C) +# define BN_MP_CLEAR_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_CNT_LSB_C +# define BN_MP_DIV_2D_C +# define BN_MP_EXPTMOD_C +# define BN_MP_INIT_C +# define BN_MP_INIT_COPY_C +# define BN_MP_SQRMOD_C +# define BN_MP_SUB_D_C +#endif + +#if defined(BN_MP_PRIME_NEXT_PRIME_C) +# define BN_MP_ADD_D_C +# define BN_MP_CLEAR_C +# define BN_MP_CMP_D_C +# define BN_MP_INIT_C +# define BN_MP_MOD_D_C +# define BN_MP_PRIME_IS_PRIME_C +# define BN_MP_SET_C +# define BN_MP_SUB_D_C +#endif + +#if defined(BN_MP_PRIME_RABIN_MILLER_TRIALS_C) +#endif + +#if defined(BN_MP_PRIME_RAND_C) +# define BN_MP_ADD_D_C +# define BN_MP_DIV_2_C +# define BN_MP_FROM_UBIN_C +# define BN_MP_MUL_2_C +# define BN_MP_PRIME_IS_PRIME_C +# define BN_MP_SUB_D_C +# define BN_S_MP_PRIME_RANDOM_EX_C +# define BN_S_MP_RAND_CB_C +# define BN_S_MP_RAND_SOURCE_C +#endif + +#if defined(BN_MP_PRIME_STRONG_LUCAS_SELFRIDGE_C) +# define BN_MP_ADD_C +# define BN_MP_ADD_D_C +# define BN_MP_CLEAR_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_CNT_LSB_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DIV_2D_C +# define BN_MP_DIV_2_C +# define BN_MP_GCD_C +# define BN_MP_INIT_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_KRONECKER_C +# define BN_MP_MOD_C +# define BN_MP_MUL_2_C +# define BN_MP_MUL_C +# define BN_MP_SET_C +# define BN_MP_SET_I32_C +# define BN_MP_SET_U32_C +# define BN_MP_SQR_C +# define BN_MP_SUB_C +# define BN_MP_SUB_D_C +# define BN_S_MP_GET_BIT_C +# define BN_S_MP_MUL_SI_C +#endif + +#if defined(BN_MP_RADIX_SIZE_C) +# define BN_MP_CLEAR_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DIV_D_C +# define BN_MP_INIT_COPY_C +#endif + +#if defined(BN_MP_RADIX_SMAP_C) +#endif + +#if defined(BN_MP_RAND_C) +# define BN_MP_GROW_C +# define BN_MP_RAND_SOURCE_C +# define BN_MP_ZERO_C +# define BN_S_MP_RAND_PLATFORM_C +# define BN_S_MP_RAND_SOURCE_C +#endif + +#if defined(BN_MP_READ_RADIX_C) +# define BN_MP_ADD_D_C +# define BN_MP_MUL_D_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_REDUCE_C) +# define BN_MP_ADD_C +# define BN_MP_CLEAR_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_INIT_COPY_C +# define BN_MP_LSHD_C +# define BN_MP_MOD_2D_C +# define BN_MP_MUL_C +# define BN_MP_RSHD_C +# define BN_MP_SET_C +# define BN_MP_SUB_C +# define BN_S_MP_MUL_DIGS_C +# define BN_S_MP_MUL_HIGH_DIGS_C +# define BN_S_MP_MUL_HIGH_DIGS_FAST_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_REDUCE_2K_C) +# define BN_MP_CLEAR_C +# define BN_MP_CMP_MAG_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DIV_2D_C +# define BN_MP_INIT_C +# define BN_MP_MUL_D_C +# define BN_S_MP_ADD_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_REDUCE_2K_L_C) +# define BN_MP_CLEAR_C +# define BN_MP_CMP_MAG_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DIV_2D_C +# define BN_MP_INIT_C +# define BN_MP_MUL_C +# define BN_S_MP_ADD_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_REDUCE_2K_SETUP_C) +# define BN_MP_2EXPT_C +# define BN_MP_CLEAR_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_INIT_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_REDUCE_2K_SETUP_L_C) +# define BN_MP_2EXPT_C +# define BN_MP_CLEAR_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_INIT_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_REDUCE_IS_2K_C) +# define BN_MP_COUNT_BITS_C +#endif + +#if defined(BN_MP_REDUCE_IS_2K_L_C) +#endif + +#if defined(BN_MP_REDUCE_SETUP_C) +# define BN_MP_2EXPT_C +# define BN_MP_DIV_C +#endif + +#if defined(BN_MP_ROOT_U32_C) +# define BN_MP_2EXPT_C +# define BN_MP_ADD_D_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_C +# define BN_MP_COPY_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DIV_C +# define BN_MP_EXCH_C +# define BN_MP_EXPT_U32_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_MUL_C +# define BN_MP_MUL_D_C +# define BN_MP_SET_C +# define BN_MP_SUB_C +# define BN_MP_SUB_D_C +#endif + +#if defined(BN_MP_RSHD_C) +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_SBIN_SIZE_C) +# define BN_MP_UBIN_SIZE_C +#endif + +#if defined(BN_MP_SET_C) +#endif + +#if defined(BN_MP_SET_DOUBLE_C) +# define BN_MP_DIV_2D_C +# define BN_MP_MUL_2D_C +# define BN_MP_SET_U64_C +#endif + +#if defined(BN_MP_SET_I32_C) +# define BN_MP_SET_U32_C +#endif + +#if defined(BN_MP_SET_I64_C) +# define BN_MP_SET_U64_C +#endif + +#if defined(BN_MP_SET_L_C) +# define BN_MP_SET_UL_C +#endif + +#if defined(BN_MP_SET_LL_C) +# define BN_MP_SET_ULL_C +#endif + +#if defined(BN_MP_SET_U32_C) +#endif + +#if defined(BN_MP_SET_U64_C) +#endif + +#if defined(BN_MP_SET_UL_C) +#endif + +#if defined(BN_MP_SET_ULL_C) +#endif + +#if defined(BN_MP_SHRINK_C) +#endif + +#if defined(BN_MP_SIGNED_RSH_C) +# define BN_MP_ADD_D_C +# define BN_MP_DIV_2D_C +# define BN_MP_SUB_D_C +#endif + +#if defined(BN_MP_SQR_C) +# define BN_S_MP_KARATSUBA_SQR_C +# define BN_S_MP_SQR_C +# define BN_S_MP_SQR_FAST_C +# define BN_S_MP_TOOM_SQR_C +#endif + +#if defined(BN_MP_SQRMOD_C) +# define BN_MP_CLEAR_C +# define BN_MP_INIT_C +# define BN_MP_MOD_C +# define BN_MP_SQR_C +#endif + +#if defined(BN_MP_SQRT_C) +# define BN_MP_ADD_C +# define BN_MP_CLEAR_C +# define BN_MP_CMP_MAG_C +# define BN_MP_DIV_2_C +# define BN_MP_DIV_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_C +# define BN_MP_INIT_COPY_C +# define BN_MP_RSHD_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_SQRTMOD_PRIME_C) +# define BN_MP_ADD_D_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_D_C +# define BN_MP_COPY_C +# define BN_MP_DIV_2_C +# define BN_MP_EXPTMOD_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_KRONECKER_C +# define BN_MP_MOD_D_C +# define BN_MP_MULMOD_C +# define BN_MP_SET_C +# define BN_MP_SET_U32_C +# define BN_MP_SQRMOD_C +# define BN_MP_SUB_D_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_SUB_C) +# define BN_MP_CMP_MAG_C +# define BN_S_MP_ADD_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_SUB_D_C) +# define BN_MP_ADD_D_C +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_SUBMOD_C) +# define BN_MP_CLEAR_C +# define BN_MP_INIT_C +# define BN_MP_MOD_C +# define BN_MP_SUB_C +#endif + +#if defined(BN_MP_TO_RADIX_C) +# define BN_MP_CLEAR_C +# define BN_MP_DIV_D_C +# define BN_MP_INIT_COPY_C +# define BN_S_MP_REVERSE_C +#endif + +#if defined(BN_MP_TO_SBIN_C) +# define BN_MP_TO_UBIN_C +#endif + +#if defined(BN_MP_TO_UBIN_C) +# define BN_MP_CLEAR_C +# define BN_MP_DIV_2D_C +# define BN_MP_INIT_COPY_C +# define BN_MP_UBIN_SIZE_C +#endif + +#if defined(BN_MP_UBIN_SIZE_C) +# define BN_MP_COUNT_BITS_C +#endif + +#if defined(BN_MP_UNPACK_C) +# define BN_MP_CLAMP_C +# define BN_MP_MUL_2D_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_XOR_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_ZERO_C) +#endif + +#if defined(BN_PRIME_TAB_C) +#endif + +#if defined(BN_S_MP_ADD_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_S_MP_BALANCE_MUL_C) +# define BN_MP_ADD_C +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_LSHD_C +# define BN_MP_MUL_C +#endif + +#if defined(BN_S_MP_EXPTMOD_C) +# define BN_MP_CLEAR_C +# define BN_MP_COPY_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_C +# define BN_MP_MOD_C +# define BN_MP_MUL_C +# define BN_MP_REDUCE_2K_L_C +# define BN_MP_REDUCE_2K_SETUP_L_C +# define BN_MP_REDUCE_C +# define BN_MP_REDUCE_SETUP_C +# define BN_MP_SET_C +# define BN_MP_SQR_C +#endif + +#if defined(BN_S_MP_EXPTMOD_FAST_C) +# define BN_MP_CLEAR_C +# define BN_MP_COPY_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DR_REDUCE_C +# define BN_MP_DR_SETUP_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_MOD_C +# define BN_MP_MONTGOMERY_CALC_NORMALIZATION_C +# define BN_MP_MONTGOMERY_REDUCE_C +# define BN_MP_MONTGOMERY_SETUP_C +# define BN_MP_MULMOD_C +# define BN_MP_MUL_C +# define BN_MP_REDUCE_2K_C +# define BN_MP_REDUCE_2K_SETUP_C +# define BN_MP_SET_C +# define BN_MP_SQR_C +# define BN_S_MP_MONTGOMERY_REDUCE_FAST_C +#endif + +#if defined(BN_S_MP_GET_BIT_C) +#endif + +#if defined(BN_S_MP_INVMOD_FAST_C) +# define BN_MP_ADD_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_CMP_MAG_C +# define BN_MP_COPY_C +# define BN_MP_DIV_2_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_MOD_C +# define BN_MP_SET_C +# define BN_MP_SUB_C +#endif + +#if defined(BN_S_MP_INVMOD_SLOW_C) +# define BN_MP_ADD_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_CMP_MAG_C +# define BN_MP_COPY_C +# define BN_MP_DIV_2_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_MOD_C +# define BN_MP_SET_C +# define BN_MP_SUB_C +#endif + +#if defined(BN_S_MP_KARATSUBA_MUL_C) +# define BN_MP_ADD_C +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_LSHD_C +# define BN_MP_MUL_C +# define BN_S_MP_ADD_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_S_MP_KARATSUBA_SQR_C) +# define BN_MP_ADD_C +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_LSHD_C +# define BN_MP_SQR_C +# define BN_S_MP_ADD_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_S_MP_MONTGOMERY_REDUCE_FAST_C) +# define BN_MP_CLAMP_C +# define BN_MP_CMP_MAG_C +# define BN_MP_GROW_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_S_MP_MUL_DIGS_C) +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_SIZE_C +# define BN_S_MP_MUL_DIGS_FAST_C +#endif + +#if defined(BN_S_MP_MUL_DIGS_FAST_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_S_MP_MUL_HIGH_DIGS_C) +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_SIZE_C +# define BN_S_MP_MUL_HIGH_DIGS_FAST_C +#endif + +#if defined(BN_S_MP_MUL_HIGH_DIGS_FAST_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_S_MP_PRIME_IS_DIVISIBLE_C) +# define BN_MP_MOD_D_C +#endif + +#if defined(BN_S_MP_RAND_JENKINS_C) +# define BN_S_MP_RAND_JENKINS_INIT_C +#endif + +#if defined(BN_S_MP_RAND_PLATFORM_C) +#endif + +#if defined(BN_S_MP_REVERSE_C) +#endif + +#if defined(BN_S_MP_SQR_C) +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_SIZE_C +#endif + +#if defined(BN_S_MP_SQR_FAST_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_S_MP_SUB_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_S_MP_TOOM_MUL_C) +# define BN_MP_ADD_C +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_DIV_2_C +# define BN_MP_DIV_3_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_LSHD_C +# define BN_MP_MUL_2_C +# define BN_MP_MUL_C +# define BN_MP_SUB_C +#endif + +#if defined(BN_S_MP_TOOM_SQR_C) +# define BN_MP_ADD_C +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_DIV_2_C +# define BN_MP_INIT_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_LSHD_C +# define BN_MP_MUL_2_C +# define BN_MP_MUL_C +# define BN_MP_SQR_C +# define BN_MP_SUB_C +#endif + +#ifdef LTM_INSIDE +#undef LTM_INSIDE +#ifdef LTM3 +# define LTM_LAST +#endif + +#include "tommath_superclass.h" +#include "tommath_class.h" +#else +# define LTM_LAST +#endif diff --git a/libtom/libtommath/include/tommath_cutoffs.h b/libtom/libtommath/include/tommath_cutoffs.h new file mode 100644 index 0000000..a65a9b3 --- /dev/null +++ b/libtom/libtommath/include/tommath_cutoffs.h @@ -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 diff --git a/libtom/libtommath/include/tommath_private.h b/libtom/libtommath/include/tommath_private.h new file mode 100644 index 0000000..1a0096f --- /dev/null +++ b/libtom/libtommath/include/tommath_private.h @@ -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 +# 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 +# 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 diff --git a/libtom/libtommath/include/tommath_superclass.h b/libtom/libtommath/include/tommath_superclass.h new file mode 100644 index 0000000..d88bce9 --- /dev/null +++ b/libtom/libtommath/include/tommath_superclass.h @@ -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 diff --git a/libtom/libtommath/lib/tommath.lib b/libtom/libtommath/lib/tommath.lib new file mode 100644 index 0000000..dbf56e3 Binary files /dev/null and b/libtom/libtommath/lib/tommath.lib differ diff --git a/libtom/libtommath/tommath.h b/libtom/libtommath/tommath.h new file mode 100644 index 0000000..e87bb08 --- /dev/null +++ b/libtom/libtommath/tommath.h @@ -0,0 +1,781 @@ +/* LibTomMath, multiple-precision integer library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +#ifndef BN_H_ +#define BN_H_ + +#include +#include +#include + +#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 +#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 diff --git a/libtom/libtommath/tommath_class.h b/libtom/libtommath/tommath_class.h new file mode 100644 index 0000000..52ba585 --- /dev/null +++ b/libtom/libtommath/tommath_class.h @@ -0,0 +1,1319 @@ +/* LibTomMath, multiple-precision integer library -- Tom St Denis */ +/* SPDX-License-Identifier: Unlicense */ + +#if !(defined(LTM1) && defined(LTM2) && defined(LTM3)) +#define LTM_INSIDE +#if defined(LTM2) +# define LTM3 +#endif +#if defined(LTM1) +# define LTM2 +#endif +#define LTM1 +#if defined(LTM_ALL) +# define BN_CUTOFFS_C +# define BN_DEPRECATED_C +# define BN_MP_2EXPT_C +# define BN_MP_ABS_C +# define BN_MP_ADD_C +# define BN_MP_ADD_D_C +# define BN_MP_ADDMOD_C +# define BN_MP_AND_C +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_CMP_MAG_C +# define BN_MP_CNT_LSB_C +# define BN_MP_COMPLEMENT_C +# define BN_MP_COPY_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DECR_C +# define BN_MP_DIV_C +# define BN_MP_DIV_2_C +# define BN_MP_DIV_2D_C +# define BN_MP_DIV_3_C +# define BN_MP_DIV_D_C +# define BN_MP_DR_IS_MODULUS_C +# define BN_MP_DR_REDUCE_C +# define BN_MP_DR_SETUP_C +# define BN_MP_ERROR_TO_STRING_C +# define BN_MP_EXCH_C +# define BN_MP_EXPT_U32_C +# define BN_MP_EXPTMOD_C +# define BN_MP_EXTEUCLID_C +# define BN_MP_FREAD_C +# define BN_MP_FROM_SBIN_C +# define BN_MP_FROM_UBIN_C +# define BN_MP_FWRITE_C +# define BN_MP_GCD_C +# define BN_MP_GET_DOUBLE_C +# define BN_MP_GET_I32_C +# define BN_MP_GET_I64_C +# define BN_MP_GET_L_C +# define BN_MP_GET_LL_C +# define BN_MP_GET_MAG_U32_C +# define BN_MP_GET_MAG_U64_C +# define BN_MP_GET_MAG_UL_C +# define BN_MP_GET_MAG_ULL_C +# define BN_MP_GROW_C +# define BN_MP_INCR_C +# define BN_MP_INIT_C +# define BN_MP_INIT_COPY_C +# define BN_MP_INIT_I32_C +# define BN_MP_INIT_I64_C +# define BN_MP_INIT_L_C +# define BN_MP_INIT_LL_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_INIT_SET_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_INIT_U32_C +# define BN_MP_INIT_U64_C +# define BN_MP_INIT_UL_C +# define BN_MP_INIT_ULL_C +# define BN_MP_INVMOD_C +# define BN_MP_IS_SQUARE_C +# define BN_MP_ISEVEN_C +# define BN_MP_ISODD_C +# define BN_MP_KRONECKER_C +# define BN_MP_LCM_C +# define BN_MP_LOG_U32_C +# define BN_MP_LSHD_C +# define BN_MP_MOD_C +# define BN_MP_MOD_2D_C +# define BN_MP_MOD_D_C +# define BN_MP_MONTGOMERY_CALC_NORMALIZATION_C +# define BN_MP_MONTGOMERY_REDUCE_C +# define BN_MP_MONTGOMERY_SETUP_C +# define BN_MP_MUL_C +# define BN_MP_MUL_2_C +# define BN_MP_MUL_2D_C +# define BN_MP_MUL_D_C +# define BN_MP_MULMOD_C +# define BN_MP_NEG_C +# define BN_MP_OR_C +# define BN_MP_PACK_C +# define BN_MP_PACK_COUNT_C +# define BN_MP_PRIME_FERMAT_C +# define BN_MP_PRIME_FROBENIUS_UNDERWOOD_C +# define BN_MP_PRIME_IS_PRIME_C +# define BN_MP_PRIME_MILLER_RABIN_C +# define BN_MP_PRIME_NEXT_PRIME_C +# define BN_MP_PRIME_RABIN_MILLER_TRIALS_C +# define BN_MP_PRIME_RAND_C +# define BN_MP_PRIME_STRONG_LUCAS_SELFRIDGE_C +# define BN_MP_RADIX_SIZE_C +# define BN_MP_RADIX_SMAP_C +# define BN_MP_RAND_C +# define BN_MP_READ_RADIX_C +# define BN_MP_REDUCE_C +# define BN_MP_REDUCE_2K_C +# define BN_MP_REDUCE_2K_L_C +# define BN_MP_REDUCE_2K_SETUP_C +# define BN_MP_REDUCE_2K_SETUP_L_C +# define BN_MP_REDUCE_IS_2K_C +# define BN_MP_REDUCE_IS_2K_L_C +# define BN_MP_REDUCE_SETUP_C +# define BN_MP_ROOT_U32_C +# define BN_MP_RSHD_C +# define BN_MP_SBIN_SIZE_C +# define BN_MP_SET_C +# define BN_MP_SET_DOUBLE_C +# define BN_MP_SET_I32_C +# define BN_MP_SET_I64_C +# define BN_MP_SET_L_C +# define BN_MP_SET_LL_C +# define BN_MP_SET_U32_C +# define BN_MP_SET_U64_C +# define BN_MP_SET_UL_C +# define BN_MP_SET_ULL_C +# define BN_MP_SHRINK_C +# define BN_MP_SIGNED_RSH_C +# define BN_MP_SQR_C +# define BN_MP_SQRMOD_C +# define BN_MP_SQRT_C +# define BN_MP_SQRTMOD_PRIME_C +# define BN_MP_SUB_C +# define BN_MP_SUB_D_C +# define BN_MP_SUBMOD_C +# define BN_MP_TO_RADIX_C +# define BN_MP_TO_SBIN_C +# define BN_MP_TO_UBIN_C +# define BN_MP_UBIN_SIZE_C +# define BN_MP_UNPACK_C +# define BN_MP_XOR_C +# define BN_MP_ZERO_C +# define BN_PRIME_TAB_C +# define BN_S_MP_ADD_C +# define BN_S_MP_BALANCE_MUL_C +# define BN_S_MP_EXPTMOD_C +# define BN_S_MP_EXPTMOD_FAST_C +# define BN_S_MP_GET_BIT_C +# define BN_S_MP_INVMOD_FAST_C +# define BN_S_MP_INVMOD_SLOW_C +# define BN_S_MP_KARATSUBA_MUL_C +# define BN_S_MP_KARATSUBA_SQR_C +# define BN_S_MP_MONTGOMERY_REDUCE_FAST_C +# define BN_S_MP_MUL_DIGS_C +# define BN_S_MP_MUL_DIGS_FAST_C +# define BN_S_MP_MUL_HIGH_DIGS_C +# define BN_S_MP_MUL_HIGH_DIGS_FAST_C +# define BN_S_MP_PRIME_IS_DIVISIBLE_C +# define BN_S_MP_RAND_JENKINS_C +# define BN_S_MP_RAND_PLATFORM_C +# define BN_S_MP_REVERSE_C +# define BN_S_MP_SQR_C +# define BN_S_MP_SQR_FAST_C +# define BN_S_MP_SUB_C +# define BN_S_MP_TOOM_MUL_C +# define BN_S_MP_TOOM_SQR_C +#endif +#endif +#if defined(BN_CUTOFFS_C) +#endif + +#if defined(BN_DEPRECATED_C) +# define BN_FAST_MP_INVMOD_C +# define BN_FAST_MP_MONTGOMERY_REDUCE_C +# define BN_FAST_S_MP_MUL_DIGS_C +# define BN_FAST_S_MP_MUL_HIGH_DIGS_C +# define BN_FAST_S_MP_SQR_C +# define BN_MP_AND_C +# define BN_MP_BALANCE_MUL_C +# define BN_MP_CMP_D_C +# define BN_MP_EXPORT_C +# define BN_MP_EXPTMOD_FAST_C +# define BN_MP_EXPT_D_C +# define BN_MP_EXPT_D_EX_C +# define BN_MP_EXPT_U32_C +# define BN_MP_FROM_SBIN_C +# define BN_MP_FROM_UBIN_C +# define BN_MP_GET_BIT_C +# define BN_MP_GET_INT_C +# define BN_MP_GET_LONG_C +# define BN_MP_GET_LONG_LONG_C +# define BN_MP_GET_MAG_U32_C +# define BN_MP_GET_MAG_ULL_C +# define BN_MP_GET_MAG_UL_C +# define BN_MP_IMPORT_C +# define BN_MP_INIT_SET_INT_C +# define BN_MP_INIT_U32_C +# define BN_MP_INVMOD_SLOW_C +# define BN_MP_JACOBI_C +# define BN_MP_KARATSUBA_MUL_C +# define BN_MP_KARATSUBA_SQR_C +# define BN_MP_KRONECKER_C +# define BN_MP_N_ROOT_C +# define BN_MP_N_ROOT_EX_C +# define BN_MP_OR_C +# define BN_MP_PACK_C +# define BN_MP_PRIME_IS_DIVISIBLE_C +# define BN_MP_PRIME_RANDOM_EX_C +# define BN_MP_RAND_DIGIT_C +# define BN_MP_READ_SIGNED_BIN_C +# define BN_MP_READ_UNSIGNED_BIN_C +# define BN_MP_ROOT_U32_C +# define BN_MP_SBIN_SIZE_C +# define BN_MP_SET_INT_C +# define BN_MP_SET_LONG_C +# define BN_MP_SET_LONG_LONG_C +# define BN_MP_SET_U32_C +# define BN_MP_SET_U64_C +# define BN_MP_SIGNED_BIN_SIZE_C +# define BN_MP_SIGNED_RSH_C +# define BN_MP_TC_AND_C +# define BN_MP_TC_DIV_2D_C +# define BN_MP_TC_OR_C +# define BN_MP_TC_XOR_C +# define BN_MP_TOOM_MUL_C +# define BN_MP_TOOM_SQR_C +# define BN_MP_TORADIX_C +# define BN_MP_TORADIX_N_C +# define BN_MP_TO_RADIX_C +# define BN_MP_TO_SBIN_C +# define BN_MP_TO_SIGNED_BIN_C +# define BN_MP_TO_SIGNED_BIN_N_C +# define BN_MP_TO_UBIN_C +# define BN_MP_TO_UNSIGNED_BIN_C +# define BN_MP_TO_UNSIGNED_BIN_N_C +# define BN_MP_UBIN_SIZE_C +# define BN_MP_UNPACK_C +# define BN_MP_UNSIGNED_BIN_SIZE_C +# define BN_MP_XOR_C +# define BN_S_MP_BALANCE_MUL_C +# define BN_S_MP_EXPTMOD_FAST_C +# define BN_S_MP_GET_BIT_C +# define BN_S_MP_INVMOD_FAST_C +# define BN_S_MP_INVMOD_SLOW_C +# define BN_S_MP_KARATSUBA_MUL_C +# define BN_S_MP_KARATSUBA_SQR_C +# define BN_S_MP_MONTGOMERY_REDUCE_FAST_C +# define BN_S_MP_MUL_DIGS_FAST_C +# define BN_S_MP_MUL_HIGH_DIGS_FAST_C +# define BN_S_MP_PRIME_IS_DIVISIBLE_C +# define BN_S_MP_PRIME_RANDOM_EX_C +# define BN_S_MP_RAND_SOURCE_C +# define BN_S_MP_REVERSE_C +# define BN_S_MP_SQR_FAST_C +# define BN_S_MP_TOOM_MUL_C +# define BN_S_MP_TOOM_SQR_C +#endif + +#if defined(BN_MP_2EXPT_C) +# define BN_MP_GROW_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_ABS_C) +# define BN_MP_COPY_C +#endif + +#if defined(BN_MP_ADD_C) +# define BN_MP_CMP_MAG_C +# define BN_S_MP_ADD_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_ADD_D_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +# define BN_MP_SUB_D_C +#endif + +#if defined(BN_MP_ADDMOD_C) +# define BN_MP_ADD_C +# define BN_MP_CLEAR_C +# define BN_MP_INIT_C +# define BN_MP_MOD_C +#endif + +#if defined(BN_MP_AND_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_CLAMP_C) +#endif + +#if defined(BN_MP_CLEAR_C) +#endif + +#if defined(BN_MP_CLEAR_MULTI_C) +# define BN_MP_CLEAR_C +#endif + +#if defined(BN_MP_CMP_C) +# define BN_MP_CMP_MAG_C +#endif + +#if defined(BN_MP_CMP_D_C) +#endif + +#if defined(BN_MP_CMP_MAG_C) +#endif + +#if defined(BN_MP_CNT_LSB_C) +#endif + +#if defined(BN_MP_COMPLEMENT_C) +# define BN_MP_NEG_C +# define BN_MP_SUB_D_C +#endif + +#if defined(BN_MP_COPY_C) +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_COUNT_BITS_C) +#endif + +#if defined(BN_MP_DECR_C) +# define BN_MP_INCR_C +# define BN_MP_SET_C +# define BN_MP_SUB_D_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_DIV_C) +# define BN_MP_ADD_C +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_CMP_C +# define BN_MP_CMP_MAG_C +# define BN_MP_COPY_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DIV_2D_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_C +# define BN_MP_INIT_COPY_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_LSHD_C +# define BN_MP_MUL_2D_C +# define BN_MP_MUL_D_C +# define BN_MP_RSHD_C +# define BN_MP_SUB_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_DIV_2_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_DIV_2D_C) +# define BN_MP_CLAMP_C +# define BN_MP_COPY_C +# define BN_MP_MOD_2D_C +# define BN_MP_RSHD_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_DIV_3_C) +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_SIZE_C +#endif + +#if defined(BN_MP_DIV_D_C) +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_COPY_C +# define BN_MP_DIV_2D_C +# define BN_MP_DIV_3_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_SIZE_C +#endif + +#if defined(BN_MP_DR_IS_MODULUS_C) +#endif + +#if defined(BN_MP_DR_REDUCE_C) +# define BN_MP_CLAMP_C +# define BN_MP_CMP_MAG_C +# define BN_MP_GROW_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_DR_SETUP_C) +#endif + +#if defined(BN_MP_ERROR_TO_STRING_C) +#endif + +#if defined(BN_MP_EXCH_C) +#endif + +#if defined(BN_MP_EXPT_U32_C) +# define BN_MP_CLEAR_C +# define BN_MP_INIT_COPY_C +# define BN_MP_MUL_C +# define BN_MP_SET_C +# define BN_MP_SQR_C +#endif + +#if defined(BN_MP_EXPTMOD_C) +# define BN_MP_ABS_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_DR_IS_MODULUS_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_INVMOD_C +# define BN_MP_REDUCE_IS_2K_C +# define BN_MP_REDUCE_IS_2K_L_C +# define BN_S_MP_EXPTMOD_C +# define BN_S_MP_EXPTMOD_FAST_C +#endif + +#if defined(BN_MP_EXTEUCLID_C) +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_COPY_C +# define BN_MP_DIV_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_MUL_C +# define BN_MP_NEG_C +# define BN_MP_SET_C +# define BN_MP_SUB_C +#endif + +#if defined(BN_MP_FREAD_C) +# define BN_MP_ADD_D_C +# define BN_MP_MUL_D_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_FROM_SBIN_C) +# define BN_MP_FROM_UBIN_C +#endif + +#if defined(BN_MP_FROM_UBIN_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +# define BN_MP_MUL_2D_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_FWRITE_C) +# define BN_MP_RADIX_SIZE_C +# define BN_MP_TO_RADIX_C +#endif + +#if defined(BN_MP_GCD_C) +# define BN_MP_ABS_C +# define BN_MP_CLEAR_C +# define BN_MP_CMP_MAG_C +# define BN_MP_CNT_LSB_C +# define BN_MP_DIV_2D_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_COPY_C +# define BN_MP_MUL_2D_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_GET_DOUBLE_C) +#endif + +#if defined(BN_MP_GET_I32_C) +# define BN_MP_GET_MAG_U32_C +#endif + +#if defined(BN_MP_GET_I64_C) +# define BN_MP_GET_MAG_U64_C +#endif + +#if defined(BN_MP_GET_L_C) +# define BN_MP_GET_MAG_UL_C +#endif + +#if defined(BN_MP_GET_LL_C) +# define BN_MP_GET_MAG_ULL_C +#endif + +#if defined(BN_MP_GET_MAG_U32_C) +#endif + +#if defined(BN_MP_GET_MAG_U64_C) +#endif + +#if defined(BN_MP_GET_MAG_UL_C) +#endif + +#if defined(BN_MP_GET_MAG_ULL_C) +#endif + +#if defined(BN_MP_GROW_C) +#endif + +#if defined(BN_MP_INCR_C) +# define BN_MP_ADD_D_C +# define BN_MP_DECR_C +# define BN_MP_SET_C +#endif + +#if defined(BN_MP_INIT_C) +#endif + +#if defined(BN_MP_INIT_COPY_C) +# define BN_MP_CLEAR_C +# define BN_MP_COPY_C +# define BN_MP_INIT_SIZE_C +#endif + +#if defined(BN_MP_INIT_I32_C) +# define BN_MP_INIT_C +# define BN_MP_SET_I32_C +#endif + +#if defined(BN_MP_INIT_I64_C) +# define BN_MP_INIT_C +# define BN_MP_SET_I64_C +#endif + +#if defined(BN_MP_INIT_L_C) +# define BN_MP_INIT_C +# define BN_MP_SET_L_C +#endif + +#if defined(BN_MP_INIT_LL_C) +# define BN_MP_INIT_C +# define BN_MP_SET_LL_C +#endif + +#if defined(BN_MP_INIT_MULTI_C) +# define BN_MP_CLEAR_C +# define BN_MP_INIT_C +#endif + +#if defined(BN_MP_INIT_SET_C) +# define BN_MP_INIT_C +# define BN_MP_SET_C +#endif + +#if defined(BN_MP_INIT_SIZE_C) +#endif + +#if defined(BN_MP_INIT_U32_C) +# define BN_MP_INIT_C +# define BN_MP_SET_U32_C +#endif + +#if defined(BN_MP_INIT_U64_C) +# define BN_MP_INIT_C +# define BN_MP_SET_U64_C +#endif + +#if defined(BN_MP_INIT_UL_C) +# define BN_MP_INIT_C +# define BN_MP_SET_UL_C +#endif + +#if defined(BN_MP_INIT_ULL_C) +# define BN_MP_INIT_C +# define BN_MP_SET_ULL_C +#endif + +#if defined(BN_MP_INVMOD_C) +# define BN_MP_CMP_D_C +# define BN_S_MP_INVMOD_FAST_C +# define BN_S_MP_INVMOD_SLOW_C +#endif + +#if defined(BN_MP_IS_SQUARE_C) +# define BN_MP_CLEAR_C +# define BN_MP_CMP_MAG_C +# define BN_MP_GET_I32_C +# define BN_MP_INIT_U32_C +# define BN_MP_MOD_C +# define BN_MP_MOD_D_C +# define BN_MP_SQRT_C +# define BN_MP_SQR_C +#endif + +#if defined(BN_MP_ISEVEN_C) +#endif + +#if defined(BN_MP_ISODD_C) +#endif + +#if defined(BN_MP_KRONECKER_C) +# define BN_MP_CLEAR_C +# define BN_MP_CMP_D_C +# define BN_MP_CNT_LSB_C +# define BN_MP_COPY_C +# define BN_MP_DIV_2D_C +# define BN_MP_INIT_C +# define BN_MP_INIT_COPY_C +# define BN_MP_MOD_C +#endif + +#if defined(BN_MP_LCM_C) +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_MAG_C +# define BN_MP_DIV_C +# define BN_MP_GCD_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_MUL_C +#endif + +#if defined(BN_MP_LOG_U32_C) +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_COPY_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_EXCH_C +# define BN_MP_EXPT_U32_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_MUL_C +# define BN_MP_SET_C +# define BN_MP_SQR_C +#endif + +#if defined(BN_MP_LSHD_C) +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_MOD_C) +# define BN_MP_ADD_C +# define BN_MP_CLEAR_C +# define BN_MP_DIV_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_SIZE_C +#endif + +#if defined(BN_MP_MOD_2D_C) +# define BN_MP_CLAMP_C +# define BN_MP_COPY_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_MOD_D_C) +# define BN_MP_DIV_D_C +#endif + +#if defined(BN_MP_MONTGOMERY_CALC_NORMALIZATION_C) +# define BN_MP_2EXPT_C +# define BN_MP_CMP_MAG_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_MUL_2_C +# define BN_MP_SET_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_MONTGOMERY_REDUCE_C) +# define BN_MP_CLAMP_C +# define BN_MP_CMP_MAG_C +# define BN_MP_GROW_C +# define BN_MP_RSHD_C +# define BN_S_MP_MONTGOMERY_REDUCE_FAST_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_MONTGOMERY_SETUP_C) +#endif + +#if defined(BN_MP_MUL_C) +# define BN_S_MP_BALANCE_MUL_C +# define BN_S_MP_KARATSUBA_MUL_C +# define BN_S_MP_MUL_DIGS_C +# define BN_S_MP_MUL_DIGS_FAST_C +# define BN_S_MP_TOOM_MUL_C +#endif + +#if defined(BN_MP_MUL_2_C) +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_MUL_2D_C) +# define BN_MP_CLAMP_C +# define BN_MP_COPY_C +# define BN_MP_GROW_C +# define BN_MP_LSHD_C +#endif + +#if defined(BN_MP_MUL_D_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_MULMOD_C) +# define BN_MP_CLEAR_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_MOD_C +# define BN_MP_MUL_C +#endif + +#if defined(BN_MP_NEG_C) +# define BN_MP_COPY_C +#endif + +#if defined(BN_MP_OR_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_PACK_C) +# define BN_MP_CLEAR_C +# define BN_MP_DIV_2D_C +# define BN_MP_INIT_COPY_C +# define BN_MP_PACK_COUNT_C +#endif + +#if defined(BN_MP_PACK_COUNT_C) +# define BN_MP_COUNT_BITS_C +#endif + +#if defined(BN_MP_PRIME_FERMAT_C) +# define BN_MP_CLEAR_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_EXPTMOD_C +# define BN_MP_INIT_C +#endif + +#if defined(BN_MP_PRIME_FROBENIUS_UNDERWOOD_C) +# define BN_MP_ADD_C +# define BN_MP_ADD_D_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_EXCH_C +# define BN_MP_GCD_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_KRONECKER_C +# define BN_MP_MOD_C +# define BN_MP_MUL_2_C +# define BN_MP_MUL_C +# define BN_MP_MUL_D_C +# define BN_MP_SET_C +# define BN_MP_SET_U32_C +# define BN_MP_SQR_C +# define BN_MP_SUB_C +# define BN_MP_SUB_D_C +# define BN_S_MP_GET_BIT_C +#endif + +#if defined(BN_MP_PRIME_IS_PRIME_C) +# define BN_MP_CLEAR_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DIV_2D_C +# define BN_MP_INIT_SET_C +# define BN_MP_IS_SQUARE_C +# define BN_MP_PRIME_MILLER_RABIN_C +# define BN_MP_PRIME_STRONG_LUCAS_SELFRIDGE_C +# define BN_MP_RAND_C +# define BN_MP_READ_RADIX_C +# define BN_MP_SET_C +# define BN_S_MP_PRIME_IS_DIVISIBLE_C +#endif + +#if defined(BN_MP_PRIME_MILLER_RABIN_C) +# define BN_MP_CLEAR_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_CNT_LSB_C +# define BN_MP_DIV_2D_C +# define BN_MP_EXPTMOD_C +# define BN_MP_INIT_C +# define BN_MP_INIT_COPY_C +# define BN_MP_SQRMOD_C +# define BN_MP_SUB_D_C +#endif + +#if defined(BN_MP_PRIME_NEXT_PRIME_C) +# define BN_MP_ADD_D_C +# define BN_MP_CLEAR_C +# define BN_MP_CMP_D_C +# define BN_MP_INIT_C +# define BN_MP_MOD_D_C +# define BN_MP_PRIME_IS_PRIME_C +# define BN_MP_SET_C +# define BN_MP_SUB_D_C +#endif + +#if defined(BN_MP_PRIME_RABIN_MILLER_TRIALS_C) +#endif + +#if defined(BN_MP_PRIME_RAND_C) +# define BN_MP_ADD_D_C +# define BN_MP_DIV_2_C +# define BN_MP_FROM_UBIN_C +# define BN_MP_MUL_2_C +# define BN_MP_PRIME_IS_PRIME_C +# define BN_MP_SUB_D_C +# define BN_S_MP_PRIME_RANDOM_EX_C +# define BN_S_MP_RAND_CB_C +# define BN_S_MP_RAND_SOURCE_C +#endif + +#if defined(BN_MP_PRIME_STRONG_LUCAS_SELFRIDGE_C) +# define BN_MP_ADD_C +# define BN_MP_ADD_D_C +# define BN_MP_CLEAR_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_CNT_LSB_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DIV_2D_C +# define BN_MP_DIV_2_C +# define BN_MP_GCD_C +# define BN_MP_INIT_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_KRONECKER_C +# define BN_MP_MOD_C +# define BN_MP_MUL_2_C +# define BN_MP_MUL_C +# define BN_MP_SET_C +# define BN_MP_SET_I32_C +# define BN_MP_SET_U32_C +# define BN_MP_SQR_C +# define BN_MP_SUB_C +# define BN_MP_SUB_D_C +# define BN_S_MP_GET_BIT_C +# define BN_S_MP_MUL_SI_C +#endif + +#if defined(BN_MP_RADIX_SIZE_C) +# define BN_MP_CLEAR_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DIV_D_C +# define BN_MP_INIT_COPY_C +#endif + +#if defined(BN_MP_RADIX_SMAP_C) +#endif + +#if defined(BN_MP_RAND_C) +# define BN_MP_GROW_C +# define BN_MP_RAND_SOURCE_C +# define BN_MP_ZERO_C +# define BN_S_MP_RAND_PLATFORM_C +# define BN_S_MP_RAND_SOURCE_C +#endif + +#if defined(BN_MP_READ_RADIX_C) +# define BN_MP_ADD_D_C +# define BN_MP_MUL_D_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_REDUCE_C) +# define BN_MP_ADD_C +# define BN_MP_CLEAR_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_INIT_COPY_C +# define BN_MP_LSHD_C +# define BN_MP_MOD_2D_C +# define BN_MP_MUL_C +# define BN_MP_RSHD_C +# define BN_MP_SET_C +# define BN_MP_SUB_C +# define BN_S_MP_MUL_DIGS_C +# define BN_S_MP_MUL_HIGH_DIGS_C +# define BN_S_MP_MUL_HIGH_DIGS_FAST_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_REDUCE_2K_C) +# define BN_MP_CLEAR_C +# define BN_MP_CMP_MAG_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DIV_2D_C +# define BN_MP_INIT_C +# define BN_MP_MUL_D_C +# define BN_S_MP_ADD_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_REDUCE_2K_L_C) +# define BN_MP_CLEAR_C +# define BN_MP_CMP_MAG_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DIV_2D_C +# define BN_MP_INIT_C +# define BN_MP_MUL_C +# define BN_S_MP_ADD_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_REDUCE_2K_SETUP_C) +# define BN_MP_2EXPT_C +# define BN_MP_CLEAR_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_INIT_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_REDUCE_2K_SETUP_L_C) +# define BN_MP_2EXPT_C +# define BN_MP_CLEAR_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_INIT_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_REDUCE_IS_2K_C) +# define BN_MP_COUNT_BITS_C +#endif + +#if defined(BN_MP_REDUCE_IS_2K_L_C) +#endif + +#if defined(BN_MP_REDUCE_SETUP_C) +# define BN_MP_2EXPT_C +# define BN_MP_DIV_C +#endif + +#if defined(BN_MP_ROOT_U32_C) +# define BN_MP_2EXPT_C +# define BN_MP_ADD_D_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_C +# define BN_MP_COPY_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DIV_C +# define BN_MP_EXCH_C +# define BN_MP_EXPT_U32_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_MUL_C +# define BN_MP_MUL_D_C +# define BN_MP_SET_C +# define BN_MP_SUB_C +# define BN_MP_SUB_D_C +#endif + +#if defined(BN_MP_RSHD_C) +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_SBIN_SIZE_C) +# define BN_MP_UBIN_SIZE_C +#endif + +#if defined(BN_MP_SET_C) +#endif + +#if defined(BN_MP_SET_DOUBLE_C) +# define BN_MP_DIV_2D_C +# define BN_MP_MUL_2D_C +# define BN_MP_SET_U64_C +#endif + +#if defined(BN_MP_SET_I32_C) +# define BN_MP_SET_U32_C +#endif + +#if defined(BN_MP_SET_I64_C) +# define BN_MP_SET_U64_C +#endif + +#if defined(BN_MP_SET_L_C) +# define BN_MP_SET_UL_C +#endif + +#if defined(BN_MP_SET_LL_C) +# define BN_MP_SET_ULL_C +#endif + +#if defined(BN_MP_SET_U32_C) +#endif + +#if defined(BN_MP_SET_U64_C) +#endif + +#if defined(BN_MP_SET_UL_C) +#endif + +#if defined(BN_MP_SET_ULL_C) +#endif + +#if defined(BN_MP_SHRINK_C) +#endif + +#if defined(BN_MP_SIGNED_RSH_C) +# define BN_MP_ADD_D_C +# define BN_MP_DIV_2D_C +# define BN_MP_SUB_D_C +#endif + +#if defined(BN_MP_SQR_C) +# define BN_S_MP_KARATSUBA_SQR_C +# define BN_S_MP_SQR_C +# define BN_S_MP_SQR_FAST_C +# define BN_S_MP_TOOM_SQR_C +#endif + +#if defined(BN_MP_SQRMOD_C) +# define BN_MP_CLEAR_C +# define BN_MP_INIT_C +# define BN_MP_MOD_C +# define BN_MP_SQR_C +#endif + +#if defined(BN_MP_SQRT_C) +# define BN_MP_ADD_C +# define BN_MP_CLEAR_C +# define BN_MP_CMP_MAG_C +# define BN_MP_DIV_2_C +# define BN_MP_DIV_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_C +# define BN_MP_INIT_COPY_C +# define BN_MP_RSHD_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_SQRTMOD_PRIME_C) +# define BN_MP_ADD_D_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_D_C +# define BN_MP_COPY_C +# define BN_MP_DIV_2_C +# define BN_MP_EXPTMOD_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_KRONECKER_C +# define BN_MP_MOD_D_C +# define BN_MP_MULMOD_C +# define BN_MP_SET_C +# define BN_MP_SET_U32_C +# define BN_MP_SQRMOD_C +# define BN_MP_SUB_D_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_SUB_C) +# define BN_MP_CMP_MAG_C +# define BN_S_MP_ADD_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_MP_SUB_D_C) +# define BN_MP_ADD_D_C +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_SUBMOD_C) +# define BN_MP_CLEAR_C +# define BN_MP_INIT_C +# define BN_MP_MOD_C +# define BN_MP_SUB_C +#endif + +#if defined(BN_MP_TO_RADIX_C) +# define BN_MP_CLEAR_C +# define BN_MP_DIV_D_C +# define BN_MP_INIT_COPY_C +# define BN_S_MP_REVERSE_C +#endif + +#if defined(BN_MP_TO_SBIN_C) +# define BN_MP_TO_UBIN_C +#endif + +#if defined(BN_MP_TO_UBIN_C) +# define BN_MP_CLEAR_C +# define BN_MP_DIV_2D_C +# define BN_MP_INIT_COPY_C +# define BN_MP_UBIN_SIZE_C +#endif + +#if defined(BN_MP_UBIN_SIZE_C) +# define BN_MP_COUNT_BITS_C +#endif + +#if defined(BN_MP_UNPACK_C) +# define BN_MP_CLAMP_C +# define BN_MP_MUL_2D_C +# define BN_MP_ZERO_C +#endif + +#if defined(BN_MP_XOR_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_MP_ZERO_C) +#endif + +#if defined(BN_PRIME_TAB_C) +#endif + +#if defined(BN_S_MP_ADD_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_S_MP_BALANCE_MUL_C) +# define BN_MP_ADD_C +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_LSHD_C +# define BN_MP_MUL_C +#endif + +#if defined(BN_S_MP_EXPTMOD_C) +# define BN_MP_CLEAR_C +# define BN_MP_COPY_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_C +# define BN_MP_MOD_C +# define BN_MP_MUL_C +# define BN_MP_REDUCE_2K_L_C +# define BN_MP_REDUCE_2K_SETUP_L_C +# define BN_MP_REDUCE_C +# define BN_MP_REDUCE_SETUP_C +# define BN_MP_SET_C +# define BN_MP_SQR_C +#endif + +#if defined(BN_S_MP_EXPTMOD_FAST_C) +# define BN_MP_CLEAR_C +# define BN_MP_COPY_C +# define BN_MP_COUNT_BITS_C +# define BN_MP_DR_REDUCE_C +# define BN_MP_DR_SETUP_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_MOD_C +# define BN_MP_MONTGOMERY_CALC_NORMALIZATION_C +# define BN_MP_MONTGOMERY_REDUCE_C +# define BN_MP_MONTGOMERY_SETUP_C +# define BN_MP_MULMOD_C +# define BN_MP_MUL_C +# define BN_MP_REDUCE_2K_C +# define BN_MP_REDUCE_2K_SETUP_C +# define BN_MP_SET_C +# define BN_MP_SQR_C +# define BN_S_MP_MONTGOMERY_REDUCE_FAST_C +#endif + +#if defined(BN_S_MP_GET_BIT_C) +#endif + +#if defined(BN_S_MP_INVMOD_FAST_C) +# define BN_MP_ADD_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_CMP_MAG_C +# define BN_MP_COPY_C +# define BN_MP_DIV_2_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_MOD_C +# define BN_MP_SET_C +# define BN_MP_SUB_C +#endif + +#if defined(BN_S_MP_INVMOD_SLOW_C) +# define BN_MP_ADD_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_CMP_C +# define BN_MP_CMP_D_C +# define BN_MP_CMP_MAG_C +# define BN_MP_COPY_C +# define BN_MP_DIV_2_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_MOD_C +# define BN_MP_SET_C +# define BN_MP_SUB_C +#endif + +#if defined(BN_S_MP_KARATSUBA_MUL_C) +# define BN_MP_ADD_C +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_LSHD_C +# define BN_MP_MUL_C +# define BN_S_MP_ADD_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_S_MP_KARATSUBA_SQR_C) +# define BN_MP_ADD_C +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_LSHD_C +# define BN_MP_SQR_C +# define BN_S_MP_ADD_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_S_MP_MONTGOMERY_REDUCE_FAST_C) +# define BN_MP_CLAMP_C +# define BN_MP_CMP_MAG_C +# define BN_MP_GROW_C +# define BN_S_MP_SUB_C +#endif + +#if defined(BN_S_MP_MUL_DIGS_C) +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_SIZE_C +# define BN_S_MP_MUL_DIGS_FAST_C +#endif + +#if defined(BN_S_MP_MUL_DIGS_FAST_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_S_MP_MUL_HIGH_DIGS_C) +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_SIZE_C +# define BN_S_MP_MUL_HIGH_DIGS_FAST_C +#endif + +#if defined(BN_S_MP_MUL_HIGH_DIGS_FAST_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_S_MP_PRIME_IS_DIVISIBLE_C) +# define BN_MP_MOD_D_C +#endif + +#if defined(BN_S_MP_RAND_JENKINS_C) +# define BN_S_MP_RAND_JENKINS_INIT_C +#endif + +#if defined(BN_S_MP_RAND_PLATFORM_C) +#endif + +#if defined(BN_S_MP_REVERSE_C) +#endif + +#if defined(BN_S_MP_SQR_C) +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_EXCH_C +# define BN_MP_INIT_SIZE_C +#endif + +#if defined(BN_S_MP_SQR_FAST_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_S_MP_SUB_C) +# define BN_MP_CLAMP_C +# define BN_MP_GROW_C +#endif + +#if defined(BN_S_MP_TOOM_MUL_C) +# define BN_MP_ADD_C +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_CLEAR_MULTI_C +# define BN_MP_DIV_2_C +# define BN_MP_DIV_3_C +# define BN_MP_INIT_MULTI_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_LSHD_C +# define BN_MP_MUL_2_C +# define BN_MP_MUL_C +# define BN_MP_SUB_C +#endif + +#if defined(BN_S_MP_TOOM_SQR_C) +# define BN_MP_ADD_C +# define BN_MP_CLAMP_C +# define BN_MP_CLEAR_C +# define BN_MP_DIV_2_C +# define BN_MP_INIT_C +# define BN_MP_INIT_SIZE_C +# define BN_MP_LSHD_C +# define BN_MP_MUL_2_C +# define BN_MP_MUL_C +# define BN_MP_SQR_C +# define BN_MP_SUB_C +#endif + +#ifdef LTM_INSIDE +#undef LTM_INSIDE +#ifdef LTM3 +# define LTM_LAST +#endif + +#include "tommath_superclass.h" +#include "tommath_class.h" +#else +# define LTM_LAST +#endif diff --git a/libtom/libtommath/tommath_cutoffs.h b/libtom/libtommath/tommath_cutoffs.h new file mode 100644 index 0000000..a65a9b3 --- /dev/null +++ b/libtom/libtommath/tommath_cutoffs.h @@ -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 diff --git a/libtom/libtommath/tommath_private.h b/libtom/libtommath/tommath_private.h new file mode 100644 index 0000000..1a0096f --- /dev/null +++ b/libtom/libtommath/tommath_private.h @@ -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 +# 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 +# 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 diff --git a/libtom/libtommath/tommath_superclass.h b/libtom/libtommath/tommath_superclass.h new file mode 100644 index 0000000..d88bce9 --- /dev/null +++ b/libtom/libtommath/tommath_superclass.h @@ -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 diff --git a/ultimateteknotool.v2.sln b/ultimateteknotool.v2.sln new file mode 100644 index 0000000..1d8f8e4 --- /dev/null +++ b/ultimateteknotool.v2.sln @@ -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 diff --git a/ultimateteknotool.v2/CWinAPIFileW.cpp b/ultimateteknotool.v2/CWinAPIFileW.cpp new file mode 100644 index 0000000..a71ec19 --- /dev/null +++ b/ultimateteknotool.v2/CWinAPIFileW.cpp @@ -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); + } +} diff --git a/ultimateteknotool.v2/CWinAPIFileW.h b/ultimateteknotool.v2/CWinAPIFileW.h new file mode 100644 index 0000000..b891c1c --- /dev/null +++ b/ultimateteknotool.v2/CWinAPIFileW.h @@ -0,0 +1,24 @@ +#pragma once +#include +#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(); +}; + diff --git a/ultimateteknotool.v2/CWindowCfgReader.cpp b/ultimateteknotool.v2/CWindowCfgReader.cpp new file mode 100644 index 0000000..c6907e8 --- /dev/null +++ b/ultimateteknotool.v2/CWindowCfgReader.cpp @@ -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(win, pp)); + } +} + +void CWindowPostLoadStrings::LoadTextInEdits() +{ + for (auto& x : this->pairs) + { + CWindowTextWriter_WriteText(x.first, x.second); + } +} + diff --git a/ultimateteknotool.v2/CWindowCfgReader.h b/ultimateteknotool.v2/CWindowCfgReader.h new file mode 100644 index 0000000..fd20040 --- /dev/null +++ b/ultimateteknotool.v2/CWindowCfgReader.h @@ -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 wchart_buffer; + std::vector> 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; + } +}; diff --git a/ultimateteknotool.v2/CWindowCfgWriter.cpp b/ultimateteknotool.v2/CWindowCfgWriter.cpp new file mode 100644 index 0000000..830e92e --- /dev/null +++ b/ultimateteknotool.v2/CWindowCfgWriter.cpp @@ -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); +} diff --git a/ultimateteknotool.v2/CWindowCfgWriter.h b/ultimateteknotool.v2/CWindowCfgWriter.h new file mode 100644 index 0000000..7a3f55c --- /dev/null +++ b/ultimateteknotool.v2/CWindowCfgWriter.h @@ -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); + diff --git a/ultimateteknotool.v2/CWindowFileW.cpp b/ultimateteknotool.v2/CWindowFileW.cpp new file mode 100644 index 0000000..9673d24 --- /dev/null +++ b/ultimateteknotool.v2/CWindowFileW.cpp @@ -0,0 +1,2 @@ +#include "pch.h" +#include "CWinAPIFileW.h" diff --git a/ultimateteknotool.v2/CWindowTextLimiter.cpp b/ultimateteknotool.v2/CWindowTextLimiter.cpp new file mode 100644 index 0000000..1728b09 --- /dev/null +++ b/ultimateteknotool.v2/CWindowTextLimiter.cpp @@ -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); } +} diff --git a/ultimateteknotool.v2/CWindowTextLimiter.h b/ultimateteknotool.v2/CWindowTextLimiter.h new file mode 100644 index 0000000..f59d47f --- /dev/null +++ b/ultimateteknotool.v2/CWindowTextLimiter.h @@ -0,0 +1,14 @@ +#pragma once +#include +#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); + diff --git a/ultimateteknotool.v2/CWindowTextReader.cpp b/ultimateteknotool.v2/CWindowTextReader.cpp new file mode 100644 index 0000000..ce9bd7f --- /dev/null +++ b/ultimateteknotool.v2/CWindowTextReader.cpp @@ -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; +} diff --git a/ultimateteknotool.v2/CWindowTextReader.h b/ultimateteknotool.v2/CWindowTextReader.h new file mode 100644 index 0000000..3aeb21a --- /dev/null +++ b/ultimateteknotool.v2/CWindowTextReader.h @@ -0,0 +1,45 @@ +#pragma once +#include +#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); \ No newline at end of file diff --git a/ultimateteknotool.v2/CWindowTextWriter.cpp b/ultimateteknotool.v2/CWindowTextWriter.cpp new file mode 100644 index 0000000..947c24a --- /dev/null +++ b/ultimateteknotool.v2/CWindowTextWriter.cpp @@ -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); + } +} diff --git a/ultimateteknotool.v2/CWindowTextWriter.h b/ultimateteknotool.v2/CWindowTextWriter.h new file mode 100644 index 0000000..9e34b6e --- /dev/null +++ b/ultimateteknotool.v2/CWindowTextWriter.h @@ -0,0 +1,20 @@ +#pragma once +#include +#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); + + diff --git a/ultimateteknotool.v2/CWindow_button.cpp b/ultimateteknotool.v2/CWindow_button.cpp new file mode 100644 index 0000000..ec7b97c --- /dev/null +++ b/ultimateteknotool.v2/CWindow_button.cpp @@ -0,0 +1,2 @@ +#include "pch.h" +#include "CWindow_button.h" diff --git a/ultimateteknotool.v2/CWindow_button.h b/ultimateteknotool.v2/CWindow_button.h new file mode 100644 index 0000000..778dc14 --- /dev/null +++ b/ultimateteknotool.v2/CWindow_button.h @@ -0,0 +1,12 @@ +#pragma once +#include "CWindow_hwnd.h" + +class CWindow_button : public CWindow_hwnd, public CWindow_abs_temp +{ +public: + DWORD id = 0; + CWindow_button() :CWindow_hwnd() { id = 0; } + ~CWindow_button() = default; + //DWORD GetID()const { return this->id; } +}; + diff --git a/ultimateteknotool.v2/CWindow_button_cfg.cpp b/ultimateteknotool.v2/CWindow_button_cfg.cpp new file mode 100644 index 0000000..27b24e6 --- /dev/null +++ b/ultimateteknotool.v2/CWindow_button_cfg.cpp @@ -0,0 +1,2 @@ +#include "pch.h" +#include "CWindow_button_cfg.h" diff --git a/ultimateteknotool.v2/CWindow_button_cfg.h b/ultimateteknotool.v2/CWindow_button_cfg.h new file mode 100644 index 0000000..f3be060 --- /dev/null +++ b/ultimateteknotool.v2/CWindow_button_cfg.h @@ -0,0 +1,15 @@ +#pragma once +#include "CWindow_hwnd.h" + +class CWindow_button_cfg : public CWindow_hwnd, public CWindow_abs_temp +{ +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; } +}; + diff --git a/ultimateteknotool.v2/CWindow_edit.cpp b/ultimateteknotool.v2/CWindow_edit.cpp new file mode 100644 index 0000000..ca38fc6 --- /dev/null +++ b/ultimateteknotool.v2/CWindow_edit.cpp @@ -0,0 +1,2 @@ +#include "pch.h" +#include "CWindow_edit.h" diff --git a/ultimateteknotool.v2/CWindow_edit.h b/ultimateteknotool.v2/CWindow_edit.h new file mode 100644 index 0000000..038ec8d --- /dev/null +++ b/ultimateteknotool.v2/CWindow_edit.h @@ -0,0 +1,12 @@ +#pragma once +#include "CWindow_hwnd.h" + +class CWindow_edit : public CWindow_hwnd, public CWindow_abs_temp +{ +private: + +public: + CWindow_edit():CWindow_hwnd(){} + ~CWindow_edit() = default; +}; + diff --git a/ultimateteknotool.v2/CWindow_edit_cfg.cpp b/ultimateteknotool.v2/CWindow_edit_cfg.cpp new file mode 100644 index 0000000..68487e8 --- /dev/null +++ b/ultimateteknotool.v2/CWindow_edit_cfg.cpp @@ -0,0 +1,2 @@ +#include "pch.h" +#include "CWindow_edit_cfg.h" diff --git a/ultimateteknotool.v2/CWindow_edit_cfg.h b/ultimateteknotool.v2/CWindow_edit_cfg.h new file mode 100644 index 0000000..0ad0462 --- /dev/null +++ b/ultimateteknotool.v2/CWindow_edit_cfg.h @@ -0,0 +1,12 @@ +#pragma once +#include "CWindow_hwnd.h" + +class CWindow_edit_cfg : public CWindow_hwnd, public CWindow_abs_temp +{ +private: + +public: + CWindow_edit_cfg() :CWindow_hwnd() {} + ~CWindow_edit_cfg() = default; +}; + diff --git a/ultimateteknotool.v2/CWindow_hwnd.h b/ultimateteknotool.v2/CWindow_hwnd.h new file mode 100644 index 0000000..a576210 --- /dev/null +++ b/ultimateteknotool.v2/CWindow_hwnd.h @@ -0,0 +1,36 @@ +#pragma once +#include +#include "WindowsVisitor.h" +//struct WindowsVisitor; + +class CWindow_abs +{ +public: + virtual void Visit(WindowsVisitor* v) = 0; + virtual ~CWindow_abs() = default; +}; + +template +class CWindow_abs_temp : public CWindow_abs +{ +public: + CWindow_abs_temp() {} + void Visit(WindowsVisitor* v) override + { + v->Visit(static_cast(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); } +}; + diff --git a/ultimateteknotool.v2/CWindow_static.cpp b/ultimateteknotool.v2/CWindow_static.cpp new file mode 100644 index 0000000..a67b24a --- /dev/null +++ b/ultimateteknotool.v2/CWindow_static.cpp @@ -0,0 +1,2 @@ +#include "pch.h" +#include "CWindow_static.h" diff --git a/ultimateteknotool.v2/CWindow_static.h b/ultimateteknotool.v2/CWindow_static.h new file mode 100644 index 0000000..19fe850 --- /dev/null +++ b/ultimateteknotool.v2/CWindow_static.h @@ -0,0 +1,10 @@ +#pragma once +#include "CWindow_hwnd.h" + +class CWindow_static : public CWindow_hwnd , public CWindow_abs_temp +{ +public: + CWindow_static():CWindow_hwnd(){} + ~CWindow_static() = default; +}; + diff --git a/ultimateteknotool.v2/CWindowsBuilder.h b/ultimateteknotool.v2/CWindowsBuilder.h new file mode 100644 index 0000000..59f22fe --- /dev/null +++ b/ultimateteknotool.v2/CWindowsBuilder.h @@ -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); + } +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/CWindowsFontApplier.cpp b/ultimateteknotool.v2/CWindowsFontApplier.cpp new file mode 100644 index 0000000..3254018 --- /dev/null +++ b/ultimateteknotool.v2/CWindowsFontApplier.cpp @@ -0,0 +1,2 @@ +#include "pch.h" +#include "CWindowsFontApplier.h" diff --git a/ultimateteknotool.v2/CWindowsFontApplier.h b/ultimateteknotool.v2/CWindowsFontApplier.h new file mode 100644 index 0000000..f5e8421 --- /dev/null +++ b/ultimateteknotool.v2/CWindowsFontApplier.h @@ -0,0 +1,38 @@ +#pragma once +#include +#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); } + } +}; + diff --git a/ultimateteknotool.v2/HFont_Wrapper.cpp b/ultimateteknotool.v2/HFont_Wrapper.cpp new file mode 100644 index 0000000..2ae5754 --- /dev/null +++ b/ultimateteknotool.v2/HFont_Wrapper.cpp @@ -0,0 +1,2 @@ +#include "pch.h" +#include "HFont_Wrapper.h" diff --git a/ultimateteknotool.v2/HFont_Wrapper.h b/ultimateteknotool.v2/HFont_Wrapper.h new file mode 100644 index 0000000..4168f24 --- /dev/null +++ b/ultimateteknotool.v2/HFont_Wrapper.h @@ -0,0 +1,16 @@ +#pragma once +#include +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); + } +}; + diff --git a/ultimateteknotool.v2/Hooker_JMP.cpp b/ultimateteknotool.v2/Hooker_JMP.cpp new file mode 100644 index 0000000..1133018 --- /dev/null +++ b/ultimateteknotool.v2/Hooker_JMP.cpp @@ -0,0 +1,82 @@ +#include "pch.h" +#include +#include +#include "Hooker_JMP.h" + + +struct MallocNoob +{ + std::vector holders; + MallocNoob() + { + + } + unsigned char* doalloc(const size_t sz) + { + void* retard = 0; + retard = ::malloc(sz); + holders.push_back(retard); + return static_cast(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((addr + 1))) + (reinterpret_cast(addr)) + 5; + newjump = (jumpto - reinterpret_cast(jmp + 5)); + jmp[0] = 0xE9; + *reinterpret_cast((jmp + 1)) = newjump; + jmp += 5; + jmp[0] = 0xE9; + *(reinterpret_cast((jmp + 1))) = reinterpret_cast(reinterpret_cast((addr - jmp))); + } + else + { + jmp = allocer.doalloc(5+len); + if (jmp == 0) { return nullptr; } + ::memcpy(jmp, addr, len); + jmp += len; + jmp[0] = 0xE9; + *reinterpret_cast((jmp + 1)) = reinterpret_cast(reinterpret_cast(addr + len - jmp)) - 5; + } + addr[0] = 0xE9; + *reinterpret_cast((addr + 1)) = reinterpret_cast(reinterpret_cast(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) + diff --git a/ultimateteknotool.v2/Hooker_JMP.h b/ultimateteknotool.v2/Hooker_JMP.h new file mode 100644 index 0000000..3d38f0b --- /dev/null +++ b/ultimateteknotool.v2/Hooker_JMP.h @@ -0,0 +1,25 @@ +#pragma once +#include "stdint.h" +#include "debugconsole.h" +#include +#include +#include "SystemFunctionXRefRemover.h" + +namespace Hooker_JMP +{ + + void* __Hook32_internal__NativeHook(uint8_t* addr, uint8_t* hook, uint8_t len); + + template + bool Hook32(uint32_t addr, HookType& hook, uint8_t asm_length_of_original_code, FunctionType& original_call) + { + original_call = nullptr; + original_call = reinterpret_cast( + __Hook32_internal__NativeHook(reinterpret_cast(addr), reinterpret_cast(hook), asm_length_of_original_code) + ); + + return original_call != nullptr; + } + + +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/HooksAfterResumingThreads.cpp b/ultimateteknotool.v2/HooksAfterResumingThreads.cpp new file mode 100644 index 0000000..75dc62f --- /dev/null +++ b/ultimateteknotool.v2/HooksAfterResumingThreads.cpp @@ -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; +} diff --git a/ultimateteknotool.v2/HooksAfterResumingThreads.h b/ultimateteknotool.v2/HooksAfterResumingThreads.h new file mode 100644 index 0000000..3969269 --- /dev/null +++ b/ultimateteknotool.v2/HooksAfterResumingThreads.h @@ -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(); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/HooksOnThreadsStart.cpp b/ultimateteknotool.v2/HooksOnThreadsStart.cpp new file mode 100644 index 0000000..ad1e328 --- /dev/null +++ b/ultimateteknotool.v2/HooksOnThreadsStart.cpp @@ -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; +} diff --git a/ultimateteknotool.v2/HooksOnThreadsStart.h b/ultimateteknotool.v2/HooksOnThreadsStart.h new file mode 100644 index 0000000..0fe707e --- /dev/null +++ b/ultimateteknotool.v2/HooksOnThreadsStart.h @@ -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(); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/Injector.cpp b/ultimateteknotool.v2/Injector.cpp new file mode 100644 index 0000000..909909f --- /dev/null +++ b/ultimateteknotool.v2/Injector.cpp @@ -0,0 +1,126 @@ +#include "pch.h" +#include "Injector.h" + + std::unique_ptr 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; + } diff --git a/ultimateteknotool.v2/Injector.h b/ultimateteknotool.v2/Injector.h new file mode 100644 index 0000000..04f55da --- /dev/null +++ b/ultimateteknotool.v2/Injector.h @@ -0,0 +1,28 @@ +#pragma once +//#include +#include +#include +#include + +// must be singleton +class Injector +{ +private: + static std::unique_ptr 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); +}; + diff --git a/ultimateteknotool.v2/JMPHook_SerializeNetdata.cpp b/ultimateteknotool.v2/JMPHook_SerializeNetdata.cpp new file mode 100644 index 0000000..8063ae3 --- /dev/null +++ b/ultimateteknotool.v2/JMPHook_SerializeNetdata.cpp @@ -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( + 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; +} + diff --git a/ultimateteknotool.v2/JMPHook_SerializeNetdata.h b/ultimateteknotool.v2/JMPHook_SerializeNetdata.h new file mode 100644 index 0000000..755e715 --- /dev/null +++ b/ultimateteknotool.v2/JMPHook_SerializeNetdata.h @@ -0,0 +1,30 @@ +#pragma once +#include +#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(); + }; +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/JMPHook_bdDTLSAssociation_functions.cpp b/ultimateteknotool.v2/JMPHook_bdDTLSAssociation_functions.cpp new file mode 100644 index 0000000..66b9650 --- /dev/null +++ b/ultimateteknotool.v2/JMPHook_bdDTLSAssociation_functions.cpp @@ -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( + 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; +} \ No newline at end of file diff --git a/ultimateteknotool.v2/JMPHook_bdDTLSAssociation_functions.h b/ultimateteknotool.v2/JMPHook_bdDTLSAssociation_functions.h new file mode 100644 index 0000000..26e6527 --- /dev/null +++ b/ultimateteknotool.v2/JMPHook_bdDTLSAssociation_functions.h @@ -0,0 +1,12 @@ +#pragma once +#include +#include "Hooker_JMP.h" +#include "windows_accountpage.h" + +namespace hooks +{ + namespace bdDTLSAssociation_functions + { + bool JMPHook_sendInit(uint32_t addr, uint8_t asmlen); + }; +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/JMPHook_bdUPnP_functions.cpp b/ultimateteknotool.v2/JMPHook_bdUPnP_functions.cpp new file mode 100644 index 0000000..0308638 --- /dev/null +++ b/ultimateteknotool.v2/JMPHook_bdUPnP_functions.cpp @@ -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 + 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 Fieldlocation; + static Fieldserver; + static FieldUSN; + + static uint8_t* stat_relative = nullptr; + uint8_t* GetFirstRightEntry() + { + return stat_relative; + } + + + + }; + }; +}; + +static CONSTEXPRENCRYPTSTRW(Error_UPnPSpoofFailed, L"UPnP spoof failed", 0x31F1); +#define MACRO_Error_UPnPSpoofFailed DECRYPTCONSTENCSTRW(Error_UPnPSpoofFailed, sizeof(L"UPnP spoof failed") / sizeof(wchar_t), 0x31F1) + +bool hooks::bdUPnP_functions::JMPHook_extractDeviceInfo(uint32_t addr, uint8_t asmlen) +{ + return Hooker_JMP::Hook32( + 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* 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 \ No newline at end of file diff --git a/ultimateteknotool.v2/JMPHook_bdUPnP_functions.h b/ultimateteknotool.v2/JMPHook_bdUPnP_functions.h new file mode 100644 index 0000000..6e9adbb --- /dev/null +++ b/ultimateteknotool.v2/JMPHook_bdUPnP_functions.h @@ -0,0 +1,27 @@ +#pragma once +#include +#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(); + }; + + }; +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/JMPHook_iphlpapi_functions.cpp b/ultimateteknotool.v2/JMPHook_iphlpapi_functions.cpp new file mode 100644 index 0000000..fa62337 --- /dev/null +++ b/ultimateteknotool.v2/JMPHook_iphlpapi_functions.cpp @@ -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( + addr, + Hook_GetInterfaceInfo, + asmlen, + OriginalFunc + ); +} diff --git a/ultimateteknotool.v2/JMPHook_iphlpapi_functions.h b/ultimateteknotool.v2/JMPHook_iphlpapi_functions.h new file mode 100644 index 0000000..4d4296b --- /dev/null +++ b/ultimateteknotool.v2/JMPHook_iphlpapi_functions.h @@ -0,0 +1,14 @@ +#pragma once +#include +#include "Hooker_JMP.h" +#include +#pragma comment(lib, "iphlpapi.lib") +#include "debugconsole.h" + +namespace hooks +{ + namespace iphlpapi_functions + { + bool JMPHook_GetInterfaceInfo(uint32_t addr, uint8_t asmlen); + }; +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/JMPHook_sysinfoapi_functions.cpp b/ultimateteknotool.v2/JMPHook_sysinfoapi_functions.cpp new file mode 100644 index 0000000..347eb65 --- /dev/null +++ b/ultimateteknotool.v2/JMPHook_sysinfoapi_functions.cpp @@ -0,0 +1,333 @@ +#include "pch.h" +#include "JMPHook_sysinfoapi_functions.h" +#include "windows_accountpage.h" +#include "Randomizer.h" +#include + +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 + 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( + 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(pFirmwareTableBuffer); + const LPBYTE pEOFData = static_cast(pFirmwareTableBuffer) + pDMIData->Length; + PSMBIOSHEADER pHeader = reinterpret_cast(&(pDMIData->SMBIOSTableData)); + LPBYTE pCurrentData = reinterpret_cast(&(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; + } +} + diff --git a/ultimateteknotool.v2/JMPHook_sysinfoapi_functions.h b/ultimateteknotool.v2/JMPHook_sysinfoapi_functions.h new file mode 100644 index 0000000..8088ced --- /dev/null +++ b/ultimateteknotool.v2/JMPHook_sysinfoapi_functions.h @@ -0,0 +1,16 @@ +#pragma once +#include +#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); + }; +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/JMP_iw5mp_functions.cpp b/ultimateteknotool.v2/JMP_iw5mp_functions.cpp new file mode 100644 index 0000000..5dc9210 --- /dev/null +++ b/ultimateteknotool.v2/JMP_iw5mp_functions.cpp @@ -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( + 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; +} + + diff --git a/ultimateteknotool.v2/JMP_iw5mp_functions.h b/ultimateteknotool.v2/JMP_iw5mp_functions.h new file mode 100644 index 0000000..7f585a0 --- /dev/null +++ b/ultimateteknotool.v2/JMP_iw5mp_functions.h @@ -0,0 +1,23 @@ +#pragma once +#include +#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; + }; + }; +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/LazyBuffer.cpp b/ultimateteknotool.v2/LazyBuffer.cpp new file mode 100644 index 0000000..eb10a05 --- /dev/null +++ b/ultimateteknotool.v2/LazyBuffer.cpp @@ -0,0 +1,2 @@ +#include "pch.h" +#include "LazyBuffer.h" diff --git a/ultimateteknotool.v2/LazyBuffer.h b/ultimateteknotool.v2/LazyBuffer.h new file mode 100644 index 0000000..f18e468 --- /dev/null +++ b/ultimateteknotool.v2/LazyBuffer.h @@ -0,0 +1,279 @@ +#pragma once +#include +#include "debugconsole.h" +#include "DRM/DRM_DllUnloadThread.h" + +template +class LazyBuffer +{ +private: + std::vector 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 +using LazyBuffer_wchart = LazyBuffer; + +template +using LazyBuffer_char = LazyBuffer; + +template +class LazySectionBuffer +{ +private: + std::vector 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 +using LazySectionBuffer_wchart = LazySectionBuffer; + +template +using LazySectionBuffer_char = LazySectionBuffer; \ No newline at end of file diff --git a/ultimateteknotool.v2/LazyBuffer_512wchart.cpp b/ultimateteknotool.v2/LazyBuffer_512wchart.cpp new file mode 100644 index 0000000..ca6e335 --- /dev/null +++ b/ultimateteknotool.v2/LazyBuffer_512wchart.cpp @@ -0,0 +1,5 @@ +#include "pch.h" +#include "LazyBuffer_512wchart.h" + +//LazyBuffer_wchart<512>lazybuffer512wchart; +LazySectionBuffer_wchart<512, 3> lazysectionbuffer_3x512; diff --git a/ultimateteknotool.v2/LazyBuffer_512wchart.h b/ultimateteknotool.v2/LazyBuffer_512wchart.h new file mode 100644 index 0000000..e1364ea --- /dev/null +++ b/ultimateteknotool.v2/LazyBuffer_512wchart.h @@ -0,0 +1,5 @@ +#pragma once +#include "LazyBuffer.h" + +//extern LazyBuffer_wchart<512>lazybuffer512wchart; +extern LazySectionBuffer_wchart<512, 3> lazysectionbuffer_3x512; diff --git a/ultimateteknotool.v2/MainWindowSizes.cpp b/ultimateteknotool.v2/MainWindowSizes.cpp new file mode 100644 index 0000000..e0f3ef7 --- /dev/null +++ b/ultimateteknotool.v2/MainWindowSizes.cpp @@ -0,0 +1,7 @@ +#include "pch.h" + +namespace MainWindowSizes +{ + constexpr int width = 620; + constexpr int height = 450 + 6; +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/ParserRandMask.cpp b/ultimateteknotool.v2/ParserRandMask.cpp new file mode 100644 index 0000000..7def04f --- /dev/null +++ b/ultimateteknotool.v2/ParserRandMask.cpp @@ -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(RANDANSIDIGIT); + } + else if (randmask[i] == 'u') + { + output[i] = static_cast(RANDANSIUPPERCASE); + } + else if (randmask[i] == 'l') + { + output[i] = static_cast(RANDANSILOWCASE); + } + else if (randmask[i] == 'c') + { + output[i] = static_cast(RANDANSICHAR); + } + else if (randmask[i] == 'h') + { + output[i] = static_cast(RANDHEXSYMBOL); + } + else + { + output[i] = randmask[i]; + } + } +} diff --git a/ultimateteknotool.v2/ParserRandMask.h b/ultimateteknotool.v2/ParserRandMask.h new file mode 100644 index 0000000..b5f4de0 --- /dev/null +++ b/ultimateteknotool.v2/ParserRandMask.h @@ -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); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/PatternSearcher.cpp b/ultimateteknotool.v2/PatternSearcher.cpp new file mode 100644 index 0000000..3aede90 --- /dev/null +++ b/ultimateteknotool.v2/PatternSearcher.cpp @@ -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(RET) == BYTES[0].value) + { + for (verify = 1; verify < counter; verify++) + { + RET++; + if (BYTES[verify].mustbeskipped == 0x00) { + if (*reinterpret_cast(RET) != BYTES[verify].value) + { + break; + } + else + { + continue; + } + } + else + { + continue; + } + } + if (verify == counter) { + return RET - verify + 1; } + } + RET++; + } + return 0; +} diff --git a/ultimateteknotool.v2/PatternSearcher.h b/ultimateteknotool.v2/PatternSearcher.h new file mode 100644 index 0000000..1fd1ffb --- /dev/null +++ b/ultimateteknotool.v2/PatternSearcher.h @@ -0,0 +1,6 @@ +#pragma once +#include "debugconsole.h" +#include +namespace patternsearcher { + uint32_t PatternSearch(char* pattern, uint32_t start_address, uint32_t maxdeep); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/ProcessController.h b/ultimateteknotool.v2/ProcessController.h new file mode 100644 index 0000000..ca6c403 --- /dev/null +++ b/ultimateteknotool.v2/ProcessController.h @@ -0,0 +1,50 @@ +#pragma once +#include +#include + + +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); + } + } + +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/Randomizer.cpp b/ultimateteknotool.v2/Randomizer.cpp new file mode 100644 index 0000000..c47a2c1 --- /dev/null +++ b/ultimateteknotool.v2/Randomizer.cpp @@ -0,0 +1,78 @@ +#include "pch.h" +#include "Randomizer.h" + + + std::once_flag Randomizer::m_createonceflag; + std::unique_ptr Randomizer::m_pInstance; + + XORShiftSeeder Randomizer::m_xorshift; + std::uniform_int_distribution Randomizer::m_distrByte; + std::uniform_int_distribution Randomizer::m_distrByteHighBit_1; + std::uniform_int_distribution Randomizer::m_distrByteHighBit_0; + std::uniform_int_distribution Randomizer::m_ANSIdigit; + std::uniform_int_distribution Randomizer::m_ANSIuppercase; + std::uniform_int_distribution Randomizer::m_ANSIlowcase; + std::uniform_int_distribution Randomizer::m_ANSIchar; + std::uniform_int_distribution Randomizer::m_ANSIfromAtoF; + std::uniform_int_distribution 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(Randomizer::m_distrByteHighBit_0(Randomizer::m_xorshift)); + case Randomizer::FillType::_128_to_255: + return static_cast(Randomizer::m_distrByteHighBit_1(Randomizer::m_xorshift)); + case Randomizer::FillType::_0_to_255: + return static_cast(Randomizer::m_distrByte(Randomizer::m_xorshift)); + case Randomizer::FillType::ANSIchar: + return static_cast(Randomizer::m_ANSIchar(Randomizer::m_xorshift)); + case Randomizer::FillType::ANSIdigit: + return static_cast(Randomizer::m_ANSIdigit(Randomizer::m_xorshift)); + case Randomizer::FillType::ANSIlowcase: + return static_cast(Randomizer::m_ANSIlowcase(Randomizer::m_xorshift)); + case Randomizer::FillType::ANSIuppercase: + return static_cast(Randomizer::m_ANSIuppercase(Randomizer::m_xorshift)); + case Randomizer::FillType::ANSIfromAtoF: + return static_cast(Randomizer::m_ANSIfromAtoF(Randomizer::m_xorshift)); + case Randomizer::FillType::ANSIfromAtoF_lower: + return static_cast(Randomizer::m_ANSIfromAtoF_lower(Randomizer::m_xorshift)); + default: + return static_cast(Randomizer::m_distrByte(Randomizer::m_xorshift)); + } +} + + + +Randomizer::Randomizer() +{ + std::random_device randomdevice; + Randomizer::m_xorshift = XORShiftSeeder(randomdevice); + Randomizer::m_distrByte = std::uniform_int_distribution(0, 255); + Randomizer::m_distrByteHighBit_1 = std::uniform_int_distribution(128, 255); + Randomizer::m_distrByteHighBit_0 = std::uniform_int_distribution(0, 127); + Randomizer::m_ANSIdigit = std::uniform_int_distribution(48, 57); + Randomizer::m_ANSIuppercase = std::uniform_int_distribution(65, 90); + Randomizer::m_ANSIlowcase = std::uniform_int_distribution(97, 122); + Randomizer::m_ANSIchar = std::uniform_int_distribution(33, 126); + Randomizer::m_ANSIfromAtoF = std::uniform_int_distribution(65, 70); + Randomizer::m_ANSIfromAtoF_lower = std::uniform_int_distribution('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; +} diff --git a/ultimateteknotool.v2/Randomizer.h b/ultimateteknotool.v2/Randomizer.h new file mode 100644 index 0000000..b86c984 --- /dev/null +++ b/ultimateteknotool.v2/Randomizer.h @@ -0,0 +1,89 @@ +#pragma once +#include +#include +#include + +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 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 m_distrByte; + static std::uniform_int_distribution m_distrByteHighBit_1; + static std::uniform_int_distribution m_distrByteHighBit_0; + static std::uniform_int_distribution m_ANSIdigit; + static std::uniform_int_distribution m_ANSIuppercase; + static std::uniform_int_distribution m_ANSIlowcase; + static std::uniform_int_distribution m_ANSIchar; + static std::uniform_int_distribution m_ANSIfromAtoF; + static std::uniform_int_distribution 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; +}; + diff --git a/ultimateteknotool.v2/Serializers.cpp b/ultimateteknotool.v2/Serializers.cpp new file mode 100644 index 0000000..7426366 --- /dev/null +++ b/ultimateteknotool.v2/Serializers.cpp @@ -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; + } +} diff --git a/ultimateteknotool.v2/Serializers.h b/ultimateteknotool.v2/Serializers.h new file mode 100644 index 0000000..de5c2e9 --- /dev/null +++ b/ultimateteknotool.v2/Serializers.h @@ -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); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/SystemFunctionXRefRemover.h b/ultimateteknotool.v2/SystemFunctionXRefRemover.h new file mode 100644 index 0000000..38665fb --- /dev/null +++ b/ultimateteknotool.v2/SystemFunctionXRefRemover.h @@ -0,0 +1,68 @@ +#pragma once +#include +#include "debugconsole.h" + +template +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 + void AddNewFunction(void* addr, uint32_t xfake_address) + { + + _pointers[XRefRemover_FAKEADR(0)] = *reinterpret_cast(addr); + _pointers[XRefRemover_FAKEADR(1)] = reinterpret_cast(addr) ^ _pointers[0]; + _pointers[XRefRemover_FAKEADR(2)] = *(reinterpret_cast(addr) + 1); + } + template + void* GetFunction(uint32_t xfake_address) const + { + return reinterpret_cast(_pointers[XRefRemover_FAKEADR(1)] ^ _pointers[XRefRemover_FAKEADR(0)]); + } + void VerifyFunction() const + { + uint32_t addr = 0x00; + if ( + *reinterpret_cast(_pointers[1] ^ _pointers[0]) != _pointers[0] + ) + { + addr = 0x7F340000; + __asm { + jmp [addr]; + } + } + else if (*(reinterpret_cast(_pointers[1] ^ _pointers[0]) + 1) != _pointers[2]) + { + addr = 0x0010AB00; + __asm { + jmp [addr]; + } + } + else + { + + } + } + template + void* GetVerifiedFunction(uint32_t xfake_address) const + { + this->VerifyFunction(); + return this->GetFunction(xfake_address); + } + + size_t Size() const noexcept { return BFSZ; } +#undef XRefRemover_FAKEADR +#pragma optimize("" ,on) +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/TextConvertors.cpp b/ultimateteknotool.v2/TextConvertors.cpp new file mode 100644 index 0000000..a650d13 --- /dev/null +++ b/ultimateteknotool.v2/TextConvertors.cpp @@ -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(NewIP[0]) << L'.' << + static_cast(NewIP[1]) << L'.' << + static_cast(NewIP[2]) << L'.' << + static_cast(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(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(' ')); i++) + { + diesoon[i] = static_cast(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(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(LazyC256.GetNulledMem(sz + 2)); + const uint8_t* txtp = reinterpret_cast(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(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(NewIP[0]) << L'.' << + static_cast(NewIP[1]) << L'.' << + static_cast(NewIP[2]) << L'.' << + static_cast(NewIP[3]); + aaaaaa = outputWstringstream.str(); + return aaaaaa; +} diff --git a/ultimateteknotool.v2/TextConvertors.h b/ultimateteknotool.v2/TextConvertors.h new file mode 100644 index 0000000..8290d81 --- /dev/null +++ b/ultimateteknotool.v2/TextConvertors.h @@ -0,0 +1,37 @@ +#pragma once +#include +#include +#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]); + }; +}; + diff --git a/ultimateteknotool.v2/TheWinMain.cpp b/ultimateteknotool.v2/TheWinMain.cpp new file mode 100644 index 0000000..b1ee27b --- /dev/null +++ b/ultimateteknotool.v2/TheWinMain.cpp @@ -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; +} diff --git a/ultimateteknotool.v2/TheWinMain.h b/ultimateteknotool.v2/TheWinMain.h new file mode 100644 index 0000000..29673d3 --- /dev/null +++ b/ultimateteknotool.v2/TheWinMain.h @@ -0,0 +1,9 @@ +#pragma once +#include +#include + +namespace windowsMain +{ + constexpr wchar_t classname[] = L"iw5mpx"; + bool WinStart(); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/TomLibKeyGen.cpp b/ultimateteknotool.v2/TomLibKeyGen.cpp new file mode 100644 index 0000000..afa8ae2 --- /dev/null +++ b/ultimateteknotool.v2/TomLibKeyGen.cpp @@ -0,0 +1,108 @@ +#include "pch.h" +#include "TomLibKeyGen.h" + +std::once_flag TomLibKeyGen::m_createonceflag; +std::unique_ptr TomLibKeyGen::m_pInstance; +bool TomLibKeyGen::m_boolPRGNisReady; + prng_state TomLibKeyGen::m_prng_yarrow; + + bool TomLibKeyGen::m_boolECCKEYisReady; + ::ecc_key TomLibKeyGen::m_ECCKey; +static_assert(sizeof(prng_state) > 10000, "we have to allocate prng somewhere"); + +void TomLibKeyGen::PreparePRGN() +{ + m_boolPRGNisReady = false; + if (::register_prng(&::yarrow_desc) == -1) + { + WCWOUT("error/libtomcrypt/::register_prng failed register yarrow description"); + return; + } + constexpr uint8_t YABUFSIZE = 128; + int error = 0; + unsigned char yaBuffer[YABUFSIZE]; + for (uint8_t i = 0; i < YABUFSIZE; i++) + { + yaBuffer[i] = RANDBYTE; + } + if (error = ::yarrow_start(&this->m_prng_yarrow) != CRYPT_OK) + { + WCWOUT("error/libtomcrypt/::yarrow_start failed. Error description: ", ::error_to_string(error)); + return; + } + if (error = ::yarrow_add_entropy(yaBuffer, YABUFSIZE, &this->m_prng_yarrow) != CRYPT_OK) + { + WCWOUT("error/libtomcrypt/::yarrow_add_entropy failed. Error description: ", ::error_to_string(error)); + return; + } + if (error = ::yarrow_ready(&this->m_prng_yarrow) != CRYPT_OK) + { + WCWOUT("error/libtomcrypt/::yarrow_ready failed. Error description: ", ::error_to_string(error)); + return; + } + m_boolPRGNisReady = true; +} + +TomLibKeyGen::~TomLibKeyGen() +{ + if (this->m_boolECCKEYisReady) + { + ::ecc_free(&(this->m_ECCKey)); + } +} + +TomLibKeyGen::TomLibKeyGen() +{ + /* libtom fix */ + ltc_mp = ltm_desc; + /* libtom fix */ +} + +TomLibKeyGen& TomLibKeyGen::GetT0mLibKeyGen() +{ + std::call_once(TomLibKeyGen::m_createonceflag, [] { + TomLibKeyGen::m_pInstance.reset(new TomLibKeyGen); + }); + return *TomLibKeyGen::m_pInstance.get(); +} + +void TomLibKeyGen::ECC_GetExportKey(unsigned char* outbuffer, unsigned char sz) +{ + if (sz < 100) { throw 0xDEAD; } + if (this->ECC_GenerateKey()) + { + unsigned long outlen = 100; + unsigned char outbuf[100]; + ::ecc_export(outbuf, &outlen, PK_PUBLIC, &(this->m_ECCKey)); + if (outlen < 100) + { + memset(&outbuf[outlen], 0, 100 - outlen); + } + memcpy(outbuffer, outbuf, 100); + } +} + + +bool TomLibKeyGen::ECC_GenerateKey() +{ + int error = 0; + if (this->m_boolECCKEYisReady) + { + ::ecc_free(&(this->m_ECCKey)); + } + if (this->m_boolPRGNisReady == false) + { + this->PreparePRGN(); + } + if (error = ::ecc_make_key(&this->m_prng_yarrow, ::find_prng("yarrow"), 28, &(this->m_ECCKey)) != CRYPT_OK) + { + WCWOUT("error/libtomcrypt/::ecc_make_key. Error description: ", ::error_to_string(error)); + this->m_boolECCKEYisReady = false; + return false; + } + else + { + this->m_boolECCKEYisReady = true; + return true; + } +} diff --git a/ultimateteknotool.v2/TomLibKeyGen.h b/ultimateteknotool.v2/TomLibKeyGen.h new file mode 100644 index 0000000..a6d5f38 --- /dev/null +++ b/ultimateteknotool.v2/TomLibKeyGen.h @@ -0,0 +1,34 @@ +#pragma once +#include +#include +#include +#include +#pragma comment (lib, "tommath.lib") +#pragma comment (lib, "tomcrypt.lib") +#include "Randomizer.h" +#include "debugconsole.h" + +class TomLibKeyGen +{ +private: + TomLibKeyGen(); + static std::once_flag m_createonceflag; + static std::unique_ptr m_pInstance; + TomLibKeyGen(const TomLibKeyGen&) = delete; + TomLibKeyGen(TomLibKeyGen&&) = delete; + TomLibKeyGen& operator=(const TomLibKeyGen&) = delete; + TomLibKeyGen& operator=(TomLibKeyGen&&) = delete; + + void PreparePRGN(); + static bool m_boolPRGNisReady; + static prng_state m_prng_yarrow; + + bool ECC_GenerateKey(); + static bool m_boolECCKEYisReady; + static ::ecc_key m_ECCKey; +public: + ~TomLibKeyGen(); + static TomLibKeyGen& GetT0mLibKeyGen(); + + void ECC_GetExportKey(unsigned char* outbuffer, unsigned char sz); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/WSAController.cpp b/ultimateteknotool.v2/WSAController.cpp new file mode 100644 index 0000000..bb34b18 --- /dev/null +++ b/ultimateteknotool.v2/WSAController.cpp @@ -0,0 +1,46 @@ +#include "pch.h" +#include "WSAController.h" +std::once_flag WSAController::m_createonceflag; +std::unique_ptr WSAController::m_pInstance; +WSADATA WSAController::wsa_data; +bool WSAController::isValid; + +WSAController::WSAController() +{ + this->isValid = false; + this->wsa_data.wVersion = 0; + int error = 0; + error = WSAStartup(MAKEWORD(2, 2), &wsa_data); + if (error) + { + this->isValid = false; + } + else + { + if (LOBYTE(this->wsa_data.wVersion) != 2 || HIBYTE(this->wsa_data.wVersion) != 2) + { + this->isValid = false; + } + this->isValid = true; + } +} + +WSAController::~WSAController() +{ + if (LOBYTE(this->wsa_data.wVersion) != 2 || HIBYTE(this->wsa_data.wVersion) != 2) { + ::WSACleanup(); + } +} + +WSAController& WSAController::WSAC0ntroller() +{ + std::call_once(WSAController::m_createonceflag, [] { + WSAController::m_pInstance.reset(new WSAController); + }); + return *WSAController::m_pInstance.get(); +} + +bool WSAController::IsValid() +{ + return this->isValid; +} diff --git a/ultimateteknotool.v2/WSAController.h b/ultimateteknotool.v2/WSAController.h new file mode 100644 index 0000000..1dd5bf5 --- /dev/null +++ b/ultimateteknotool.v2/WSAController.h @@ -0,0 +1,27 @@ +#pragma once +#include +#include +#include +#include +#include +#include +#pragma comment (lib, "Ws2_32.lib") + +class WSAController +{ +private: + WSAController(); + static std::once_flag m_createonceflag; + static std::unique_ptr m_pInstance; + WSAController(const WSAController&) = delete; + WSAController(WSAController&&) = delete; + WSAController& operator=(const WSAController&) = delete; + WSAController& operator=(WSAController&&) = delete; + static WSADATA wsa_data; + static bool isValid; +public: + ~WSAController(); + static WSAController& WSAC0ntroller(); + bool IsValid(); +}; + diff --git a/ultimateteknotool.v2/WinMainProc.cpp b/ultimateteknotool.v2/WinMainProc.cpp new file mode 100644 index 0000000..a134511 --- /dev/null +++ b/ultimateteknotool.v2/WinMainProc.cpp @@ -0,0 +1,167 @@ +#include "pch.h" +#include "constexprcolorcodes.h" +#include "WinMainProc.h" +#include "CWindowsBuilder.h" +#include "CWindowsFontApplier.h" +#include "CWindowTextWriter.h" +#include "MainWindowSizes.cpp" +#include "windows_maincontrolbuttons.h" +#include "windows_accountpage.h" +#include "windows_cfgbuttons.h" +#include "windows_injectorpage.h" +#include "cfg_functions.h" +#include "HFont_Wrapper.h" +#include "LazyBuffer_512wchart.h" +#include "PatternSearcher.h" +#include "windows_playerspage.h" +#include "windows_quickbuttons.h" + + +static HFont_Wrapper hFontWrap; +static HDC HDeviceC; +static PAINTSTRUCT PaintStruct = { 0 }; +static constexpr int mainbuttonbackgroundtopoffset = 5; +static constexpr int mainbuttonbackgroundheight = 30; +static DWORD dynamic_background_color = constexprcolorcodes::Color_00DDDAFA; +static bool WindowAreInitedAndReadyToDispatchWMCOMMANDs = false; + + + +LRESULT CALLBACK windowsMain::MainWinProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) +{ + switch (msg) + { + case WM_CREATE: + { + WindowAreInitedAndReadyToDispatchWMCOMMANDs = false; + hFontWrap.HFONT_Wrap(CreateFontW(((int)(-11)), 0, 0, 0, + FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, + 0x31u, L"Courier New")); + RECT rect = { 0 }; + ::GetClientRect(hwnd, &rect); + CWindowsBuilder BUILDER; + CWindowsFontApplier FONTAPPLER(hFontWrap); + /* + give free box for building, don't build windows with negative offsets? + */ + windows_maincontrolbuttons::Build(BUILDER, 5, MainWindowSizes::width, mainbuttonbackgroundtopoffset, MainWindowSizes::height, hwnd); + windows_maincontrolbuttons::ApplyFonts(FONTAPPLER); + windows_maincontrolbuttons::Show(); + + int gap = 2; + int freewidth = rect.right / 10; + int leftpos = rect.right - freewidth * 3 ; + + int freeheight = rect.bottom / 18; + int toppos = rect.bottom - freeheight; + + windows_quickbuttons::Build(BUILDER, leftpos, freewidth, toppos, freeheight, gap, hwnd); + windows_quickbuttons::ApplyFonts(FONTAPPLER); + windows_quickbuttons::Show(); + leftpos += freewidth; + freewidth = freewidth + freewidth - freewidth / 5; + windows_cfgbuttons::Build(BUILDER, leftpos, freewidth, toppos, freeheight, gap, hwnd); + windows_cfgbuttons::ApplyFonts(FONTAPPLER); + windows_cfgbuttons::Show(); + + + + windows_accountpage::Build(BUILDER, 8, MainWindowSizes::width, mainbuttonbackgroundheight + 5, MainWindowSizes::height, hwnd); + windows_accountpage::ApplyFonts(FONTAPPLER); + windows_accountpage::ApplyTextLimits(); + windows_accountpage::Show(); + + windows_injectorpage::Build(BUILDER, 8, rect.right, mainbuttonbackgroundheight + 5, rect.bottom, hwnd); + windows_injectorpage::ApplyFonts(FONTAPPLER); + windows_injectorpage::Hide(); + + windows_playerspage::Build(BUILDER, 8, rect.right, mainbuttonbackgroundheight + 5, rect.bottom, hwnd); + windows_playerspage::ApplyFonts(FONTAPPLER); + windows_playerspage::ApplyTextLimits(); + windows_playerspage::Hide(); + + cfg_functions::LoadDefaultOrExistingCfg(); + +#ifdef UTT2_DEBUG + LazySectionBuffer SectionBuffer; + if (SectionBuffer.Test1()) { + LazySectionBuffer SectionBuffer2; + WCWOUT("SectionBuffer.Test1() returned: success"); + if (SectionBuffer2.Test2()) { WCWOUT("SectionBuffer.Test2() returned: success"); } + } + +#endif + WindowAreInitedAndReadyToDispatchWMCOMMANDs = true; + break; + } + case WM_SETFOCUS: + { + break; + } + case WM_SIZE: + { + break; + } + case WM_SIZING: + { + break; + } + case WM_TIMER: + { + break; + } + case WM_COMMAND: + { + if (WindowAreInitedAndReadyToDispatchWMCOMMANDs) { + + if (LOWORD(wparam) == windows_cfgbuttons::loadCfg.id) + { + cfg_functions::LoadCfgFromFile(); + break; + } + else if (LOWORD(wparam) == windows_cfgbuttons::saveCfg.id) + { + cfg_functions::SaveCfgInFile(); + break; + } + else if (windows_maincontrolbuttons::Account.id == LOWORD(wparam)) + { + + } + windows_maincontrolbuttons::ButtonHandler(wparam); + windows_accountpage::Handler_ClickButton(wparam); + windows_injectorpage::ButtonHandler(wparam); + windows_playerspage::Handler_ClickButton(wparam); + windows_quickbuttons::Handler_ClickButton(wparam); + } + break; + } + case WM_PAINT: + { + HDeviceC = ::BeginPaint(hwnd, &PaintStruct); + HGDIOBJ original = NULL; + original = ::SelectObject(HDeviceC, GetStockObject(DC_PEN)); + + ::SetBkColor(HDeviceC, dynamic_background_color); + ::SetTextColor(HDeviceC, dynamic_background_color); + ::SelectObject(HDeviceC, GetStockObject(DC_PEN)); + ::SelectObject(HDeviceC, GetStockObject(DC_BRUSH)); + ::SetDCPenColor(HDeviceC, dynamic_background_color); + ::SetDCBrushColor(HDeviceC, dynamic_background_color); + ::Rectangle(HDeviceC, 0, mainbuttonbackgroundtopoffset, MainWindowSizes::width, mainbuttonbackgroundheight- mainbuttonbackgroundtopoffset); + + ::SelectObject(HDeviceC, original); + ::EndPaint(hwnd, &PaintStruct); + ::ReleaseDC(hwnd, HDeviceC); + break; + } + + case WM_DESTROY: { + PostQuitMessage(0); + return 0; + } + default: + {break; } + } + return (DefWindowProc(hwnd, msg, wparam, lparam)); +} diff --git a/ultimateteknotool.v2/WinMainProc.h b/ultimateteknotool.v2/WinMainProc.h new file mode 100644 index 0000000..e4c1956 --- /dev/null +++ b/ultimateteknotool.v2/WinMainProc.h @@ -0,0 +1,6 @@ +#pragma once +#include +namespace windowsMain +{ + LRESULT CALLBACK MainWinProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/WindowsVisitor.h b/ultimateteknotool.v2/WindowsVisitor.h new file mode 100644 index 0000000..a85f3af --- /dev/null +++ b/ultimateteknotool.v2/WindowsVisitor.h @@ -0,0 +1,16 @@ +#pragma once +class CWindow_edit; +class CWindow_button; +class CWindow_edit_cfg; +class CWindow_button_cfg; +class CWindow_static; + +struct WindowsVisitor +{ + virtual void Visit(CWindow_edit*) = 0; + virtual void Visit(CWindow_edit_cfg*) = 0; + virtual void Visit(CWindow_button*) = 0; + virtual void Visit(CWindow_button_cfg*) = 0; + virtual void Visit(CWindow_static*) = 0; + virtual ~WindowsVisitor() = default; +}; diff --git a/ultimateteknotool.v2/Winsock_Client.cpp b/ultimateteknotool.v2/Winsock_Client.cpp new file mode 100644 index 0000000..9034760 --- /dev/null +++ b/ultimateteknotool.v2/Winsock_Client.cpp @@ -0,0 +1,142 @@ +#include "pch.h" +#include "Winsock_Client.h" + +Winsock_Client::Winsock_Client() +{ + this->bdSecurityID.Init(0x31); +} + +Winsock_Client::~Winsock_Client() +{ + ::closesocket(this->m_Socket); +} + +void Winsock_Client::doDTLSconnect(sockaddr_in* address) +{ + if (WSAController::WSAC0ntroller().IsValid() == false) { return; } + this->m_Socket = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + this->m_ServerAddr.sin_addr = address->sin_addr; + this->m_ServerAddr.sin_family = AF_INET; + this->m_ServerAddr.sin_port = address->sin_port; + + DWORD timeout = 2 * 1000; + setsockopt(this->m_Socket, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(timeout)); + + this->buffer_for_dtls.Flush(); + this->Send_Init(); + WCWOUT("Winsock_Client::doDTLSconnect: sent init"); + if (NO_ERROR != this->RecvFrom(this->buffer_for_dtls.Data(), this->buffer_for_dtls.Size())) { + return; + } + else + { + memcpy((char*)&this->initialACK, this->buffer_for_dtls.Data(), sizeof(this->initialACK)); + this->buffer_for_dtls.Flush(); + this->Send_CookieAck(); + WCWOUT("Winsock_Client::doDTLSconnect: sent cookieack"); + /* next steps are not released */ + } +} + +void Winsock_Client::SetPlayerNetData(iw5mp_structs::playerNetData& ppp) +{ + WCWOUT("Winsock_Client::SetPlayerNetData()"); + this->playernetdata = ppp; + +} + +long Winsock_Client::SendTo(const char* buf, int len, int flags) +{ + int sendret = 0; // SOCKET_ERROR, etc ... + sendret = ::sendto(this->m_Socket, buf, len, flags, reinterpret_cast(&this->m_ServerAddr), sizeof(this->m_ServerAddr)); + if (sendret <= 0) + { + //wsaerror = ::WSAGetLastError(); + //std::cout << "error/socket/::sendto wsaerror: " << wsaerror << '\n'; + //switch (wsaerror) + //{ + //case WSAETIMEDOUT: + //case WSAEHOSTUNREACH: + //case WSAECONNABORTED: + // return WSABASEERR - WSAECONNABORTED; + //default: + // return WSABASEERR; + //} + WCWOUT("Winsock_Client::SendTo failed"); + return WSABASEERR; + } + return NO_ERROR; +} + +long Winsock_Client::RecvFrom(char* buf, int len, int flags) +{ + this->m_recvbytes = 0; + int wsaerror = 0; + int recvret = 0; // SOCKET_ERROR, etc ... + int fromlen = sizeof(this->m_ServerAddr); + recvret = ::recvfrom(this->m_Socket, buf, len, flags, reinterpret_cast<::SOCKADDR*>(&this->m_ServerAddr), &fromlen); + if (recvret > 0) { + this->m_recvbytes = recvret; + } + else + { + wsaerror = ::WSAGetLastError(); + WCWOUT("this->RecvFrom failed", wsaerror); + //std::cout << "error/socket/::recvfrom wsaerror: " << wsaerror << '\n'; + //switch (wsaerror) + //{ + //case WSAETIMEDOUT: + //case WSAEHOSTUNREACH: + //case WSAECONNABORTED: + // return WSAECONNABORTED - WSABASEERR; + //default: + // return WSABASEERR; + //} + return WSABASEERR; + } + return NO_ERROR; +} + +void Winsock_Client::FlushStruct(char* dst, size_t sz) +{ + char crypt = RANDBYTE; + for (size_t i = 0; i < sz; i++) + { + dst[i] = (dst[i] + 1) ^ crypt; + crypt++; + } +} + + +void Winsock_Client::Send_Init() +{ + iw5mp_structs::DTLS::InitPacket initial; + initial.header_high = 0x01; + initial.header_low = 0x02; + initial.unknown = 0; + initial.m_initTag = MAKEWORD(RANDBYTEH1, RANDBYTEH0); + initial.bdSecurityID.Set(&(this->bdSecurityID)); + this->SendTo((char*)&initial, sizeof(iw5mp_structs::DTLS::InitPacket)); +} + +void Winsock_Client::Send_CookieAck() +{ + this->CookieAckPacket.header_high = 0x03; + this->CookieAckPacket.header_low = 0x02; + /* initack part */ + this->CookieAckPacket.initack = this->initialACK; + this->initialACK.cookie.localTag = 0; + this->CookieAckPacket.cookie = this->initialACK.cookie; + this->FlushStruct((char*)&this->initialACK, sizeof(this->initialACK)); + /* netdata */ + this->CookieAckPacket.pND = this->playernetdata; + /* bdsecurity */ + this->CookieAckPacket.bdSecurityID.Set(&this->bdSecurityID); + /* ecckey */ + TomLibKeyGen::GetT0mLibKeyGen().ECC_GetExportKey(this->CookieAckPacket.ECCkey_exportkey, sizeof(this->CookieAckPacket.ECCkey_exportkey)); + + this->SendTo((char*)&this->CookieAckPacket, sizeof(this->CookieAckPacket)); + this->FlushStruct((char*)&this->CookieAckPacket, sizeof(this->CookieAckPacket)); +} + + diff --git a/ultimateteknotool.v2/Winsock_Client.h b/ultimateteknotool.v2/Winsock_Client.h new file mode 100644 index 0000000..0e220a3 --- /dev/null +++ b/ultimateteknotool.v2/Winsock_Client.h @@ -0,0 +1,62 @@ +#pragma once +#include "iw5mp_structs.h" +#include "Randomizer.h" +#include "debugconsole.h" +#include +#include +#include +#include +#pragma comment (lib, "Ws2_32.lib") +#include "TomLibKeyGen.h" +#include "WSAController.h" + +/* only dynamic alloc */ +class Winsock_Client +{ +public: + Winsock_Client(); + ~Winsock_Client(); + void doDTLSconnect(sockaddr_in* address); + void SetPlayerNetData(iw5mp_structs::playerNetData& playernetdata); +private: + template + class MemBuffer + { + private: + char _mem[SZ] = { 0 }; + public: + MemBuffer() + { + for (size_t i = 0; i < SZ; i++) + { + _mem[i] = 0; + } + } + ~MemBuffer() = default; + void Flush() + { + for (size_t i = 0; i < SZ; i++) + { + _mem[i] = 0; + } + } + char* Data() { return this->_mem; } + size_t Size() const { return SZ; } + }; + + SOCKET m_Socket = { 0 }; + sockaddr_in m_ServerAddr = { 0 }; + MemBuffer<256> buffer_for_dtls; + + int m_recvbytes = 0x00; + long SendTo(const char* buf, int len, int flags = 0); + long RecvFrom(char* buf, int len, int flags = 0); + void FlushStruct(char* dst, size_t sz); + iw5mp_structs::bdSecurityKeyMap_bdSecurityID bdSecurityID; + + void Send_Init(); + iw5mp_structs::DTLS::InitAck initialACK = { 0 }; + iw5mp_structs::DTLS::CookieAckPacket CookieAckPacket = { 0 }; + iw5mp_structs::playerNetData playernetdata = { 0 }; + void Send_CookieAck(); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/Winsock_ClientController.cpp b/ultimateteknotool.v2/Winsock_ClientController.cpp new file mode 100644 index 0000000..af1a2de --- /dev/null +++ b/ultimateteknotool.v2/Winsock_ClientController.cpp @@ -0,0 +1,34 @@ +#include "pch.h" +#include "Winsock_ClientController.h" + std::once_flag Winsock_ClientController::m_createonceflag; + std::unique_ptr Winsock_ClientController::m_pInstance; + + Winsock_ClientController::Winsock_ClientController() + { + this->ptrClient = nullptr; + } + +Winsock_ClientController::~Winsock_ClientController() +{ + if (this->ptrClient != nullptr) + { + delete this->ptrClient; + } +} + +Winsock_ClientController& Winsock_ClientController::Winsock_ClientC0ntroller() +{ + std::call_once(Winsock_ClientController::m_createonceflag, [] { + Winsock_ClientController::m_pInstance.reset(new Winsock_ClientController); + }); + return *Winsock_ClientController::m_pInstance.get(); +} + +Winsock_Client* Winsock_ClientController::GetClient() +{ + if (this->ptrClient == nullptr) + { + this->ptrClient = new Winsock_Client(); + } + return this->ptrClient; +} diff --git a/ultimateteknotool.v2/Winsock_ClientController.h b/ultimateteknotool.v2/Winsock_ClientController.h new file mode 100644 index 0000000..383fe93 --- /dev/null +++ b/ultimateteknotool.v2/Winsock_ClientController.h @@ -0,0 +1,22 @@ +#pragma once +#include +#include +#include "Winsock_Client.h" + +class Winsock_ClientController +{ +private: + Winsock_ClientController(); + static std::once_flag m_createonceflag; + static std::unique_ptr m_pInstance; + Winsock_ClientController(const Winsock_ClientController&) = delete; + Winsock_ClientController(Winsock_ClientController&&) = delete; + Winsock_ClientController& operator=(const Winsock_ClientController&) = delete; + Winsock_ClientController& operator=(Winsock_ClientController&&) = delete; + + Winsock_Client* ptrClient = nullptr; +public: + ~Winsock_ClientController(); + static Winsock_ClientController& Winsock_ClientC0ntroller(); + Winsock_Client* GetClient(); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/cfg_functions.cpp b/ultimateteknotool.v2/cfg_functions.cpp new file mode 100644 index 0000000..8d8fca7 --- /dev/null +++ b/ultimateteknotool.v2/cfg_functions.cpp @@ -0,0 +1,88 @@ +#include "pch.h" +#include "cfg_functions.h" + + +static constexpr size_t BUFFERSIZE = 1024; +static CONSTEXPRENCRYPTSTRW(uttv2_1, L"x022f_5f7a0ec6.demo", 0x9950); +static CONSTEXPRENCRYPTSTRW(uttv2_2, L"x022f_5f7a0ec6.demo", 0xAC0A); +static CONSTEXPRENCRYPTSTRW(uttv2_3, L"x022f_5f7a0ec6.demo", 0x13FA); +#define CFGFILEMACRO_1 DECRYPTCONSTENCSTRW(uttv2_1, sizeof(L"x022f_5f7a0ec6.demo") / sizeof(wchar_t), 0x9950) +#define CFGFILEMACRO_2 DECRYPTCONSTENCSTRW(uttv2_2, sizeof(L"x022f_5f7a0ec6.demo") / sizeof(wchar_t), 0xAC0A) +#define CFGFILEMACRO_3 DECRYPTCONSTENCSTRW(uttv2_3, sizeof(L"x022f_5f7a0ec6.demo") / sizeof(wchar_t), 0x13FA) + +void cfg_functions::LoadDefaultOrExistingCfg() +{ + CWinAPIFileW file; + if (file.IsFileExist(CFGFILEMACRO_1)) + { + cfg_functions::LoadCfgFromFile(); + } + else + { + cfg_functions::LoadDefaultSettings(); + } +} + + + +void cfg_functions::LoadCfgPreCreateWinInFile() +{ + CWinAPIFileW file; + if (file.IsFileExist(CFGFILEMACRO_1)) { + file.OpenForReading(CFGFILEMACRO_3); + std::vectorpacker(BUFFERSIZE, 0); + CWindowCfgReader reader(packer.data(), packer.size()); + file.ReadFrom((char*)packer.data(), packer.size() * sizeof(wchar_t)); + file.Close(); + + windows_accountpage::Cfg_LoadPreCreateWindowSettings(&reader); + } +} + +void SaveCfgPreCreateWinInFile(CWindowCfgWriter& writer) +{ + windows_accountpage::Cfg_SavePreCreateWindowSettings(&writer); +} + +void LoadCfgPreCreateWinInFile(CWindowCfgReader& reader) +{ + windows_accountpage::Cfg_LoadPreCreateWindowSettings(&reader); +} + +void cfg_functions::SaveCfgInFile() +{ + std::vectorpacker(BUFFERSIZE, 0); + CWindowCfgWriter writer(packer.data(), packer.size()); + + SaveCfgPreCreateWinInFile(writer); + + windows_accountpage::Cfg_Save(&writer); + + CWinAPIFileW file; + file.Truncate(CFGFILEMACRO_2); + file.OpenForWriting(CFGFILEMACRO_2); + file.WriteInAppend(reinterpret_cast(packer.data()), writer.GetTotalBytesWriten()*sizeof(wchar_t)); + file.Close(); +} + +void cfg_functions::LoadCfgFromFile() +{ + CWinAPIFileW file; + file.OpenForReading(CFGFILEMACRO_3); + std::vectorpacker(BUFFERSIZE, 0); + CWindowCfgReader reader(packer.data(), packer.size()); + file.ReadFrom((char*)packer.data(), packer.size() * sizeof(wchar_t)); + file.Close(); + + LoadCfgPreCreateWinInFile(reader); + windows_accountpage::Cfg_Load(&reader); +} + +void cfg_functions::LoadDefaultSettings() +{ + windows_accountpage::WriteDefault(); +} + +#undef CFGFILEMACRO_1 //DECRYPTCONSTENCSTRW(uttv2_1, sizeof(L"utt.v2") / sizeof(wchar_t), 0x0050, 6) +#undef CFGFILEMACRO_2 //DECRYPTCONSTENCSTRW(uttv2_2, sizeof(L"utt.v2") / sizeof(wchar_t), 0x000A, 2) +#undef CFGFILEMACRO_3 //DECRYPTCONSTENCSTRW(uttv2_3, sizeof(L"utt.v2") / sizeof(wchar_t), 0x00FA, 1) \ No newline at end of file diff --git a/ultimateteknotool.v2/cfg_functions.h b/ultimateteknotool.v2/cfg_functions.h new file mode 100644 index 0000000..b588489 --- /dev/null +++ b/ultimateteknotool.v2/cfg_functions.h @@ -0,0 +1,15 @@ +#pragma once +#include "CWindowCfgWriter.h" +#include "CWindowCfgReader.h" +#include "CWinAPIFileW.h" +#include "compiletime_XORstring.h" +#include "windows_accountpage.h" + +namespace cfg_functions +{ + void LoadDefaultOrExistingCfg(); + void LoadCfgPreCreateWinInFile(); + void SaveCfgInFile(); + void LoadCfgFromFile(); + void LoadDefaultSettings(); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/compiletime_XORstring.cpp b/ultimateteknotool.v2/compiletime_XORstring.cpp new file mode 100644 index 0000000..49fc3b9 --- /dev/null +++ b/ultimateteknotool.v2/compiletime_XORstring.cpp @@ -0,0 +1,4 @@ +#include "pch.h" +#include "compiletime_XORstring.h" + + diff --git a/ultimateteknotool.v2/compiletime_XORstring.h b/ultimateteknotool.v2/compiletime_XORstring.h new file mode 100644 index 0000000..69d7b33 --- /dev/null +++ b/ultimateteknotool.v2/compiletime_XORstring.h @@ -0,0 +1,129 @@ +#pragma once +#include + +namespace compile_time +{ + /* + Encrypt normal char string with xor key +i on compile time + */ + template + class EncryptString + { + private: + std::array _buf; + constexpr char encrypt(unsigned char c, unsigned char index) + { + unsigned char KEY = XKEY; + KEY += index; + KEY ^= (1 << (XBIT & 7)); + return c ^ KEY; + } + + public: + template + constexpr EncryptString(const char* str, std::index_sequence) + : _buf { { encrypt(str[Is], Is)... } } + { + /* can't do smth here, it is constexpr func */ + } + char* getData() const { return (char*)this->_buf.data(); } + }; + /* + Decrypt to normal string with fake offset + */ + template + struct DecryptedString + { + char _buffer[SLEN + 1]; + DecryptedString(char* encstr) + { + char KEY = XKEY; + for (unsigned char i = 0; i < SLEN; i++) + { + KEY = XKEY; + KEY += i; + KEY ^= (1 << XBIT); + _buffer[i] = KEY ^ encstr[i - Offset32bit]; + } + _buffer[SLEN] = 0; + } + + }; + + + static_assert(static_cast(0xFA00) == (static_cast(0x00FA) << 8), ""); + template + class EncryptStringW + { + private: + std::array _buf; + static_assert(sizeof(wchar_t) == 2 * sizeof(char), "doing byte shit"); + constexpr wchar_t encrypt( wchar_t c, wchar_t index) + { + wchar_t KEY = XKEY; + KEY += (index + (static_cast(index) << 8)); + return c ^ KEY; + } + + public: + template + constexpr EncryptStringW(const wchar_t* str, std::index_sequence) + : _buf{ { encrypt(str[Is], Is)... } } + { + /* can't do smth here, it is constexpr func */ + } + wchar_t* getData() const { return (wchar_t*)this->_buf.data(); } + }; + /* + Decrypt to normal string with fake offset + */ + template + struct DecryptedStringW + { + wchar_t _buffer[SLEN + 1]; + DecryptedStringW(wchar_t* encstr) + { + wchar_t KEY = XKEY; + for (wchar_t i = 0; i < SLEN; i++) + { + KEY = XKEY; + KEY += (i + (static_cast(i) << 8)); + _buffer[i] = KEY ^ encstr[i - Offset32bit]; + } + _buffer[SLEN] = 0; + } + + }; + //constexpr long a = MAKELONG(MAKEWORD(__DATE__[2], __DATE__[0]), (MAKEWORD(__DATE__[1],0) >> 4)); + + + constexpr uint32_t CreateRandomOffset() + { + return MAKELONG(MAKEWORD(__DATE__[2], __DATE__[0]), (MAKEWORD(__DATE__[1], 0) >> 4)); + } + +}; +/* XREF KILLING DOESNT WORK WITH /O2 MAX PERFOMANCE */ +/* XREF KILLING RARELY WORK WITH /O1 MIN SIZE */ +/* XREF KILLING OFTEN WORK WITH /O disabled, but still you can find xref to "fdshgjsd" cause IDA has some deduction */ + +#define CONSTEXPRENCRYPTSTR(n, s, key, charbit) constexpr compile_time::EncryptString encstr_##n( s, std::make_index_sequence()) +#define DECRYPTCONSTENCSTR(n, slen, key, charbit) compile_time::DecryptedString (encstr_##n.getData() + compile_time::CreateRandomOffset())._buffer +#define CONSTEXPRENCRYPTSTRW(n, s, key) constexpr compile_time::EncryptStringW<(sizeof(s)/sizeof(wchar_t)), key> encstr_##n( s, std::make_index_sequence<(sizeof(s)/sizeof(wchar_t))>()) +#define DECRYPTCONSTENCSTRW(n, slen, key) compile_time::DecryptedStringW (encstr_##n.getData() + compile_time::CreateRandomOffset())._buffer + +constexpr inline size_t wstringSzFromSizeof(size_t sizeofvalue) +{ + return sizeofvalue / sizeof(wchar_t); +} +inline void copy_string_w(wchar_t* dst, size_t sz1, const wchar_t* src, size_t sz2) +{ + for (size_t i = 0; i < sz1 && i < sz2; i++) + { + dst[i] = src[i]; + } + dst[sz1 - 1] = 0x00; + WCWOUT("decrypted-string: ", dst, " sz1: ", sz1, " sz2: ", sz2 ); +} + + diff --git a/ultimateteknotool.v2/constexprcolorcodes.h b/ultimateteknotool.v2/constexprcolorcodes.h new file mode 100644 index 0000000..191c60d --- /dev/null +++ b/ultimateteknotool.v2/constexprcolorcodes.h @@ -0,0 +1,15 @@ +#pragma once +#include + +namespace constexprcolorcodes +{ + constexpr DWORD Color_00FFFFFF = 0x00FFFFFF; + constexpr DWORD Color_00EFEFEF = 0x00EFEFEF; + constexpr DWORD Color_00FFFAFA = 0x00FFFAFA; + constexpr DWORD Color_00FAFAFF = 0x00FAFAFF; + constexpr DWORD Color_00533E32 = 0x00533E32; + constexpr DWORD Color_00FADADD = 0x00FADADD; + constexpr DWORD Color_00DDDAFA = 0x00DDDAFA; + constexpr DWORD Color_00FFC0CB = 0x00FFC0CB; + constexpr DWORD Color_00CBC0FF = 0x00CBC0FF; +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/debug_console/debugconsole.cpp b/ultimateteknotool.v2/debug_console/debugconsole.cpp new file mode 100644 index 0000000..4eb84c0 --- /dev/null +++ b/ultimateteknotool.v2/debug_console/debugconsole.cpp @@ -0,0 +1,39 @@ +#include "pch.h" +#include "debugconsole.h" + +#ifdef UTT2_DEBUG + std::once_flag WinConsoleW::m_createonceflag; + std::unique_ptr WinConsoleW::m_pInstance; + std::wofstream WinConsoleW::m_woutstream; + +WinConsoleW::WinConsoleW() +{ + if (::AllocConsole() == TRUE) + { + this->m_woutstream.open("CONOUT$", std::wofstream::out); + std::wcout.rdbuf(this->m_woutstream.rdbuf()); + } + else + { + if (::AttachConsole(::GetCurrentProcessId())) + { + this->m_woutstream.open("CONOUT$", std::wofstream::out); + std::wcout.rdbuf(this->m_woutstream.rdbuf()); + } + } +} + +WinConsoleW& WinConsoleW::Console() +{ + std::call_once(WinConsoleW::m_createonceflag, [] { + WinConsoleW::m_pInstance.reset(new WinConsoleW); + }); + return *WinConsoleW::m_pInstance.get(); +} + +WinConsoleW::~WinConsoleW() +{ + ::FreeConsole(); +} + +#endif \ No newline at end of file diff --git a/ultimateteknotool.v2/debug_console/debugconsole.h b/ultimateteknotool.v2/debug_console/debugconsole.h new file mode 100644 index 0000000..1693a20 --- /dev/null +++ b/ultimateteknotool.v2/debug_console/debugconsole.h @@ -0,0 +1,42 @@ +#pragma once + #include + #include +#include +#include +#include +#define UTT2_DEBUG + +#ifdef UTT2_DEBUG +class WinConsoleW +{ +private: + static std::wofstream m_woutstream; + WinConsoleW(); + static std::once_flag m_createonceflag; + static std::unique_ptr m_pInstance; + WinConsoleW(const WinConsoleW&) = delete; + WinConsoleW(WinConsoleW&&) = delete; + WinConsoleW& operator=(const WinConsoleW&) = delete; + WinConsoleW& operator=(WinConsoleW&&) = delete; +public: + ~WinConsoleW(); + static WinConsoleW& Console(); + void print() { + std::wcout << std::endl; + } + template void print(const T& t) { + std::wcout << t << std::endl; + } + template void print(const First& first, const Rest&... rest) { + std::wcout << first; + print(rest...); // recursive call using pack expansion syntax + } + +}; +#endif + +#ifdef UTT2_DEBUG +#define WCWOUT WinConsoleW::Console().print +#else +#define WCWOUT //WinConsoleW::Console().print +#endif \ No newline at end of file diff --git a/ultimateteknotool.v2/debug_console/pch.h b/ultimateteknotool.v2/debug_console/pch.h new file mode 100644 index 0000000..42d0757 --- /dev/null +++ b/ultimateteknotool.v2/debug_console/pch.h @@ -0,0 +1,13 @@ +// pch.h: это предварительно скомпилированный заголовочный файл. +// Перечисленные ниже файлы компилируются только один раз, что ускоряет последующие сборки. +// Это также влияет на работу IntelliSense, включая многие функции просмотра и завершения кода. +// Однако изменение любого из приведенных здесь файлов между операциями сборки приведет к повторной компиляции всех(!) этих файлов. +// Не добавляйте сюда файлы, которые планируете часто изменять, так как в этом случае выигрыша в производительности не будет. + +#ifndef PCH_H +#define PCH_H + +// Добавьте сюда заголовочные файлы для предварительной компиляции +#include "framework.h" + +#endif //PCH_H diff --git a/ultimateteknotool.v2/debug_hooks.cpp b/ultimateteknotool.v2/debug_hooks.cpp new file mode 100644 index 0000000..537d7cc --- /dev/null +++ b/ultimateteknotool.v2/debug_hooks.cpp @@ -0,0 +1,352 @@ +#include "pch.h" +#include "debug_hooks.h" +#include +#include "Randomizer.h" +#include "windows_playerspage.h" + +constexpr static uint16_t bufferSIZE = 512; +static char buffer[bufferSIZE] = { 0 }; +static char* v8; +static char v12[bufferSIZE] = { 0 }; + +void LogMessage(int a1, const char* a2, const char* a3, const char* a4, const char* a5, int a6, const char* a7, ...) +{ + va_list va; + va_list ArgList; + va_start(va, a7); + ::memset(buffer, 0, bufferSIZE); + int vpret = 0; + vpret = ::vprintf(a7, va); + ArgList = va; + _vsnprintf_s(buffer, bufferSIZE, 0xFFFFFFFF, a7, ArgList); + if (vpret >= bufferSIZE) + { + WCWOUT("MsgTruncated"); + } + ArgList = 0; + v8 = (char*)a2; + if (a2 && a3) + { + if (snprintf(v12, 0x100, "%s%s", a2, a3) >= bufferSIZE) + { + LogMessage(1, "warn", "bdPlatformLog", "[junk]", "LogMessage", 251, "Channel name truncated: %s%s.", 0); + } + v8 = v12; + } + WCWOUT(L'[', v8, L']', buffer, L' '); +} + +typedef void(__cdecl* Dummy_bdLogMessage_t)(); +Dummy_bdLogMessage_t Dummy = nullptr; + + +static std::wstringstream sstream; +static std::wstringstream sstreamdechex; +void PrintData_Text(uint8_t* src, size_t sz) +{ + sstream.clear(); + sstream.str(L""); + for (uint32_t i = 0; i < sz; i++) + { + //if (src[i] == 0) + //{ + // sstream << ""; + // //break; + //} + sstream << (char)src[i]; + + } +} + +void PrintData_Dec(uint8_t* src, size_t sz) +{ + sstreamdechex.clear(); + sstreamdechex.str(L""); + for (uint32_t i = 0; i < sz; i++) + { + sstreamdechex << std::dec << (uint32_t)src[i] << L'.'; + + } +} + +void PrintData_Text2(uint8_t* src, size_t sz) +{ + sstream.clear(); + sstream.str(L""); + for (uint32_t i = 0; i < sz; i++) + { + //if (src[i] == 0) + //{ + // sstream << ""; + // //break; + //} + sstream << (char)(src[i] ^ '1'); + + } +} + +void RandomiseData(uint8_t* src, size_t sz) +{ + for (uint32_t i = 0; i < sz; i++) + { + src[i] = src[i] ^ (RANDBYTE & 0x000000FF); + } +} + +void RandomiseData2(uint8_t* src, size_t sz) +{ + for (uint32_t i = 0; i < sz; i++) + { + if (src[i] != 49) { src[i] = src[i] ^ (RANDBYTE & 0x000000FF); } + } +} + +typedef int(__cdecl* bdPlatformSocket_sendTo_t)(uint8_t* socket, uint32_t a2, uint16_t a3, uint8_t* buf, uint32_t len); +static bdPlatformSocket_sendTo_t Original_bdPlatformSocket_sendTo = nullptr; +typedef int(__cdecl* bdPlatformSocket_receiveFrom_t)(uint8_t* socket, int ip, int port, uint8_t* buf, uint32_t len); +static bdPlatformSocket_receiveFrom_t Original_bdPlatformSocket_receiveFrom = nullptr; +typedef int(__thiscall* bdDTLSAssociation_sendData_t)(void* _this, uint32_t a2, uint8_t* a3, uint32_t a4, uint32_t a5); +bdDTLSAssociation_sendData_t Original_bdDTLSAssociation_sendData = nullptr; + +int __cdecl HOOK_bdPlatformSocket_sendTo(uint8_t* socket, uint32_t ip, uint16_t port, uint8_t* buf, uint32_t len); +int __cdecl HOOK_bdPlatformSocket_receiveFrom(uint8_t* socket, int ip, int port, uint8_t* buf, uint32_t len); + +int __cdecl HOOK_bdPlatformSocket_sendTo(uint8_t* socket, uint32_t ip, uint16_t port, uint8_t* buf, uint32_t len) +{ + + return Original_bdPlatformSocket_sendTo(socket, ip, port, buf, len); +} + +int __cdecl HOOK_bdPlatformSocket_receiveFrom(uint8_t* socket, int ip, int port, uint8_t* buf, uint32_t len) +{ + int ret; + //std::cout << "[recv]: "; + //PrintData_Text(buf, len); + ret = Original_bdPlatformSocket_receiveFrom(socket, ip, port, buf, len); + return ret; +} + +typedef char(__thiscall* bdUPnPDevice_extractData_t)(void* th1s); +bdUPnPDevice_extractData_t original_bdUPnPDevice_extractData; +char __fastcall bdUPnPDevice_extractData(uint8_t* th1s, void* deadboi) +{ + std::cout << "bdUPnPDevice_extractData: "; + + return original_bdUPnPDevice_extractData(th1s); +} + +typedef void(__thiscall* bdUPnPDevice_pump_t)(DWORD* th1s); +bdUPnPDevice_pump_t original_bdUPnPDevice_pump; +void __fastcall bdUPnPDevice_pump(DWORD* th1s, DWORD edx) +{ + std::cout << "bdUPnPDevice_pump->state: " << *th1s << '\n'; + original_bdUPnPDevice_pump(th1s); +} + +typedef char(__thiscall* bdUPnP_extractDeviceInfo_t)(void* th1s, int a2, char** a3, DWORD* a4); +bdUPnP_extractDeviceInfo_t original_bdUPnP_extractDeviceInfo; +char __fastcall bdUPnP_extractDeviceInfo(uint8_t* th1s, void* deadboi, int a2, char** a3, DWORD* a4) +{ + std::cout << "bdUPnPDevice_extractData: "; + PrintData_Text(th1s, 0x200); + return original_bdUPnP_extractDeviceInfo(th1s, a2, a3, a4); +} + +typedef int (__cdecl* vsnprintf_8x8x8x8x_t)(DWORD* a1, char* a2, size_t a3); +vsnprintf_8x8x8x8x_t orig_vsnprintf_8x8x8x8x; +int __cdecl vsnprintf_8x8x8x8x(DWORD* a1, char* a2, size_t a3) +{ + int ret = orig_vsnprintf_8x8x8x8x(a1, a2, a3); + PrintData_Text((uint8_t*)a2, a3); + WCWOUT(L"[vsnprintf_8x8x8x8x]: ", sstream.str()); + return ret; +} + +struct NetDataStructure +{ + DWORD netadresstype; + DWORD dw_ip; + DWORD dw_port; + DWORD field_C; + DWORD field_10; + DWORD index; +}; + +struct unkstruct64 +{ + DWORD isValid; + DWORD field_4; + DWORD xuid_part1; + DWORD xuid_part2; + DWORD field_10; + NetDataStructure pNDS; + DWORD v[5]; +}; + +static_assert(sizeof(unkstruct64) == 64, "not 64"); + +struct gameSession_struct +{ + uint8_t bytes[58]; + unkstruct64 unk64x18[18]; + uint32_t field_4D8; + uint32_t field_4DC; + uint32_t field_4E0; + uint32_t field_4E4; + uint32_t field_4E8; +}; + +typedef void(__cdecl* sub_4D9E40_t)(gameSession_struct* a1, int a2); +sub_4D9E40_t sub_4D9E40_orig; +void __cdecl hook_sub_4D9E40(gameSession_struct* a1, int a2) +{ + sub_4D9E40_orig(a1, a2); + WCWOUT("hook_sub_4D9E40 has been called"); + /* called very rare idk what s this */ +} + + +typedef bool(__cdecl* doSmthWithNetData_pSrcHasLocalIpEtc_t)(void* a1, DWORD* a2, WORD* port_value); +doSmthWithNetData_pSrcHasLocalIpEtc_t doSmthWithNetData_pSrcHasLocalIpEtc_orig; +bool __cdecl hook_doSmthWithNetData_pSrcHasLocalIpEtc_(void* a1, DWORD* a2, WORD* port_value) +{ + bool ret = false; + ret = doSmthWithNetData_pSrcHasLocalIpEtc_orig(a1, a2, port_value); + uint8_t* data = (uint8_t*)a2 - (sizeof(NetDataStructure) - sizeof(NetDataStructure::index)); + NetDataStructure* pNDS = reinterpret_cast(data); + WCWOUT("PlayerNetData: ip->", std::dec, pNDS->dw_ip, " port->", pNDS->dw_port, " fC->", pNDS->field_C, " f10->", pNDS->field_10, " index->", pNDS->index); + + return ret; +} + +constexpr uint8_t ASMOPCODE_NOP = 0x90; +struct AddrDescriptor +{ + uint32_t address = 0; + uint8_t overwritebytes = 0; // we don't really want overwrite more than 255 bytes, I m sure + constexpr AddrDescriptor(uint32_t addr, uint8_t ovr) + { + this->address = addr; + this->overwritebytes = ovr; + } + AddrDescriptor() = delete; + //AddrDescriptor(uint32_t addr, uint8_t ovr) = delete; + ~AddrDescriptor() = default; + bool IwantKillMyself() const + { + DWORD restore = 0; + uint8_t* pbyteAddr = reinterpret_cast(this->address); + bool notFailed = false; + notFailed = ::VirtualProtect((LPVOID)this->address, overwritebytes, PAGE_EXECUTE_READWRITE, &restore); + if (notFailed) { + for (decltype(overwritebytes) i = 0; i < overwritebytes; i++) + { + pbyteAddr[i] = ASMOPCODE_NOP; + } + ::VirtualProtect((LPVOID)address, overwritebytes, restore, &restore); + } + return notFailed; + } +}; + +constexpr AddrDescriptor cringeArray[] = { {0x49814F, 2}, {0x498156, 2}, {0x57858c, 2}, {0x429bd7, 3}, {0x4a93e4, 3}, {0x429c1d, 7}, {0x429c2c, 7} }; + +typedef int(__cdecl* GenerateHashIndex_t)(const char* a1); +GenerateHashIndex_t orig = (GenerateHashIndex_t)0x006484D0; +int __cdecl GenerateHashIndexHook(const char* a1) +{ + const char* inputstr = a1; + uint16_t hashindex = 0; + uint32_t key = 119; // 'w' char + if (!inputstr) + { + return 0; + //CRITICALERR_BEGIN "GenerateHashIndex called with nullptr arg" CRITICALERR_END; + } + while (*inputstr) + { + hashindex += ::tolower(*inputstr) * key; + inputstr++; key++; + } + WCWOUT("[GenerateHashIndex] name: ", a1, " idx: ", std::hex, hashindex & 1023); + return hashindex & 1023; + +} + +typedef uint16_t (__cdecl* ScriptString_IndexList_RegisterNewData_t)(void* pdata, int a2, uint32_t size); +ScriptString_IndexList_RegisterNewData_t ScriptString_IndexList_RegisterNewData_torgi; + +typedef void(__cdecl* EnterCriticalSection_ByIndex_t)(int a1); +EnterCriticalSection_ByIndex_t EnterCriticalSection_ByIndex = (EnterCriticalSection_ByIndex_t)0x004D6310; +typedef void(__cdecl* LeaveCriticalSection_byIndex_t)(int a1); +LeaveCriticalSection_byIndex_t LeaveCriticalSection_byIndex = (LeaveCriticalSection_byIndex_t)0x004DCF40; +static uint32_t maxsize = 0; +unsigned __int16 __cdecl ScriptString_IndexList_RegisterNewData(void* pdata, int a2, uint32_t size) +{ + EnterCriticalSection_ByIndex(14); + if (maxsize < size) { + maxsize = size; + WCWOUT("[ScriptString_IndexList_RegisterNewData] size: ", std::dec, size, " "); + } + LeaveCriticalSection_byIndex(14); + return ScriptString_IndexList_RegisterNewData_torgi(pdata, a2, size); +} + + +void hooks::DEBUG_HOOKS() +{ + //Hooker_JMP::Hook32( + // 0x0042CD10, + // ScriptString_IndexList_RegisterNewData, + // 7, + // ScriptString_IndexList_RegisterNewData_torgi); + //for (size_t i = 0; i < (sizeof(cringeArray) / sizeof(AddrDescriptor)); i++) + //{ + // cringeArray[i].IwantKillMyself(); + //} + //Hooker_JMP::Hook32( + // 0x0044A4A0, + // reinterpret_cast(hook_doSmthWithNetData_pSrcHasLocalIpEtc_), + // 7, + // doSmthWithNetData_pSrcHasLocalIpEtc_orig); + + + + // *(BYTE*)(0x006EA960) = 0xC3; + //Hooker_JMP::Hook32( + // 0x006EA960, + // reinterpret_cast(LogMessage), + // 5, + // Dummy + // ); + //Hooker_JMP::Hook32( + // 0x006EAD40, + // reinterpret_cast(HOOK_bdPlatformSocket_sendTo), + // 6, + // Original_bdPlatformSocket_sendTo); + //Hooker_JMP::Hook32( + // 0x006EAEF0, + // reinterpret_cast(HOOK_bdPlatformSocket_receiveFrom), + // 6, + // Original_bdPlatformSocket_receiveFrom); + //Hooker_JMP::Hook32( + // 0x006D0BD0, + // reinterpret_cast(bdUPnPDevice_extractData), + // 6, + // original_bdUPnPDevice_extractData); + //Hooker_JMP::Hook32( + // 0x006CF9B0, + // reinterpret_cast(bdUPnPDevice_pump), + // 6, + // original_bdUPnPDevice_pump); + //Hooker_JMP::Hook32( + // 0x006CF310, + // reinterpret_cast(bdUPnP_extractDeviceInfo), + // 6, + // original_bdUPnP_extractDeviceInfo); + //Hooker_JMP::Hook32( + // 0x004BE5E0, + // reinterpret_cast(vsnprintf_8x8x8x8x), + // 7, + // orig_vsnprintf_8x8x8x8x); +} diff --git a/ultimateteknotool.v2/debug_hooks.h b/ultimateteknotool.v2/debug_hooks.h new file mode 100644 index 0000000..c02bf1d --- /dev/null +++ b/ultimateteknotool.v2/debug_hooks.h @@ -0,0 +1,9 @@ +#pragma once +#include +#include "debugconsole.h" +#include "Hooker_JMP.h" + +namespace hooks +{ + void DEBUG_HOOKS(); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/dllmain.cpp b/ultimateteknotool.v2/dllmain.cpp new file mode 100644 index 0000000..1d447aa --- /dev/null +++ b/ultimateteknotool.v2/dllmain.cpp @@ -0,0 +1,77 @@ +#include "pch.h" +#include "ProcessController.h" +#include "TheWinMain.h" +#include "iw5mp_addresses_definition.h" +#include "iw5mp_functions_definition.h" +#include "cfg_functions.h" +#include "HooksAfterResumingThreads.h" +#include "HooksOnThreadsStart.h" +#include "debugconsole.h" +#include "debug_hooks.h" + + +DWORD WINAPI EntryPoint(LPVOID _arguments) +{ + UNREFERENCED_PARAMETER(_arguments); + WCWOUT(L"debug ", L"string ", 123); + WCWOUT(L"debug ", L"debug ", 123); + bool failed = true; + + ProcessController::SuspendThreads(true); + if (iw5mp_functions_definition::DefineAndVerify() == true) { failed = false; } + if (failed == false) + { + failed = !hooks_on_threads_start::Hook(); +#ifdef UTT2_DEBUG + hooks::DEBUG_HOOKS(); +#endif + cfg_functions::LoadCfgPreCreateWinInFile(); + } + /* we suspend all threads to prevent any data transaction to masterserver before we hook socket and other stuff */ + ProcessController::SuspendThreads(false); + if (failed == true) + { + return ERROR_POSSIBLE_DEADLOCK; + } + //Sleep(10000); + if (hooks_after_resuming_threads::Hook() == false) + { + return ERROR_POSSIBLE_DEADLOCK; + } + + iw5mp_addresses_definition::DefineAddresses_PatternSearching(); + + if (windowsMain::WinStart()) + { + // we really gonna kill iw5mp game via windows functions? we are mad + // ... windows method via procid (weri smart way) + // ::SendMessage(FindMainProcHWND(), WM_CLOSE, 0, 0); + ::SendMessage(*(HWND*)0x05A86AF0, WM_CLOSE, 0, 0); + } + return ERROR_POSSIBLE_DEADLOCK; +} + +BOOL APIENTRY DllMain(HMODULE hModule, + DWORD ul_reason_for_call, + LPVOID lpReserved +) +{ + + UNREFERENCED_PARAMETER(hModule); + UNREFERENCED_PARAMETER(lpReserved); + switch (ul_reason_for_call) + { + case DLL_PROCESS_ATTACH: + ::CreateThread(0, 0, static_cast(EntryPoint), 0, 0, 0); + break; + case DLL_THREAD_ATTACH: + break; + case DLL_THREAD_DETACH: + break; + case DLL_PROCESS_DETACH: + + break; + } + return TRUE; +} + diff --git a/ultimateteknotool.v2/framework.h b/ultimateteknotool.v2/framework.h new file mode 100644 index 0000000..61ca0b6 --- /dev/null +++ b/ultimateteknotool.v2/framework.h @@ -0,0 +1,5 @@ +#pragma once + +#define WIN32_LEAN_AND_MEAN // Исключите редко используемые компоненты из заголовков Windows +// Файлы заголовков Windows +#include diff --git a/ultimateteknotool.v2/iw5mp_address_verifier.cpp b/ultimateteknotool.v2/iw5mp_address_verifier.cpp new file mode 100644 index 0000000..30a44ff --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_address_verifier.cpp @@ -0,0 +1,7 @@ +#include "pch.h" +#include "iw5mp_address_verifier.h" + +bool iw5mp_addresses::sections::IsAddressPlacedAfterDataEnd(uint32_t address) +{ + return address > iw5mp_addresses::sections::data_end; +} diff --git a/ultimateteknotool.v2/iw5mp_address_verifier.h b/ultimateteknotool.v2/iw5mp_address_verifier.h new file mode 100644 index 0000000..48b83b6 --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_address_verifier.h @@ -0,0 +1,14 @@ +#pragma once +#include + +namespace iw5mp_addresses +{ + namespace sections + { + constexpr uint32_t text_start = 0x00401000; + constexpr uint32_t text_end = text_start + 0x00301000; + constexpr uint32_t data_start = text_end; + constexpr uint32_t data_end = data_start + 0x06000000; + bool IsAddressPlacedAfterDataEnd(uint32_t address); + } +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/iw5mp_addresses_declaration.cpp b/ultimateteknotool.v2/iw5mp_addresses_declaration.cpp new file mode 100644 index 0000000..c660e24 --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_addresses_declaration.cpp @@ -0,0 +1,29 @@ +#include "pch.h" +#include "iw5mp_addresses_declaration.h" + +namespace iw5mp_addresses +{ + uint32_t SteamAPI_RegisterCallback_1 = 0x00; + uint32_t NicknameBuffer = 0x00; + uint32_t TitleBuffer = 0x00; + uint32_t TitleTypeValue = 0x00; + uint32_t TitleCustomTextIsAllowed = 0x00; + uint32_t ClanTagBuffer = 0x00; + uint32_t ClanTagIsAllowed = 0x00; + uint32_t EmblemTypeValue = 0x00; + uint32_t XUID = 0x00; + uint32_t SteamAPI_XUID = 0x00; + uint32_t HWID = 0x00; + uint32_t TotalXPValue = 0x00; + uint32_t PrestigeValue = 0x00; + uint32_t PlayersData_xuid = 0x00; + /* using gameSession 24 byte struct */ + uint32_t PlayersData_netdata = 0x00; + uint32_t gameSessionStruct = 0x00; + uint32_t cgameGlob = 0x00; + //uint32_t ChallengeS2 = 0x00; + + uint32_t PlayerDataDef = 0x00; + + uint32_t unnamed_ForceJumpToMenuValue = 0x00; +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/iw5mp_addresses_declaration.h b/ultimateteknotool.v2/iw5mp_addresses_declaration.h new file mode 100644 index 0000000..45e8526 --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_addresses_declaration.h @@ -0,0 +1,29 @@ +#pragma once +#include +#include "iw5mp_structs.h" +#include "iw5mp_address_verifier.h" + +namespace iw5mp_addresses +{ + extern uint32_t SteamAPI_RegisterCallback_1; + extern uint32_t NicknameBuffer; + extern uint32_t TitleBuffer; + extern uint32_t TitleTypeValue; + extern uint32_t TitleCustomTextIsAllowed; + extern uint32_t ClanTagBuffer; + extern uint32_t ClanTagIsAllowed; + extern uint32_t EmblemTypeValue; + extern uint32_t XUID; + extern uint32_t SteamAPI_XUID; + extern uint32_t HWID; + extern uint32_t TotalXPValue; + extern uint32_t PrestigeValue; + extern uint32_t PlayersData_xuid; + extern uint32_t PlayersData_netdata; + extern uint32_t gameSessionStruct; + extern uint32_t cgameGlob; + //extern uint32_t ChallengeS2; + + extern uint32_t PlayerDataDef; + extern uint32_t unnamed_ForceJumpToMenuValue; +}; diff --git a/ultimateteknotool.v2/iw5mp_addresses_definition.cpp b/ultimateteknotool.v2/iw5mp_addresses_definition.cpp new file mode 100644 index 0000000..b1e80e9 --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_addresses_definition.cpp @@ -0,0 +1,707 @@ +#include "pch.h" +#include "iw5mp_addresses_definition.h" + +static CONSTEXPRENCRYPTSTR(SteamAPI_RegisterCallback_1, "8B108BC88B4228", 0x43, 6); +static CONSTEXPRENCRYPTSTR(SteamAPI_XUID, "8B542404568B74240C8BC20BC67505", 0x3F, 1); +static CONSTEXPRENCRYPTSTR(NicknameBufferPatt, "83C4286820BF020068B80B0000", 0x43, 3); +static CONSTEXPRENCRYPTSTR(TitlePattern, "5556578B7C24108BF769", 0x13, 6); +static CONSTEXPRENCRYPTSTR(PlayerDataDefPattern, "69C0053000008BD669D218900000", 0x23, 5); +static CONSTEXPRENCRYPTSTR(CL_CheckForResend, "83C4185083EC188BC48908", 0x66, 6); +static CONSTEXPRENCRYPTSTR(dediServerResolveIpFunction, "0FB64E5B8D542408520FB6565A", 0x6A, 6); +static CONSTEXPRENCRYPTSTR(PlayernetDataStruct, "F3A58BD85589", 0x35, 6); +static CONSTEXPRENCRYPTSTR(cgameGlobstruct, "8B74247C8BC669C090220000", 0x25, 3); +static CONSTEXPRENCRYPTSTR(unnamedui_ForceJumpToMenuValue, "803D????????007459E8????????84C0", 0xA1, 3); + +static constexpr uint32_t VERIFYBASE_ADDRESS = 0x00401000; +bool StupidVerifyAddress(uint32_t add) { return add > VERIFYBASE_ADDRESS; } + +namespace search +{ + uint32_t SteamAPI_RegisterCallback_1(); + uint32_t NicknameBuffer(); + uint32_t TitleBuffer(); + uint32_t TitleTypeValue(); + uint32_t TitleCustomTextIsAllowed(); + uint32_t ClanTagBuffer(); + uint32_t ClanTagIsAllowed(); + uint32_t EmblemTypeValue(); + uint32_t XUID(); + uint32_t SteamAPI_XUID(); + uint32_t HWID(); + uint32_t TotalXPValue(); + uint32_t PrestigeValue(); + uint32_t ChallengeS2(); + uint32_t GameSessionStruct(); + uint32_t PlayersData_xuid(); + uint32_t PlayersData_xuid(uint32_t gameSessionStruct); + uint32_t PlayersData_netdata(); + uint32_t CGameGlobStruct(); + uint32_t unnamed_ForceJumpToMenuValue(); +}; + +namespace constexprvalue +{ + constexpr uint32_t SteamAPI_RegisterCallback_1(); + constexpr uint32_t NicknameBuffer(); + constexpr uint32_t TitleBuffer(); + constexpr uint32_t TitleTypeValue(); + constexpr uint32_t TitleCustomTextIsAllowed(); + constexpr uint32_t ClanTagBuffer(); + constexpr uint32_t ClanTagIsAllowed(); + constexpr uint32_t EmblemTypeValue(); + constexpr uint32_t XUID(); + constexpr uint32_t SteamAPI_XUID(); + constexpr uint32_t HWID(); + constexpr uint32_t TotalXPValue(); + constexpr uint32_t PrestigeValue(); + constexpr uint32_t ChallengeS2(); + constexpr uint32_t GameSessionStruct(); + constexpr uint32_t PlayersData_xuid(); + constexpr uint32_t PlayersData_netdata(); + constexpr uint32_t CGameGlobStruct(); + constexpr uint32_t unnamed_ForceJumpToMenuValue(); +}; + + + +void iw5mp_addresses_definition::DefineAddresses_PatternSearching() +{ + uint32_t addr = search::SteamAPI_RegisterCallback_1(); if (StupidVerifyAddress(addr)) { + iw5mp_addresses::SteamAPI_RegisterCallback_1 = addr; + + } + WCWOUT(L"iw5mp_addresses::SteamAPI_RegisterCallback_1: ", std::hex, (uint32_t)iw5mp_addresses::SteamAPI_RegisterCallback_1); + addr = search::NicknameBuffer(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::NicknameBuffer = addr; } + WCWOUT(L"iw5mp_addresses::NicknameBuffer: ", std::hex, (uint32_t)iw5mp_addresses::NicknameBuffer); + addr = search::TitleBuffer(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::TitleBuffer = addr; } + WCWOUT(L"iw5mp_addresses::TitleBuffer: ", std::hex, (uint32_t)iw5mp_addresses::TitleBuffer); + addr = search::TitleTypeValue(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::TitleTypeValue = addr; } + WCWOUT(L"iw5mp_addresses::TitleTypeValue: ", std::hex, (uint32_t)iw5mp_addresses::TitleTypeValue); + addr = search::TitleCustomTextIsAllowed(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::TitleCustomTextIsAllowed = addr; } + WCWOUT(L"iw5mp_addresses::TitleCustomTextIsAllowed: ", std::hex, (uint32_t)iw5mp_addresses::TitleCustomTextIsAllowed); + addr = search::ClanTagBuffer(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::ClanTagBuffer = addr; } + WCWOUT(L"iw5mp_addresses::ClanTagBuffer: ", std::hex, (uint32_t)iw5mp_addresses::ClanTagBuffer); + addr = search::ClanTagIsAllowed(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::ClanTagIsAllowed = addr; } + WCWOUT(L"iw5mp_addresses::ClanTagIsAllowed: ", std::hex, (uint32_t)iw5mp_addresses::ClanTagIsAllowed); + addr = search::EmblemTypeValue(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::EmblemTypeValue = addr; } + WCWOUT(L"iw5mp_addresses::EmblemTypeValue: ", std::hex, (uint32_t)iw5mp_addresses::EmblemTypeValue); + addr = search::XUID(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::XUID = addr; } + WCWOUT(L"iw5mp_addresses::XUID: ", std::hex, (uint32_t)iw5mp_addresses::XUID); + addr = search::SteamAPI_XUID(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::SteamAPI_XUID = addr; } + WCWOUT(L"iw5mp_addresses::SteamAPI_XUID: ", std::hex, (uint32_t)iw5mp_addresses::SteamAPI_XUID); + addr = search::HWID(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::HWID = addr; } + WCWOUT(L"iw5mp_addresses::HWID: ", std::hex, (uint32_t)iw5mp_addresses::HWID); + addr = search::TotalXPValue(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::TotalXPValue = addr; } + WCWOUT(L"iw5mp_addresses::TotalXPValue: ", std::hex, (uint32_t)iw5mp_addresses::TotalXPValue); + addr = search::PrestigeValue(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::PrestigeValue = addr; } + WCWOUT(L"iw5mp_addresses::PrestigeValue: ", std::hex, (uint32_t)iw5mp_addresses::PrestigeValue); + + addr = search::GameSessionStruct(); if (StupidVerifyAddress(addr)) { + iw5mp_addresses::gameSessionStruct = addr; + addr = search::PlayersData_xuid(iw5mp_addresses::gameSessionStruct); + if (StupidVerifyAddress(addr)) + { + iw5mp_addresses::PlayersData_xuid = addr; + } + } + WCWOUT(L"iw5mp_addresses::gameSessionStruct: ", std::hex, (uint32_t)iw5mp_addresses::gameSessionStruct); + WCWOUT(L"iw5mp_addresses::PlayersData_xuid: ", std::hex, (uint32_t)iw5mp_addresses::PlayersData_xuid); + + addr = search::PlayersData_netdata(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::PlayersData_netdata = addr; } + WCWOUT(L"iw5mp_addresses::PlayersData_netdata: ", std::hex, (uint32_t)iw5mp_addresses::PlayersData_netdata); + addr = search::CGameGlobStruct(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::cgameGlob = addr; } + WCWOUT(L"iw5mp_addresses::cgameGlob: ", std::hex, (uint32_t)iw5mp_addresses::cgameGlob); + //addr = search::ChallengeS2(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::ChallengeS2 = addr; } + //WCWOUT(L"iw5mp_addresses::ChallengeS2: ", std::hex, (uint32_t)iw5mp_addresses::ChallengeS2); + + addr = search::unnamed_ForceJumpToMenuValue(); if (StupidVerifyAddress(addr)) { iw5mp_addresses::unnamed_ForceJumpToMenuValue = addr; } + WCWOUT(L"iw5mp_addresses::unnamed_ForceJumpToMenuValue: ", std::hex, (uint32_t)iw5mp_addresses::unnamed_ForceJumpToMenuValue); +} + +void iw5mp_addresses_definition::DefineAddresses_ConstValues() +{ + iw5mp_addresses::SteamAPI_RegisterCallback_1 = constexprvalue::SteamAPI_RegisterCallback_1(); + iw5mp_addresses::NicknameBuffer = constexprvalue::NicknameBuffer(); + iw5mp_addresses::TitleBuffer = constexprvalue::TitleBuffer(); + iw5mp_addresses::TitleTypeValue = constexprvalue::TitleTypeValue(); + iw5mp_addresses::TitleCustomTextIsAllowed = constexprvalue::TitleCustomTextIsAllowed(); + iw5mp_addresses::ClanTagBuffer = constexprvalue::ClanTagBuffer(); + iw5mp_addresses::ClanTagIsAllowed = constexprvalue::ClanTagIsAllowed(); + iw5mp_addresses::EmblemTypeValue = constexprvalue::EmblemTypeValue(); + iw5mp_addresses::XUID = constexprvalue::XUID(); + iw5mp_addresses::SteamAPI_XUID = constexprvalue::SteamAPI_XUID(); + iw5mp_addresses::HWID = constexprvalue::HWID(); + iw5mp_addresses::TotalXPValue = constexprvalue::TotalXPValue(); + iw5mp_addresses::PrestigeValue = constexprvalue::PrestigeValue(); + //iw5mp_addresses::ChallengeS2 = constexprvalue::ChallengeS2(); + iw5mp_addresses::unnamed_ForceJumpToMenuValue = constexprvalue::unnamed_ForceJumpToMenuValue(); +} + + +uint32_t search::SteamAPI_RegisterCallback_1() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(SteamAPI_RegisterCallback_1, sizeof("8B108BC88B4228"), 0x43, 6), startaddress, maxdepth); + raddress += 0x24; + if (StupidVerifyAddress(raddress)) + { + return *reinterpret_cast(raddress); + } + else + { + return 0; + } +} + +uint32_t search::NicknameBuffer() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(NicknameBufferPatt, sizeof("83C4286820BF020068B80B0000"), 0x43, 3), startaddress, maxdepth); + raddress = raddress - 0x133; + if (StupidVerifyAddress(raddress)) + { + return *reinterpret_cast(raddress); + } + else + { + return 0; + } +} + + +uint32_t search::TitleBuffer() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(TitlePattern, sizeof("5556578B7C24108BF769"), 0x13, 6), startaddress, maxdepth); + raddress += 19; + if (StupidVerifyAddress(raddress)) + { + return *reinterpret_cast(raddress); + } + else + { + return 0; + } +} + +uint32_t search::TitleTypeValue() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(TitlePattern, sizeof("5556578B7C24108BF769"), 0x13, 6), startaddress, maxdepth); + raddress += 31; + if (StupidVerifyAddress(raddress)) + { + return *reinterpret_cast(raddress); + } + else + { + return 0; + } +} + +uint32_t search::TitleCustomTextIsAllowed() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(TitlePattern, sizeof("5556578B7C24108BF769"), 0x13, 6), startaddress, maxdepth); + raddress += 41; + if (StupidVerifyAddress(raddress)) + { + return *reinterpret_cast(raddress); + } + else + { + return 0; + } +} + +uint32_t search::ClanTagBuffer() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(TitlePattern, sizeof("5556578B7C24108BF769"), 0x13, 6), startaddress, maxdepth); + raddress += 62; + if (StupidVerifyAddress(raddress)) + { + return *reinterpret_cast(raddress); + } + else + { + return 0; + } +} + +uint32_t search::ClanTagIsAllowed() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(TitlePattern, sizeof("5556578B7C24108BF769"), 0x13, 6), startaddress, maxdepth); + raddress += 48; + if (StupidVerifyAddress(raddress)) + { + return *reinterpret_cast(raddress); + } + else + { + return 0; + } +} + +uint32_t search::EmblemTypeValue() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(PlayerDataDefPattern, sizeof("69C0053000008BD669D218900000"), 0x23, 5), startaddress, maxdepth); + raddress += 0x22; // playerdef + if (StupidVerifyAddress(raddress)) + { + raddress = *reinterpret_cast(raddress); + raddress += 0x28A2; // emblem offset + if (StupidVerifyAddress(raddress)) + { + return raddress; + } + else + { + return 0; + } + } + else + { + return 0; + } +} + +uint32_t search::XUID() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(PlayerDataDefPattern, sizeof("69C0053000008BD669D218900000"), 0x23, 5), startaddress, maxdepth); + raddress += 0x22; // playerdef + if (StupidVerifyAddress(raddress)) + { + raddress = *reinterpret_cast(raddress); + raddress += 0x2BB9; // xuid offset + if (StupidVerifyAddress(raddress)) + { + return raddress; + } + else + { + return 0; + } + } + else + { + return 0; + } +} + +uint32_t search::SteamAPI_XUID() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(SteamAPI_XUID, sizeof("8B542404568B74240C8BC20BC67505"), 0x3F, 1), startaddress, maxdepth); + raddress += (22+1); // mov ecx, offset SteamAPI_xuid; mov ecx, smth 1 byte + if (StupidVerifyAddress(raddress)) + { + raddress = *reinterpret_cast(raddress); + if (StupidVerifyAddress(raddress)) + { + return raddress; + } + else + { + return 0; + } + } + else + { + return 0; + } + +} + +uint32_t search::HWID() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(PlayerDataDefPattern, sizeof("69C0053000008BD669D218900000"), 0x23, 5), startaddress, maxdepth); + raddress += 0x22; // playerdef + if (StupidVerifyAddress(raddress)) + { + raddress = *reinterpret_cast(raddress); + raddress += 0x2FF0; // hwid offset + if (StupidVerifyAddress(raddress)) + { + return raddress; + } + else + { + return 0; + } + } + else + { + return 0; + } +} + +uint32_t search::TotalXPValue() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(PlayerDataDefPattern, sizeof("69C0053000008BD669D218900000"), 0x23, 5), startaddress, maxdepth); + raddress += 0x22; // playerdef + if (StupidVerifyAddress(raddress)) + { + raddress = *reinterpret_cast(raddress); + raddress += 0xA98; // totalxp offset + if (StupidVerifyAddress(raddress)) + { + return raddress; + } + else + { + return 0; + } + } + else + { + return 0; + } +} + +uint32_t search::PrestigeValue() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(PlayerDataDefPattern, sizeof("69C0053000008BD669D218900000"), 0x23, 5), startaddress, maxdepth); + raddress += 0x22; // playerdef + if (StupidVerifyAddress(raddress)) + { + raddress = *reinterpret_cast(raddress); + raddress += 0xCA8; // prestige offset + if (StupidVerifyAddress(raddress)) + { + return raddress; + } + else + { + return 0; + } + } + else + { + return 0; + } +} + +uint32_t search::ChallengeS2() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + uint32_t addr2 = 0x00; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(CL_CheckForResend, sizeof("83C4185083EC188BC48908"), 0x66, 6), startaddress, maxdepth); + raddress -= (0x29 - 1 /* E8 */); + if (StupidVerifyAddress(raddress)) + { + addr2 = *reinterpret_cast(raddress); + raddress += addr2; + raddress += 4; + /* +.text:005CA2F0 sub_5CA2F0 proc near ; CODE XREF: sub_48FF30+13Dp +.text:005CA2F0 mov eax, offset dword_5A96F48 +.text:005CA2F5 retn +.text:005CA2F5 sub_5CA2F0 endp -> B8 48 6F A9 05 C3 + */ + if (StupidVerifyAddress(raddress)) + { + raddress += 1; + raddress = *reinterpret_cast(raddress); + return raddress; + } + else + { + return 0; + } + } + else + { + return 0; + } +} + +uint32_t search::GameSessionStruct() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(dediServerResolveIpFunction, sizeof("0FB64E5B8D542408520FB6565A"), 0x6A, 6), startaddress, maxdepth); + raddress = raddress + 0x12 + 1; // 1 = push + if (StupidVerifyAddress(raddress)) + { + raddress = *reinterpret_cast(raddress); + if (StupidVerifyAddress(raddress)) + { + return raddress; + } + else + { + return 0; + } + } + else + { + return 0; + } +} + +uint32_t search::PlayersData_xuid() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(dediServerResolveIpFunction, sizeof("0FB64E5B8D542408520FB6565A"), 0x6A, 6), startaddress, maxdepth); + raddress = raddress + 0x12 + 1; // 1 = push + if (StupidVerifyAddress(raddress)) + { + raddress = *reinterpret_cast(raddress); + if (StupidVerifyAddress(raddress)) + { + return raddress + offsetof(iw5mp_structs::gameSession, x18_24b); + } + else + { + return 0; + } + } + else + { + return 0; + } +} + +uint32_t search::PlayersData_xuid(uint32_t gameSessionStruct) +{ + return gameSessionStruct + offsetof(iw5mp_structs::gameSession, x18_24b); +} + +uint32_t search::PlayersData_netdata() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(PlayernetDataStruct, sizeof("F3A58BD85589"), 0x35, 6), startaddress, maxdepth); + /* +.text:00435005 114 rep movsd +.text:00435007 114 mov ebx, eax +.text:00435009 114 push ebp +.text:0043500A 118 mov [esp+118h+var_CC], ebx +.text:0043500E 118 movsb +.text:0043500F 118 call return_0 +.text:00435014 118 mov esi, offset stru_FB4E70 + */ + raddress = raddress + 0x0F + 1; // 1 = mov + if (StupidVerifyAddress(raddress)) + { + raddress = *reinterpret_cast(raddress); + if (StupidVerifyAddress(raddress)) + { + return raddress; + } + else + { + return 0; + } + } + else + { + return 0; + } +} + +uint32_t search::CGameGlobStruct() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(cgameGlobstruct, sizeof("8B74247C8BC669C090220000"), 0x25, 3), startaddress, maxdepth); + /* +.text:0047702F 074 push offset cgameGlob ; void * +.text:00477034 078 call _memset +.text:00477039 078 mov esi, [esp+78h+index] +.text:0047703D 078 mov eax, esi +.text:0047703F 078 imul eax, 2290h +.text:00477045 078 push 2290h ; size_t + */ + raddress = raddress - (5+4); // 5 = call + if (StupidVerifyAddress(raddress)) + { + raddress = *reinterpret_cast(raddress); + if (StupidVerifyAddress(raddress)) + { + return raddress; + } + else + { + return 0; + } + } + else + { + return 0; + } +} + +uint32_t search::unnamed_ForceJumpToMenuValue() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(unnamedui_ForceJumpToMenuValue, sizeof("803D????????007459E8????????84C0"), 0xA1, 3), startaddress, maxdepth); + /* pluto iw5mp +.text:00577CA0 cmp byte_2108264, 0 -> 80 3D 64 82 10 02 00 +.text:00577CA7 jz short loc_577D02 +.text:00577CA9 call sub_578210 +.text:00577CAE test al, al + */ + raddress = raddress + 2; + if (StupidVerifyAddress(raddress)) + { + raddress = *reinterpret_cast(raddress); + if (StupidVerifyAddress(raddress)) + { + return raddress; + } + else + { + return 0; + } + } + else + { + return 0; + } +} + + + +constexpr uint32_t constexprvalue::SteamAPI_RegisterCallback_1() +{ + return 0x05CCB138; +} + +constexpr uint32_t constexprvalue::NicknameBuffer() +{ + return 0x05A7B1B4; +} + +constexpr uint32_t constexprvalue::TitleBuffer() +{ + return 0x01328D35; +} + +constexpr uint32_t constexprvalue::TitleTypeValue() +{ + return 0x01328D50; +} + +constexpr uint32_t constexprvalue::TitleCustomTextIsAllowed() +{ + return 0x01328D34; +} + +constexpr uint32_t constexprvalue::ClanTagBuffer() +{ + return 0x01328D54; +} + +constexpr uint32_t constexprvalue::ClanTagIsAllowed() +{ + return 0x01328D33; +} + +constexpr uint32_t constexprvalue::EmblemTypeValue() +{ + return 0x01CDD85E; +} + +constexpr uint32_t constexprvalue::XUID() +{ + return 0x01CDDB75; +} + +constexpr uint32_t constexprvalue::SteamAPI_XUID() +{ + return 0x05A7B1D8; +} + +constexpr uint32_t constexprvalue::HWID() +{ + return 0x01CDDFAC; +} + +constexpr uint32_t constexprvalue::TotalXPValue() +{ + return 0x01CDBA54; +} + +constexpr uint32_t constexprvalue::PrestigeValue() +{ + return 0x01CDBC64; +} + +constexpr uint32_t constexprvalue::ChallengeS2() +{ + return 0x05A7B234; +} + +constexpr uint32_t constexprvalue::GameSessionStruct() +{ + return 0x05C4E7E8; +} + +constexpr uint32_t constexprvalue::PlayersData_xuid() +{ + return 0x05C4E840; +} + +constexpr uint32_t constexprvalue::PlayersData_netdata() +{ + return 0x00FB4E70; +} + +constexpr uint32_t constexprvalue::CGameGlobStruct() +{ + return 0x008FF100; +} + +constexpr uint32_t constexprvalue::unnamed_ForceJumpToMenuValue() +{ + return 0x02103A64; +} + + + + + + diff --git a/ultimateteknotool.v2/iw5mp_addresses_definition.h b/ultimateteknotool.v2/iw5mp_addresses_definition.h new file mode 100644 index 0000000..1e5c131 --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_addresses_definition.h @@ -0,0 +1,10 @@ +#pragma once +#include "iw5mp_addresses_declaration.h" +#include "PatternSearcher.h" +#include "compiletime_XORstring.h" + +namespace iw5mp_addresses_definition +{ + void DefineAddresses_PatternSearching(); + void DefineAddresses_ConstValues(); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/iw5mp_constants.h b/ultimateteknotool.v2/iw5mp_constants.h new file mode 100644 index 0000000..28ae624 --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_constants.h @@ -0,0 +1,21 @@ +#pragma once +namespace iw5mp_constants +{ + constexpr unsigned char MAX_LENGTH_NICKNAME = 16; + /* last byte must be nulled */ + constexpr unsigned char MAX_LENGTH_TITLE = 24; + /* last byte must be nulled */ + constexpr unsigned char MAX_LENGTH_CLANTAG = 8; + /* last byte must be nulled */ + + constexpr unsigned char maxvalidlevel = 80; + constexpr unsigned char maxvalidprestige = 20; + constexpr uint32_t XP_TO_LEVEL[] = + { + 0,800,1900,3100,4900,7100,9600,12400,15600,19200,23100,27500,32400,37800,43700,50100,57000,64400,72300,80700,89600,98000, + 108900,119300,130200,141600,153500,165900,178800,192200,206200,220800,236000,251800,268200,285200,302800,321000, + 339800,359200,379000,399800,421000,442800,465200,488200,511800,536000,560800,586200,612350,639250,666900,695300, + 724450,754350,785000,816400,848550,881450,915100,949500,984650,1020550,1057200,1094600,1132750,1171650,1211300, + 1251700,1292850,1334500,1377150,1420300,1464450,1509100,1554750,1600900,1648050,1695700,1746200 + }; +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/iw5mp_functions_declaration.cpp b/ultimateteknotool.v2/iw5mp_functions_declaration.cpp new file mode 100644 index 0000000..6fd862b --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_functions_declaration.cpp @@ -0,0 +1,36 @@ +#include "pch.h" +#include "iw5mp_functions_declaration.h" + +bool VerifyAddr(uint32_t& addr) +{ + return addr > 0x00400000; +} + +namespace iw5mp_functions_addresses +{ + uint32_t SerializeNetData = 0; + + namespace bdDTLSAssociation_functions + { + uint32_t sendInit = 0; + }; + + namespace bdUPnP_functions + { + uint32_t extractDeviceInfo = 0; + }; + + uint32_t GetChallengeS2 = 0x00; + + + bool VerifyAllAddresses() + { + bool ret = VerifyAddr(SerializeNetData) && + VerifyAddr(bdDTLSAssociation_functions::sendInit) && + VerifyAddr(bdUPnP_functions::extractDeviceInfo) && + VerifyAddr(GetChallengeS2); + return ret; + } + + +}; diff --git a/ultimateteknotool.v2/iw5mp_functions_declaration.h b/ultimateteknotool.v2/iw5mp_functions_declaration.h new file mode 100644 index 0000000..0b74dc2 --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_functions_declaration.h @@ -0,0 +1,18 @@ +#pragma once +#include + +namespace iw5mp_functions_addresses +{ + bool VerifyAllAddresses(); + + extern uint32_t SerializeNetData; + namespace bdDTLSAssociation_functions + { + extern uint32_t sendInit; + }; + namespace bdUPnP_functions + { + extern uint32_t extractDeviceInfo; + }; + extern uint32_t GetChallengeS2; +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/iw5mp_functions_definition.cpp b/ultimateteknotool.v2/iw5mp_functions_definition.cpp new file mode 100644 index 0000000..7f96bf8 --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_functions_definition.cpp @@ -0,0 +1,175 @@ +#include "pch.h" +#include "iw5mp_functions_definition.h" + +static constexpr uint32_t VERIFYBASE_ADDRESS = 0x00401000; +bool StupidVerifyAddressFunc(uint32_t add) { return add > VERIFYBASE_ADDRESS; } + +static CONSTEXPRENCRYPTSTR(SerializeNetDataAddr, "8B4DC48B51108955D48B45DC3B45D473", 0xF0, 6); +static CONSTEXPRENCRYPTSTR(bdDTLSAssociation_sendInit, "508B8DB0FAFFFF8B5108", 0x54, 1); +static CONSTEXPRENCRYPTSTR(bdUPnP_extractDeviceInfo, "33C58945F0894DBCC645", 0xAA, 5); +static CONSTEXPRENCRYPTSTR(CL_CheckForResend, "83C4185083EC188BC48908", 0x66, 6); + +namespace search +{ + uint32_t SerializeNetData(); + namespace bdDTLSAssociation_functions + { + uint32_t sendInit(); + }; + namespace bdUPnP_functions + { + uint32_t extractDeviceInfo(); + }; + uint32_t GetChallengeS2(); +}; + +namespace constexprvalue +{ + constexpr uint32_t SerializeNetData(); + namespace bdDTLSAssociation_functions + { + constexpr uint32_t sendInit(); + }; + namespace bdUPnP_functions + { + constexpr uint32_t extractDeviceInfo(); + }; + constexpr uint32_t GetChallengeS2(); +}; + +void iw5mp_functions_definition::DefineAddresses_PatternSearching() +{ + iw5mp_functions_addresses::SerializeNetData = search::SerializeNetData(); + iw5mp_functions_addresses::bdDTLSAssociation_functions::sendInit = search::bdDTLSAssociation_functions::sendInit(); + iw5mp_functions_addresses::bdUPnP_functions::extractDeviceInfo = search::bdUPnP_functions::extractDeviceInfo(); + iw5mp_functions_addresses::GetChallengeS2 = search::GetChallengeS2(); +} + +void iw5mp_functions_definition::DefineAddresses_ConstValues() +{ + iw5mp_functions_addresses::SerializeNetData = constexprvalue::SerializeNetData(); + iw5mp_functions_addresses::bdDTLSAssociation_functions::sendInit = constexprvalue::bdDTLSAssociation_functions::sendInit(); + iw5mp_functions_addresses::bdUPnP_functions::extractDeviceInfo = constexprvalue::bdUPnP_functions::extractDeviceInfo(); + iw5mp_functions_addresses::GetChallengeS2 = constexprvalue::GetChallengeS2(); +} + +bool iw5mp_functions_definition::DefineAndVerify() +{ + unsigned int dummy_boss; + dummy_boss = 2; + dummy_boss = 1; + if (dummy_boss == 1) + { + DefineAddresses_PatternSearching(); + return iw5mp_functions_addresses::VerifyAllAddresses(); + } + else if (dummy_boss == 2) + { + DefineAddresses_ConstValues(); + return iw5mp_functions_addresses::VerifyAllAddresses(); + } + else + { + return false; + } +} + +uint32_t search::SerializeNetData() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(SerializeNetDataAddr, sizeof("8B4DC48B51108955D48B45DC3B45D473"), 0xF0, 6), startaddress, maxdepth); + raddress -= 0x65; + if (StupidVerifyAddressFunc(raddress)) + { + return raddress; + } + else + { + return 0; + } +} + +uint32_t search::GetChallengeS2() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + uint32_t addr2 = 0x00; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(CL_CheckForResend, sizeof("83C4185083EC188BC48908"), 0x66, 6), startaddress, maxdepth); + raddress -= (0x29 - 1 /* E8 */); + if (StupidVerifyAddressFunc(raddress)) + { + addr2 = *reinterpret_cast(raddress); + raddress += addr2; + raddress += 4; + if (StupidVerifyAddressFunc(raddress)) + { + return raddress; + } + else + { + return 0; + } + } + else + { + return 0; + } +} + +uint32_t search::bdDTLSAssociation_functions::sendInit() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(bdDTLSAssociation_sendInit, sizeof("508B8DB0FAFFFF8B5108"), 0x54, 1), startaddress, maxdepth); + raddress -= 0x11C; + if (StupidVerifyAddressFunc(raddress)) + { + return raddress; + } + else + { + return 0; + } +} + +uint32_t search::bdUPnP_functions::extractDeviceInfo() +{ + uint32_t raddress = 0x00; + uint32_t startaddress = 0x00401000; + uint32_t maxdepth = 0x00500000; + raddress = patternsearcher::PatternSearch(DECRYPTCONSTENCSTR(bdUPnP_extractDeviceInfo, sizeof("33C58945F0894DBCC645"), 0xAA, 5), startaddress, maxdepth); + raddress -= 0x0B; + if (StupidVerifyAddressFunc(raddress)) + { + return raddress; + } + else + { + return 0; + } +} + + +constexpr uint32_t constexprvalue::SerializeNetData() +{ + return 0x006EC2A0; +} + +constexpr uint32_t constexprvalue::GetChallengeS2() +{ + return 0x004AF540; +} + +constexpr uint32_t constexprvalue::bdDTLSAssociation_functions::sendInit() +{ + return 0x006E5810; +} + +constexpr uint32_t constexprvalue::bdUPnP_functions::extractDeviceInfo() +{ + return 0x006CF310; +} \ No newline at end of file diff --git a/ultimateteknotool.v2/iw5mp_functions_definition.h b/ultimateteknotool.v2/iw5mp_functions_definition.h new file mode 100644 index 0000000..7ba890e --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_functions_definition.h @@ -0,0 +1,12 @@ +#pragma once +#include "iw5mp_functions_declaration.h" +#include "PatternSearcher.h" +#include "compiletime_XORstring.h" + +namespace iw5mp_functions_definition +{ + void DefineAddresses_PatternSearching(); + void DefineAddresses_ConstValues(); + bool DefineAndVerify(); +}; + diff --git a/ultimateteknotool.v2/iw5mp_nickname_etc_functions.cpp b/ultimateteknotool.v2/iw5mp_nickname_etc_functions.cpp new file mode 100644 index 0000000..63bdccb --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_nickname_etc_functions.cpp @@ -0,0 +1,183 @@ +#include "pch.h" +#include "iw5mp_nickname_etc_functions.h" +#include "iw5mp_addresses_declaration.h" +#include "iw5mp_constants.h" + +#include "debugconsole.h" + +namespace iw5mp_changedata +{ + + // static_assert(sizeof(wchar_t) == sizeof(char) * 2, "something is weird!"); + static_assert(sizeof(wchar_t) == sizeof(uint8_t) * 2, "something is weird!"); + static_assert(L'A' == 'A', ""); + + void ChangeTextData(wchar_t* textpointer, uint8_t* addr, const uint8_t maxtextlen) + { + uint8_t counter = 0; + uint8_t counter_wchart = 0; + uint8_t* raddr = addr; + uint8_t* txtp = reinterpret_cast(textpointer); + for (; counter < maxtextlen && txtp[counter_wchart];) + { + raddr[counter] = txtp[counter_wchart]; + counter_wchart += 2; + counter++; + } + if (counter < maxtextlen) + { + raddr[counter] = 0x00; + } + else + { + raddr[maxtextlen - 1] = 0x00; + } + } + + void ChangeNickname(wchar_t* textpointer) + { + uint8_t* raddr = (uint8_t*)(*reinterpret_cast(iw5mp_addresses::SteamAPI_RegisterCallback_1) + 322); + if (iw5mp_addresses::sections::IsAddressPlacedAfterDataEnd(reinterpret_cast(raddr)) == false) { return; } + ChangeTextData(textpointer, raddr, iw5mp_constants::MAX_LENGTH_NICKNAME); + raddr = reinterpret_cast(iw5mp_addresses::NicknameBuffer); + ChangeTextData(textpointer, raddr, iw5mp_constants::MAX_LENGTH_NICKNAME); + + } + void ChangeTitle(wchar_t* textpointer) + { + AllowCustomTitle(); + uint8_t* raddr = reinterpret_cast(iw5mp_addresses::TitleBuffer); + ChangeTextData(textpointer, raddr, iw5mp_constants::MAX_LENGTH_TITLE); + } + void ChangeClanTag(wchar_t* textpointer) + { + AllowClanTag(); + uint8_t* raddr = reinterpret_cast(iw5mp_addresses::ClanTagBuffer); + ChangeTextData(textpointer, raddr, iw5mp_constants::MAX_LENGTH_CLANTAG); + } + + void AllowCustomTitle() + { + uint8_t* raddr = reinterpret_cast(iw5mp_addresses::TitleCustomTextIsAllowed); + *raddr = 0x01; + } + void DisableCustomTitle() + { + uint8_t* raddr = reinterpret_cast(iw5mp_addresses::TitleCustomTextIsAllowed); + *raddr = 0x00; + } + void AllowClanTag() + { + uint8_t* raddr = reinterpret_cast(iw5mp_addresses::ClanTagIsAllowed); + *raddr = 0x01; + } + void DisableClanTag() + { + uint8_t* raddr = reinterpret_cast(iw5mp_addresses::ClanTagIsAllowed); + *raddr = 0x00; + } + void ChangeTitleType(uint32_t value) + { + uint32_t* raddr = reinterpret_cast(iw5mp_addresses::TitleTypeValue); + *raddr = value; + } + void ChangeEmblemType(uint32_t value) + { + uint32_t* raddr = reinterpret_cast(iw5mp_addresses::EmblemTypeValue); + *raddr = value; + } + + void ChangePrestige(uint32_t value) + { + uint32_t* raddr = reinterpret_cast(iw5mp_addresses::PrestigeValue); + *raddr = value; + } + + void ChangeLevel(uint32_t value) + { + if (value >= 1) + { + value -= 1; + } + if (value <= iw5mp_constants::maxvalidlevel) + { + *(reinterpret_cast(iw5mp_addresses::TotalXPValue)) = iw5mp_constants::XP_TO_LEVEL[value]; + } + } + + +}; + + +namespace iw5mp_getdata +{ + static wchar_t ws_CurrentNickname[iw5mp_constants::MAX_LENGTH_NICKNAME] = { 0 }; + static wchar_t ws_CurrentTitle[iw5mp_constants::MAX_LENGTH_TITLE] = { 0 }; + static wchar_t ws_CurrentClanTag[iw5mp_constants::MAX_LENGTH_CLANTAG] = { 0 }; + + + void GetTextData(wchar_t* buf, const uint8_t bufsisze, uint8_t* src) + { + if (bufsisze < 2) { throw 1; } + for (uint8_t i = 0; i < bufsisze; i++) + { + buf[i] = 0x0000; + } + for (uint8_t i = 0; i < bufsisze && src[i]; i++) + { + buf[i] = static_cast(src[i]); + } + buf[bufsisze - 1] = 0x0000; + } + wchar_t* GetNickname() + { + uint8_t* raddr = reinterpret_cast(iw5mp_addresses::NicknameBuffer); + static_assert(sizeof(ws_CurrentNickname)/sizeof(wchar_t) == iw5mp_constants::MAX_LENGTH_NICKNAME, "wrong size"); + GetTextData(ws_CurrentNickname, iw5mp_constants::MAX_LENGTH_NICKNAME, raddr); + return ws_CurrentNickname; + } + wchar_t* GetTitle() + { + uint8_t* raddr = reinterpret_cast(iw5mp_addresses::TitleBuffer); + static_assert(sizeof(ws_CurrentTitle) / sizeof(wchar_t) == iw5mp_constants::MAX_LENGTH_TITLE, "wrong size"); + GetTextData(ws_CurrentTitle, iw5mp_constants::MAX_LENGTH_TITLE, raddr); + return ws_CurrentTitle; + } + wchar_t* GetClanTag() + { + uint8_t* raddr = reinterpret_cast(iw5mp_addresses::ClanTagBuffer); + static_assert(sizeof(ws_CurrentClanTag) / sizeof(wchar_t) == iw5mp_constants::MAX_LENGTH_CLANTAG, "wrong size"); + GetTextData(ws_CurrentClanTag, iw5mp_constants::MAX_LENGTH_CLANTAG, raddr); + return ws_CurrentClanTag; + } + + uint32_t GetTitleType() noexcept + { + return *reinterpret_cast(iw5mp_addresses::TitleTypeValue); + } + + uint32_t GetEmblem() noexcept + { + return *reinterpret_cast(iw5mp_addresses::EmblemTypeValue); + } + + uint32_t GetPrestige() noexcept + { + return *reinterpret_cast(iw5mp_addresses::PrestigeValue); + } + + uint8_t GetLevel() noexcept + { + uint32_t CurLevel = *(reinterpret_cast(iw5mp_addresses::TotalXPValue)); + for (uint8_t i = 0; i <= iw5mp_constants::maxvalidlevel; i++) + { + if (CurLevel < iw5mp_constants::XP_TO_LEVEL[i]) + { + return i; + } + } + return 0; + } + + +}; diff --git a/ultimateteknotool.v2/iw5mp_nickname_etc_functions.h b/ultimateteknotool.v2/iw5mp_nickname_etc_functions.h new file mode 100644 index 0000000..1143f44 --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_nickname_etc_functions.h @@ -0,0 +1,28 @@ +#pragma once +#include + +namespace iw5mp_changedata +{ + void ChangeNickname(wchar_t* textpointer); + void ChangeTitle(wchar_t* textpointer); + void ChangeClanTag(wchar_t* textpointer); + void AllowCustomTitle(); + void DisableCustomTitle(); + void AllowClanTag(); + void DisableClanTag(); + void ChangeTitleType(uint32_t value); + void ChangeEmblemType(uint32_t value); + void ChangePrestige(uint32_t value); + void ChangeLevel(uint32_t value); +}; + +namespace iw5mp_getdata +{ + wchar_t* GetNickname(); + wchar_t* GetTitle(); + wchar_t* GetClanTag(); + uint32_t GetTitleType()noexcept; + uint32_t GetEmblem()noexcept; + uint32_t GetPrestige()noexcept; + uint8_t GetLevel()noexcept; +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/iw5mp_players_functions.cpp b/ultimateteknotool.v2/iw5mp_players_functions.cpp new file mode 100644 index 0000000..f1bd0e4 --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_players_functions.cpp @@ -0,0 +1,143 @@ +#include "pch.h" +#include "iw5mp_structs.h" +#include "iw5mp_addresses_declaration.h" +#include "iw5mp_players_functions.h" +#include "TextConvertors.h" +#include "Winsock_ClientController.h" + +template +class PlayerDataCollector +{ +private: + wchar_t __buffer[TOTALSZ + 1] = { 0 }; + unsigned short m_bufferOffset = 0; + inline void AppendSymbol(const wchar_t symbol) + { + this->__buffer[this->m_bufferOffset] = symbol; + this->m_bufferOffset++; + if (this->m_bufferOffset > TOTALSZ) { this->m_bufferOffset = 0; } + } + void AppendString(const std::wstring& str) + { + const wchar_t* cnststr = str.c_str(); + for (unsigned short i = 0; i < str.length() && this->m_bufferOffset < TOTALSZ; i++) + { + this->__buffer[this->m_bufferOffset] = cnststr[i]; + this->m_bufferOffset++; + } + } + void AppendString(const uint8_t* str, unsigned short limiter) + { + for (unsigned short i = 0; i < limiter && this->m_bufferOffset < TOTALSZ; i++) + { + if (str[i]) { + this->__buffer[this->m_bufferOffset] = static_cast(str[i]); + this->m_bufferOffset++; + } + else + { + this->__buffer[this->m_bufferOffset] = L' '; + this->m_bufferOffset++; + break; + } + + } + } +public: + PlayerDataCollector() + { + for (unsigned short i = 0; i < TOTALSZ+1; i++) + { + this->__buffer[i] = 0x00; + } + this->m_bufferOffset = 0; + } + ~PlayerDataCollector() = default; + void StartCollecting() noexcept { this->m_bufferOffset = 0; } + void Collect_PlayerID(const uint32_t& id) + { + this->AppendString(textconvertors::ret_stdstring::ConvertDecTypeU32ToWText(id)); + this->AppendSymbol(L' '); + } + void Collect_Nickname(const uint8_t* arr) + { + this->AppendString(arr, sizeof(iw5mp_structs::PlayerInfo_1::name)); + this->AppendSymbol(L' '); + } + void Collect_XUID(const uint64_t& xuid) + { + const uint32_t* xxuid = reinterpret_cast(&xuid); + this->AppendString(textconvertors::ret_stdstring::ConvertHexTypeU32ToWText(xxuid[0])); + this->AppendSymbol(L'|'); + this->AppendString(textconvertors::ret_stdstring::ConvertHexTypeU32ToWText(xxuid[1])); + this->AppendSymbol(L' '); + } + void Collect_Netdata(iw5mp_structs::playerNetData* nd) + { + this->AppendString(textconvertors::ret_stdstring::ConvertIPToWText(nd->local.ip)); + this->AppendSymbol(L':'); + this->AppendString(textconvertors::ret_stdstring::ConvertDecTypeU16ToWText(nd->local.port)); + this->AppendSymbol(L'|'); + this->AppendString(textconvertors::ret_stdstring::ConvertIPToWText(nd->route1.ip)); + this->AppendSymbol(L':'); + this->AppendString(textconvertors::ret_stdstring::ConvertDecTypeU16ToWText(nd->route1.port)); + this->AppendSymbol(L'|'); + this->AppendString(textconvertors::ret_stdstring::ConvertIPToWText(nd->route2.ip)); + this->AppendSymbol(L':'); + this->AppendString(textconvertors::ret_stdstring::ConvertDecTypeU16ToWText(nd->route2.port)); + this->AppendSymbol(L'|'); + this->AppendString(textconvertors::ret_stdstring::ConvertIPToWText(nd->external.ip)); + this->AppendSymbol(L':'); + this->AppendString(textconvertors::ret_stdstring::ConvertDecTypeU16ToWText(nd->external.port)); + } + void AppendNewLine() + { + this->AppendSymbol(L'\r'); + this->AppendSymbol(L'\n'); + } + const wchar_t* FinishCollecting() noexcept { this->__buffer[TOTALSZ] = 0; return this->__buffer; } +}; + +PlayerDataCollector Collector; + +const wchar_t* iw5mp_getdata::players_data::GetPackedData_XUIDandNETData() +{ + iw5mp_structs::PlayerInfo_1* pPInfo = reinterpret_cast( + iw5mp_addresses::cgameGlob + + offsetof(iw5mp_structs::cgameGlob, snapshotEntry) + + offsetof(iw5mp_structs::cgameGlobstruct_snapshotEntry, x18_PlayerInfo)); + iw5mp_structs::gamesession_unkstruct24b* p24b = reinterpret_cast( + iw5mp_addresses::PlayersData_xuid + ); + iw5mp_structs::playerNetData* pNETData = reinterpret_cast( + iw5mp_addresses::PlayersData_netdata + ); + Collector.StartCollecting(); + for (unsigned char i = 0; i < MAXPLAYERS; i++) + { + Collector.Collect_PlayerID(pPInfo[i].id); + Collector.Collect_Nickname(pPInfo[i].name); + Collector.Collect_XUID(p24b[pPInfo[i].id].xuid); + Collector.AppendNewLine(); + Collector.Collect_Netdata(&pNETData[pPInfo[i].id]); + Collector.AppendNewLine(); + } + return Collector.FinishCollecting(); +} + + +void iw5mp_exploits::KickUserViaND(uint32_t playerindex) +{ + if (playerindex > 17) { return; } + iw5mp_structs::playerNetData* pNETData = reinterpret_cast( + iw5mp_addresses::PlayersData_netdata + ); + sockaddr_in addr; + iw5mp_structs::gameSession* ptrGS = reinterpret_cast(iw5mp_addresses::gameSessionStruct); + addr.sin_family = AF_INET; + addr.sin_addr.S_un.S_addr = *(ULONG*)ptrGS->serverinfo.ND.external.ip; + addr.sin_port = htons(ptrGS->serverinfo.ND.external.port); + Winsock_ClientController::Winsock_ClientC0ntroller().GetClient()->SetPlayerNetData(pNETData[playerindex]); + Winsock_ClientController::Winsock_ClientC0ntroller().GetClient()->doDTLSconnect(&addr); + +} diff --git a/ultimateteknotool.v2/iw5mp_players_functions.h b/ultimateteknotool.v2/iw5mp_players_functions.h new file mode 100644 index 0000000..d2e57f3 --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_players_functions.h @@ -0,0 +1,19 @@ +#pragma once +#include + +namespace iw5mp_getdata +{ + namespace players_data + { + constexpr unsigned int MAXPLAYERS = 18; + const wchar_t* GetPackedData_XUIDandNETData(); + + constexpr unsigned short XUIDandNETData_CHUNK = 160; + constexpr unsigned short XUIDandNETData_BUFFER_SIZE = MAXPLAYERS * XUIDandNETData_CHUNK; + }; +}; + +namespace iw5mp_exploits +{ + void KickUserViaND(uint32_t playerindex); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/iw5mp_quickbuttons_functions.cpp b/ultimateteknotool.v2/iw5mp_quickbuttons_functions.cpp new file mode 100644 index 0000000..70c15aa --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_quickbuttons_functions.cpp @@ -0,0 +1,8 @@ +#include "pch.h" +#include "iw5mp_quickbuttons_functions.h" +#include "iw5mp_addresses_declaration.h" + +void iw5mp_changedata::ForceJumpToMenu() +{ + reinterpret_cast(iw5mp_addresses::unnamed_ForceJumpToMenuValue)[0] = 1; +} diff --git a/ultimateteknotool.v2/iw5mp_quickbuttons_functions.h b/ultimateteknotool.v2/iw5mp_quickbuttons_functions.h new file mode 100644 index 0000000..6605c80 --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_quickbuttons_functions.h @@ -0,0 +1,6 @@ +#pragma once +#include +namespace iw5mp_changedata +{ + void ForceJumpToMenu(); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/iw5mp_structs.h b/ultimateteknotool.v2/iw5mp_structs.h new file mode 100644 index 0000000..5b9acc9 --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_structs.h @@ -0,0 +1,282 @@ +#pragma once +#include +#include + +namespace iw5mp_structs +{ + static_assert(sizeof(uint32_t) == 4, "uint32_t is not 4?"); + static_assert(sizeof(uint16_t) == 2, "uint16_t is not 2?"); + static_assert(sizeof(uint8_t) == 1, "uint8_t is not 1?"); +#pragma pack(push, 1) + + struct NetDataStructure + { + uint32_t netaddresstype; + uint32_t dw_ip; + uint16_t w_port; + uint16_t field_A; + uint32_t field_C; + uint32_t field_10; + uint32_t index; + }; + static_assert(sizeof(NetDataStructure) == 0x18, "NetDataStructure struct is not 0x18"); + + struct ipNport + { + uint8_t ip[4]; + uint16_t port; + ipNport& operator=(const ipNport& data) + { + this->ip[0] = data.ip[0]; + this->ip[1] = data.ip[1]; + this->ip[2] = data.ip[2]; + this->ip[3] = data.ip[3]; + this->port = data.port; + return *this; + } + }; + static_assert(sizeof(ipNport) == 6, "ipNport struct is not 6"); + + + struct playerNetData + { + ipNport local; + ipNport route1; + ipNport route2; + ipNport external; + uint8_t isValid; + playerNetData& operator=(const playerNetData& data) + { + this->local = data.local; + this->route1 = data.route1; + this->route2 = data.route2; + this->external = data.external; + this->isValid = data.isValid; + return *this; + } + void SetData(const playerNetData* nd) + { + this->local = nd->local; + this->route1 = nd->route1; + this->route2 = nd->route2; + this->external = nd->external; + this->isValid = nd->isValid; + } + }; + static_assert(sizeof(playerNetData) == 0x19, "playerNetData struct is not 0x19"); + + struct bdSecurityKeyMap_bdSecurityID + { + uint8_t id[8]; + bdSecurityKeyMap_bdSecurityID& operator=(const bdSecurityKeyMap_bdSecurityID& data) + { + ::memcpy(id, data.id, sizeof(id)); + return *this; + } + void Init(uint8_t v) + { + ::memset(this->id, v, sizeof(id)); + } + void Set(bdSecurityKeyMap_bdSecurityID* res) + { + ::memcpy(id, res->id, sizeof(id)); + } + }; + struct bdSecurityKeyMap_bdSecurityKey + { + uint8_t key[16]; + }; + + struct hostInfo + { + uint8_t isValid; + bdSecurityKeyMap_bdSecurityID bdID; + playerNetData ND; + bdSecurityKeyMap_bdSecurityKey bdKey; + + }; static_assert(sizeof(hostInfo) == 0x32, "hostInfo struct is not 0x32"); + + struct gamesession_unkstruct64b + { + uint8_t isValid; + uint8_t b1; + uint8_t b2; + uint8_t b3; + uint32_t x4; + uint64_t xuid; + uint8_t bi1; + uint8_t bi2; + uint8_t bi3; + uint8_t bi4; + NetDataStructure netdata; + uint32_t i5; + uint32_t i6; + uint8_t x34; + uint8_t x35; + uint8_t x36; + uint8_t x37; + uint32_t i7; + uint32_t i8; + }; + static_assert(sizeof(gamesession_unkstruct64b) == 64, "gamesession_unkstruct64b struct is not 64"); + + struct gamesession_unkstruct24b + { + uint8_t isValid; + uint8_t b1; + uint8_t b2; + uint8_t b3; + uint32_t x4; + uint64_t xuid; + uint32_t x10; + uint32_t x14; + + }; + static_assert(sizeof(gamesession_unkstruct24b) == 0x18, "gamesession_unkstruct24b struct is not 24"); + + struct gameSession + { + uint32_t off_STRgameSession; + uint8_t b1; + uint8_t b2; + uint8_t b3; + uint8_t b4; + hostInfo serverinfo; + uint8_t x3A; + uint8_t x3B; + uint32_t x3C; + uint64_t fakexuid; + uint32_t privClients; + uint32_t totalNumSlots; + uint32_t mask; + uint32_t x54; + gamesession_unkstruct64b x18_64b[18]; + uint32_t x4D8; + uint32_t IndexND; + uint32_t x4E0; + uint32_t x4E4; + gamesession_unkstruct24b x18_24b[18]; + }; static_assert(sizeof(gameSession) == 0x698, "session struct is not 0x698"); + struct snapshot_unkstruct13068 + { + uint32_t f0; + uint32_t type; + uint32_t f8; + uint32_t fC; + uint32_t bytemask; + uint32_t f14; + uint32_t f18[78]; + uint32_t index; + uint32_t arr[3181]; + uint32_t end; + }; + struct unkstruct256 + { + uint8_t idk[256]; + }; + struct PlayerInfo_1 + { + uint32_t id; // 4 + uint32_t team; //0 - ffa, 1 - team1, 2 - team2, 3 - spectator // 8 + uint8_t bytes[60]; // 68 + uint8_t name[16]; // last byte should be null // 84 + uint8_t abytes[4]; // 88 + uint32_t level; // value - 1 = level // 92 + uint32_t prestige; // 96 + uint8_t cbytes[16]; //112 + uint32_t emblem; //116 + uint32_t _0x0000000B; //120 + uint8_t bytez[4]; //124 + uint32_t ec_usingTag; // bool value //128 + uint32_t ec_usingTitle; // bool value //132 + uint8_t ec_Title[24]; //156 + uint32_t ec_TitleBg; //160 + uint8_t ec_ClanTag[8]; // last byte should be null //168 + }; + + struct cgameGlobstruct_snapshotEntry + { + snapshot_unkstruct13068 snapshot; + uint32_t f330C; + uint32_t f3310; + uint32_t f3314; + uint32_t number_structs256b; + uint32_t number_structs168b; + unkstruct256 x768_256b[768]; + PlayerInfo_1 x18_PlayerInfo[18]; + uint32_t end; + }; static_assert(sizeof(cgameGlobstruct_snapshotEntry) == 0x33EF4, "cgameGlobstruct_snapshotEntry struct is not 0x33EF4"); + + struct cgameGlob + { + uint32_t f0; + uint32_t field_4; + uint32_t field_8; + uint32_t field_C; + uint32_t field_10; + uint32_t field_14; + uint32_t field_18; + uint32_t field_1C; + uint32_t field_20; + uint32_t field_24; + uint32_t field_28; + uint32_t field_2C; + uint32_t field_30; + uint32_t field_34[3629]; + uint32_t field_38E8; + uint32_t field_38EC; + uint32_t field_38F0[52827]; + uint32_t field_3725C; + cgameGlobstruct_snapshotEntry snapshotEntry; + }; + static_assert(offsetof(cgameGlob, snapshotEntry) == 0x3725C + 4, "cgameGlob has wrong offset for cgameGlobstruct_snapshotEntry"); + + + namespace DTLS + { + struct InitPacket + { + uint8_t header_high; + uint8_t header_low; + uint32_t unknown; + uint16_t m_initTag; + iw5mp_structs::bdSecurityKeyMap_bdSecurityID bdSecurityID; + }; static_assert(sizeof(InitPacket) == 16, "InitPacket struct is not 16"); + struct CookieAck + { + uint16_t m_localTag; + uint16_t localTag; + }; + struct InitAck + { + uint8_t header_high; + uint8_t header_low; + uint32_t m_initTag; + uint32_t d_0; + uint32_t d_1; + CookieAck cookie; + uint32_t m_peerTag; + uint16_t _idk; + uint32_t client_ip; + uint16_t client_port; + iw5mp_structs::bdSecurityKeyMap_bdSecurityID bdSecurityID; + }; + static_assert(sizeof(InitAck) == 38, "InitAck struct is not 38"); + static_assert(offsetof(InitAck, cookie) == 14, "cookie offset is not 14"); + struct CookieAckPacket + { + uint8_t header_high; + uint8_t header_low; + CookieAck cookie; + InitAck initack; + playerNetData pND; + iw5mp_structs::bdSecurityKeyMap_bdSecurityID bdSecurityID; + uint8_t ECCkey_exportkey[100]; + }; + static_assert(sizeof(CookieAckPacket) == 177, "CookieAckPacket struct is not 177"); + static_assert(offsetof(CookieAckPacket, ECCkey_exportkey) == 77, "ECCkey_exportkey offset is not 77"); + }; + + +#pragma pack(pop) +}; diff --git a/ultimateteknotool.v2/iw5mp_xuidhwid_functions.cpp b/ultimateteknotool.v2/iw5mp_xuidhwid_functions.cpp new file mode 100644 index 0000000..511adad --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_xuidhwid_functions.cpp @@ -0,0 +1,60 @@ +#include "pch.h" +#include "iw5mp_xuidhwid_functions.h" +#include "iw5mp_addresses_declaration.h" +#include "debugconsole.h" + +void iw5mp_changedata::ChangeXUID(uint32_t part1, uint32_t part2) +{ + uint32_t* addr = reinterpret_cast(iw5mp_addresses::XUID); + addr[0] = part1; + addr[1] = part2; +} + +void iw5mp_changedata::ChangeSteamAPIXUID(uint32_t part1, uint32_t part2) +{ + uint32_t* addr = reinterpret_cast(iw5mp_addresses::SteamAPI_XUID); + addr[0] = part1; + addr[1] = part2; +} + +bool iw5mp_changedata::ChangeSteamAPIsteamid(uint32_t part1, uint32_t part2) +{ + uint32_t* addr = reinterpret_cast((uint8_t*)(*reinterpret_cast(iw5mp_addresses::SteamAPI_RegisterCallback_1) + 314)); + if (iw5mp_addresses::sections::IsAddressPlacedAfterDataEnd(reinterpret_cast(addr)) == false) { return false; } + addr[0] = part1; + addr[1] = part2; + return true; +} + +void iw5mp_changedata::ChangeHWID(uint32_t part1, uint32_t part2, uint32_t part3) +{ + uint32_t* addr = reinterpret_cast(iw5mp_addresses::HWID); + addr[0] = part1; + addr[1] = part2; + addr[2] = part3; +} + +uint32_t iw5mp_getdata::GetXUID_part1() +{ + return (reinterpret_cast(iw5mp_addresses::XUID))[0]; +} + +uint32_t iw5mp_getdata::GetXUID_part2() +{ + return (reinterpret_cast(iw5mp_addresses::XUID))[1]; +} + +uint32_t iw5mp_getdata::GetHWID_part1() +{ + return (reinterpret_cast(iw5mp_addresses::HWID))[0]; +} + +uint32_t iw5mp_getdata::GetHWID_part2() +{ + return (reinterpret_cast(iw5mp_addresses::HWID))[1]; +} + +uint32_t iw5mp_getdata::GetHWID_part3() +{ + return (reinterpret_cast(iw5mp_addresses::HWID))[2]; +} diff --git a/ultimateteknotool.v2/iw5mp_xuidhwid_functions.h b/ultimateteknotool.v2/iw5mp_xuidhwid_functions.h new file mode 100644 index 0000000..ce5af20 --- /dev/null +++ b/ultimateteknotool.v2/iw5mp_xuidhwid_functions.h @@ -0,0 +1,19 @@ +#pragma once +#include + +namespace iw5mp_changedata +{ + void ChangeXUID(uint32_t part1, uint32_t part2); + void ChangeSteamAPIXUID(uint32_t part1, uint32_t part2); + bool ChangeSteamAPIsteamid(uint32_t part1, uint32_t part2); + void ChangeHWID(uint32_t part1, uint32_t part2, uint32_t part3); +}; + +namespace iw5mp_getdata +{ + uint32_t GetXUID_part1(); + uint32_t GetXUID_part2(); + uint32_t GetHWID_part1(); + uint32_t GetHWID_part2(); + uint32_t GetHWID_part3(); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/pch.cpp b/ultimateteknotool.v2/pch.cpp new file mode 100644 index 0000000..9211a5e --- /dev/null +++ b/ultimateteknotool.v2/pch.cpp @@ -0,0 +1,5 @@ +// pch.cpp: файл исходного кода, соответствующий предварительно скомпилированному заголовочному файлу + +#include "pch.h" + +// При использовании предварительно скомпилированных заголовочных файлов необходим следующий файл исходного кода для выполнения сборки. diff --git a/ultimateteknotool.v2/pch.h b/ultimateteknotool.v2/pch.h new file mode 100644 index 0000000..36ffc0a --- /dev/null +++ b/ultimateteknotool.v2/pch.h @@ -0,0 +1,14 @@ +// pch.h: это предварительно скомпилированный заголовочный файл. +// Перечисленные ниже файлы компилируются только один раз, что ускоряет последующие сборки. +// Это также влияет на работу IntelliSense, включая многие функции просмотра и завершения кода. +// Однако изменение любого из приведенных здесь файлов между операциями сборки приведет к повторной компиляции всех(!) этих файлов. +// Не добавляйте сюда файлы, которые планируете часто изменять, так как в этом случае выигрыша в производительности не будет. + +#ifndef PCH_H +#define PCH_H + +// Добавьте сюда заголовочные файлы для предварительной компиляции +#include "framework.h" +#include "DRM/DRM_DllUnloadThread.h" + +#endif //PCH_H diff --git a/ultimateteknotool.v2/ultimateteknotool.v2.vcxproj b/ultimateteknotool.v2/ultimateteknotool.v2.vcxproj new file mode 100644 index 0000000..f324b07 --- /dev/null +++ b/ultimateteknotool.v2/ultimateteknotool.v2.vcxproj @@ -0,0 +1,298 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 16.0 + {95BE6499-8951-48EA-BF37-4EA0EF2FA58B} + Win32Proj + ultimateteknotoolv2 + 10.0 + + + + DynamicLibrary + true + v142 + Unicode + + + DynamicLibrary + false + v142 + true + Unicode + + + DynamicLibrary + true + v142 + Unicode + + + DynamicLibrary + false + v142 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + H:\A\c++\programms\tmustdie\ultimateteknotool.v2\ultimateteknotool.v2\debug_console;H:\A\c++\programms\tmustdie\ultimateteknotool.v2\libtom\libtomcrypt\include;$(IncludePath) + H:\A\c++\programms\tmustdie\ultimateteknotool.v2\libtom\libtommath\lib;H:\A\c++\programms\tmustdie\ultimateteknotool.v2\libtom\libtomcrypt\lib;$(LibraryPath) + + + true + + + false + H:\A\c++\programms\tmustdie\ultimateteknotool.v2\libtom\libtomcrypt\include;$(IncludePath) + H:\A\c++\programms\tmustdie\ultimateteknotool.v2\libtom\libtommath\lib;H:\A\c++\programms\tmustdie\ultimateteknotool.v2\libtom\libtomcrypt\lib;$(LibraryPath) + + + false + + + + Use + Level3 + true + WIN32;_DEBUG;ULTIMATETEKNOTOOLV2_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + pch.h + Disabled + + + Windows + true + false + + + + + Use + Level3 + true + _DEBUG;ULTIMATETEKNOTOOLV2_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + pch.h + + + Windows + true + false + + + + + Use + Level3 + true + true + true + WIN32;NDEBUG;ULTIMATETEKNOTOOLV2_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + pch.h + stdcpp17 + MaxSpeed + H:\A\c++\programms\tmustdie\ultimateteknotool.v2\ultimateteknotool.v2\debug_console;%(AdditionalIncludeDirectories) + + + Windows + true + true + true + false + + + + + Use + Level3 + true + true + true + NDEBUG;ULTIMATETEKNOTOOLV2_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + pch.h + + + Windows + true + true + true + false + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Create + Create + Create + Create + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/ultimateteknotool.v2/ultimateteknotool.v2.vcxproj.filters b/ultimateteknotool.v2/ultimateteknotool.v2.vcxproj.filters new file mode 100644 index 0000000..a369c50 --- /dev/null +++ b/ultimateteknotool.v2/ultimateteknotool.v2.vcxproj.filters @@ -0,0 +1,396 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + Файлы заголовков + + + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + Исходные файлы + + + \ No newline at end of file diff --git a/ultimateteknotool.v2/ultimateteknotool.v2.vcxproj.user b/ultimateteknotool.v2/ultimateteknotool.v2.vcxproj.user new file mode 100644 index 0000000..966b4ff --- /dev/null +++ b/ultimateteknotool.v2/ultimateteknotool.v2.vcxproj.user @@ -0,0 +1,6 @@ + + + + true + + \ No newline at end of file diff --git a/ultimateteknotool.v2/windows_accountpage.cpp b/ultimateteknotool.v2/windows_accountpage.cpp new file mode 100644 index 0000000..d1ccc7e --- /dev/null +++ b/ultimateteknotool.v2/windows_accountpage.cpp @@ -0,0 +1,1226 @@ +#include "pch.h" +#include "windows_accountpage.h" +#include "TextConvertors.h" +#include "iw5mp_nickname_etc_functions.h" +#include "iw5mp_xuidhwid_functions.h" +#include "iw5mp_constants.h" +#include "JMPHook_SerializeNetdata.h" +#include "JMPHook_sysinfoapi_functions.h" +#include "JMPHook_bdUPnP_functions.h" +#include "JMP_iw5mp_functions.h" +#include "ParserRandMask.h" + + +namespace windows_accountpage +{ + + constexpr DWORD NewEditStyle_Invisible = WS_CHILD & ~WS_VISIBLE | WS_BORDER; + constexpr DWORD ShowEditStyle_Invisible = WS_CHILD & ~WS_VISIBLE | WS_BORDER | ES_READONLY; + constexpr DWORD FlatButtonStyleInvisble = (WS_CHILD & ~WS_VISIBLE) | BS_PUSHBUTTON | BS_CENTER | BS_FLAT; + constexpr DWORD FlatRadioButtonStyleInvisble = (WS_CHILD & ~WS_VISIBLE) | BS_AUTOCHECKBOX | BS_FLAT | BS_LEFTTEXT; + constexpr DWORD FlatRadioButtonStyleInvisble_RIGHT = (WS_CHILD & ~WS_VISIBLE) | BS_AUTOCHECKBOX | BS_FLAT | BS_RIGHT; + constexpr DWORD FlatRadioButtonStyleInvisble_CENTER = (WS_CHILD & ~WS_VISIBLE) | BS_AUTOCHECKBOX | BS_FLAT | BS_CENTER; + + constexpr size_t txtlimit_nickname = iw5mp_constants::MAX_LENGTH_NICKNAME - 1; + constexpr size_t txtlimit_title = iw5mp_constants::MAX_LENGTH_TITLE - 1; + constexpr size_t txtlimit_clantag = iw5mp_constants::MAX_LENGTH_CLANTAG - 1; + constexpr size_t txtlimit_emlem_and_title_types = 3; + constexpr size_t txtlimit_level_and_prestiges_values = 2; + constexpr size_t txtlimit_ip = 3 + 1 + 3 + 1 + 3 + 1 + 3; + constexpr size_t txtlimit_port = 5; // 66 666 + + constexpr size_t txtlimit_xuid_hwid_values = 8; + + void MisterDummyDum(void){} + void MisterDummyDum(const bool&) {} + inline void BuildTripleBar(CWindowsBuilder& builder, WinCombo& combo, int gap) + { + builder.ChangeStyle(ShowEditStyle_Invisible); + combo.edit_show.Visit(&builder); + builder.ChangeStyle(NewEditStyle_Invisible); + builder.ChangeTopPos(builder.build_top_pos + builder.build_height + gap); + combo.edit_new.Visit(&builder); + builder.ChangeTopPos(builder.build_top_pos + builder.build_height + gap); + combo.edit_new_randmask.Visit(&builder); + } + + typedef void doJobwhenChanged_t(void); + + + const wchar_t ws_empty_text[] = L""; + const wchar_t ws_buttontext[] = L"^"; + + WinCombo nickname; + WinCombo title; + WinCombo titletype; + WinCombo emblem; + WinCombo prestige; + WinCombo level; + WinCombo clantag; + + class CWinControlBlock + { + private: + doJobwhenChanged_t* Job_apply = &MisterDummyDum; + doJobwhenChanged_t* Job_applyRand = &MisterDummyDum; + doJobwhenChanged_t* Job_applyRand_mask = &MisterDummyDum; + CWindow_button apply; + CWindow_button applyrand; + CWindow_button_cfg randmasksymbolsreplacenormaldata_autochange; + public: + CWinControlBlock() = delete; + CWinControlBlock(doJobwhenChanged_t& appl, doJobwhenChanged_t& applrand, doJobwhenChanged_t& applrandmask) + { + this->Job_apply = &appl; + this->Job_applyRand = &applrand; + this->Job_applyRand_mask = &applrandmask; + } + void Build(CWindowsBuilder& builder, int left, int top, int buttonwidth, int bheight, int gap) + { + + builder.ChangeLeftPos(left); + builder.ChangeWidth(buttonwidth); + builder.ChangeHeight(bheight); + builder.ChangeTopPos(top); + builder.ChangeTextP(ws_empty_text); + builder.ChangeStyle(FlatRadioButtonStyleInvisble_CENTER); + this->randmasksymbolsreplacenormaldata_autochange.Visit(&builder); + builder.ChangeTopPos(builder.build_top_pos + builder.build_height + gap); + builder.ChangeStyle(FlatButtonStyleInvisble); + builder.ChangeTextP(ws_buttontext); + this->apply.Visit(&builder); + builder.ChangeTopPos(builder.build_top_pos + builder.build_height + gap); + this->applyrand.Visit(&builder); + } + void ApplyFont(CWindowsFontApplier& fontmaster) + { + apply.Visit(&fontmaster); + applyrand.Visit(&fontmaster); + randmasksymbolsreplacenormaldata_autochange.Visit(&fontmaster); + } + void Show() const + { + randmasksymbolsreplacenormaldata_autochange.Show(); + apply.Show(); + applyrand.Show(); + } + void Hide() const + { + randmasksymbolsreplacenormaldata_autochange.Hide(); + apply.Hide(); + applyrand.Hide(); + } + void SaveCfg(CWindowCfgWriter& writer) + { + writer.SaveButtonStateW(&(this->randmasksymbolsreplacenormaldata_autochange)); + } + void LoadCfg(CWindowCfgReader& reader, size_t txtlimit = 8) + { + reader.LoadButtonStateW(&(this->randmasksymbolsreplacenormaldata_autochange)); + } + void ButtonHandler(WPARAM& wparam) + { + if (this->apply.id == LOWORD(wparam)) + { + this->Job_apply(); + } + else if (this->applyrand.id == LOWORD(wparam)) + { + if (randmasksymbolsreplacenormaldata_autochange.isPressed) { + this->Job_applyRand_mask(); + } + else { + this->Job_applyRand(); + } + } + else if (this->randmasksymbolsreplacenormaldata_autochange.id == LOWORD(wparam)) + { + randmasksymbolsreplacenormaldata_autochange.SwitchState(); + } + } + void ForceExecuteJob_ApplyRand() + { + if (randmasksymbolsreplacenormaldata_autochange.isPressed) { + this->Job_applyRand_mask(); + } + else { + this->Job_applyRand(); + } + } + }; + + + CWinControlBlock control_nicknameetc(ReadData_ChangeNicknameEtc_andUpdate, ReadRandData_ChangeNicknameEtc_andUpdate, ReadRandDataMask_ChangeNicknameEtc_andUpdate); + CWindow_button_cfg nickname_autochage; + + CWindow_button xuidhwid_page; + CWindow_button localexternalip_page; + CWindow_button firmware_page; + CWindow_button upnp_page; + bool firmware_page_is_opened = false; + CWindow_button_cfg xuidhwid_autochange; + CWindow_button_cfg localexternalip_autochange; + CWindow_button_cfg firmware_autochange; + CWindow_button_cfg upnp_autochange; + + WinCombo xuid_part1; + WinCombo xuid_part2; + WinCombo hwid_part1; + WinCombo hwid_part2; + WinCombo hwid_part3; + CWinControlBlock control_xuidhwid(ReadData_ChangeXUIDHWID_andUpdate, ReadRandData_ChangeXUIDHWID_andUpdate, ReadRandDataMask_ChangeXUIDHWID_andUpdate); + + WinCombo localip; + WinCombo lip_port; + WinCombo externalip; + WinCombo exip_port; + WinCombo someip1; + WinCombo someip1_port; + WinCombo someip2; + WinCombo someip2_port; + CWinControlBlock control_externallocalips(ReadData_ChangeNETData, ReadRandData_ChangeNETData, ReadRandDataMask_ChangeNETData); + + + namespace firmware + { + CWindow_edit challengeS2_part_1; + CWindow_edit challengeS2_part_2; + CWindow_edit challengeS2_part_3; + CWindow_edit challengeS2_part_4; + wchar_t ws_generate[] = L"generate"; + CWindow_button generate_new_firmware; + wchar_t ws_randall[] = L"rand all"; + CWindow_button_cfg rand_all_firmware; + wchar_t ws_alwaysnew[] = L"always new"; + CWindow_button_cfg generate_always_new; + void ButtonHandler(WPARAM& param) + { + if (LOWORD(param) == generate_new_firmware.id) + { + hooks::sysinfoapi_functions::GetSystemFirmwareTable_SetState_GenerateNewData(); + hooks::sysinfoapi_functions::GetSystemFirmwareTable_SetState_FakingDataEnabled(true); + } + else if (LOWORD(param) == rand_all_firmware.id) + { + rand_all_firmware.SwitchState(); + hooks::sysinfoapi_functions::GetSystemFirmwareTable_SetState_RandomiseAllDataEnabled(rand_all_firmware.isPressed); + + } + else if (LOWORD(param) == generate_always_new.id) + { + generate_always_new.SwitchState(); + hooks::sysinfoapi_functions::GetSystemFirmwareTable_SetState_AlwaysGenerateNewDataEnabled(generate_always_new.isPressed); + } + else + { + + } + } + void SaveSettings_PreCreateVer(CWindowCfgWriter* writer); + void LoadSettings_PreCreateVer(CWindowCfgReader* reader); + void SaveSettings_PreCreateVer(CWindowCfgWriter* writer) + { + writer->SaveButtonStateW(&firmware_autochange); + } + void LoadSettings_PreCreateVer(CWindowCfgReader* reader) + { + firmware_autochange.isPressed = reader->LoadButtonStateW(); + hooks::sysinfoapi_functions::GetSystemFirmwareTable_SetState_FakingDataEnabled(firmware_autochange.isPressed); + } + void SaveCfg(CWindowCfgWriter* writer) + { + writer->SaveButtonStateW(&rand_all_firmware); + writer->SaveButtonStateW(&generate_always_new); + } + void LoadCfg(CWindowCfgReader* reader) + { + reader->LoadButtonStateW(&rand_all_firmware); + reader->LoadButtonStateW(&generate_always_new); + } + }; + + namespace UPnP + { + namespace textlim + { + constexpr size_t device_field_location = hooks::bdUPnP_functions::ns_extractDeviceInfo::maxtext_field_location; + constexpr size_t device_field_server = hooks::bdUPnP_functions::ns_extractDeviceInfo::maxtext_field_server; + constexpr size_t device_field_USN = hooks::bdUPnP_functions::ns_extractDeviceInfo::maxtext_field_USN; + }; + WinCombo device_field_location; + WinCombo device_field_server; + WinCombo device_field_USN; + CWinControlBlock control_deviceinfo(ReadData_ChangeDeviceInfo, ReadRandData_ChangeDeviceInfo, ReadRandDataMask_ChangeDeviceInfo); + void SaveSettings_PreCreateVer(CWindowCfgWriter* writer); + void LoadSettings_PreCreateVer(CWindowCfgReader* reader); + }; + + const wchar_t ws_xuidhwid[] = L"xuid/hwid"; + const wchar_t ws_localexternalip[] = L"NAT"; + const wchar_t ws_UPnP[] = L"UPnP"; + const wchar_t ws_firmware[] = L"firmware"; + const wchar_t ws_auto[] = L"auto"; + const wchar_t ws_hhhhhhhh[] = L"hhhhhhhh"; + + CWindowPostLoadStrings WinStringsPostLoader; + void ButtonStatesPostLoader(); +} + +void CWindowCfgWriter_Wrapper_SaveWinCombo(windows_accountpage::WinCombo& combo, CWindowCfgWriter* writer, unsigned short textlim = 32) +{ + writer->SaveTextSettingW(&combo.edit_new, textlim); + writer->SaveTextSettingW(&combo.edit_new_randmask, textlim); +} + +void CWindowCfgWriter_Wrapper_LoadWinCombo(CWindowCfgReader* reader, windows_accountpage::WinCombo& combo, unsigned short textlim = 64) +{ + reader->LoadTextSettingW(&combo.edit_new, textlim); + reader->LoadTextSettingW(&combo.edit_new_randmask, textlim); +} + + +void windows_accountpage::Build(CWindowsBuilder& builder, int left, int width, int top, int height, HWND hwnd) +{ + constexpr int applybuttonwidth = 18; + builder.ChangeParentHWND(hwnd); + builder.ChangeLeftPos(left); + builder.ChangeTopPos(top); + builder.ChangeTextP(ws_empty_text); + + int freewidth = width - left * 2; + int gap = 5; + int rheight = 20; + int rwidth = 140; + int savetop = top; + int rwidth2 = 50; + + builder.ChangeWidth(rwidth); + builder.ChangeHeight(20); + BuildTripleBar(builder, nickname, gap); + + rwidth = 175; + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeWidth(rwidth); + BuildTripleBar(builder, title, gap); + + rwidth = 28; + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeWidth(rwidth); + BuildTripleBar(builder, titletype, gap); + + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeWidth(rwidth); + BuildTripleBar(builder, emblem, gap); + + rwidth = 23; + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeWidth(rwidth); + BuildTripleBar(builder, prestige, gap); + + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + //builder.ChangeWidth(rwidth); + BuildTripleBar(builder, level, gap); + + rwidth = 70; + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeWidth(rwidth); + BuildTripleBar(builder, clantag, gap); + + rwidth = applybuttonwidth; + + control_nicknameetc.Build(builder, /*hwnd,*/ builder.build_left_pos + builder.build_width + gap, savetop, applybuttonwidth, rheight, gap); + + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeStyle(FlatRadioButtonStyleInvisble_RIGHT); + builder.ChangeWidth(rwidth2); + builder.ChangeTextP(ws_auto); + nickname_autochage.Visit(&builder); + builder.ChangeTopPos(builder.build_top_pos + builder.build_height + gap); + builder.ChangeTopPos(builder.build_top_pos + builder.build_height + gap); + + constexpr int numberofbuttons = 4; + rwidth = (freewidth - numberofbuttons * gap) / numberofbuttons; + rwidth -= gap * numberofbuttons / 2; + + builder.ChangeStyle(FlatButtonStyleInvisble); + builder.ChangeTopPos(builder.build_top_pos + builder.build_height + gap * 2); + builder.ChangeLeftPos(left); + builder.ChangeWidth(rwidth); + builder.ChangeTextP(ws_xuidhwid); + xuidhwid_page.Visit(&builder); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeTextP(ws_localexternalip); + localexternalip_page.Visit(&builder); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeTextP(ws_firmware); + firmware_page.Visit(&builder); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeTextP(ws_UPnP); + upnp_page.Visit(&builder); + + rwidth2 = 20 + 40; + builder.ChangeTopPos(builder.build_top_pos + builder.build_height); + builder.ChangeLeftPos(left); + builder.ChangeWidth(rwidth2); + builder.ChangeTextP(ws_auto); + builder.ChangeStyle(FlatRadioButtonStyleInvisble); + xuidhwid_autochange.Visit(&builder); + builder.ChangeLeftPos(left + rwidth + gap); + localexternalip_autochange.Visit(&builder); + builder.ChangeLeftPos(builder.build_left_pos + rwidth + gap); + firmware_autochange.Visit(&builder); + builder.ChangeLeftPos(builder.build_left_pos + rwidth + gap); + upnp_autochange.Visit(&builder); + + builder.ChangeStyle(NewEditStyle_Invisible); + + rwidth = 70; + savetop = builder.build_top_pos + builder.build_height + gap * 2; + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(left); + builder.ChangeTextP(ws_empty_text); + builder.ChangeWidth(rwidth); + BuildTripleBar(builder, xuid_part1, gap); + + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + BuildTripleBar(builder, xuid_part2, gap); + + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap * 2); + BuildTripleBar(builder, hwid_part1, gap); + + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + BuildTripleBar(builder, hwid_part2, gap); + + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + BuildTripleBar(builder, hwid_part3, gap); + + + control_xuidhwid.Build(builder, /*hwnd,*/ builder.build_left_pos + builder.build_width + gap, savetop, applybuttonwidth, rheight, gap); + + builder.ChangeStyle(NewEditStyle_Invisible); + + rwidth = 116; + int rwidth_port = 46; + builder.ChangeTextP(ws_empty_text); + //savetop = builder.build_top_pos + builder.build_height + gap * 2; + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(left); + builder.ChangeWidth(rwidth); + BuildTripleBar(builder, localip, gap); + + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeWidth(rwidth_port); + BuildTripleBar(builder, lip_port, gap); + + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeWidth(rwidth); + BuildTripleBar(builder, externalip, gap); + + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeWidth(rwidth_port); + BuildTripleBar(builder, exip_port, gap); + + control_externallocalips.Build(builder, /*hwnd,*/ builder.build_left_pos + builder.build_width + gap, savetop, applybuttonwidth, rheight, gap); + + builder.ChangeStyle(NewEditStyle_Invisible); + + rwidth = 116; + builder.ChangeTextP(ws_empty_text); + int savetop2 = builder.build_top_pos + builder.build_height + gap; + builder.ChangeTopPos(savetop2); + builder.ChangeLeftPos(left); + builder.ChangeWidth(rwidth); + BuildTripleBar(builder, someip1, gap); + + builder.ChangeTopPos(savetop2); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeWidth(rwidth_port); + BuildTripleBar(builder, someip1_port, gap); + + builder.ChangeTopPos(savetop2); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeWidth(rwidth); + BuildTripleBar(builder, someip2, gap); + + builder.ChangeTopPos(savetop2); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeWidth(rwidth_port); + BuildTripleBar(builder, someip2_port, gap); + + rwidth = 280; + builder.ChangeWidth(rwidth); + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(left); + builder.ChangeStyle(NewEditStyle_Invisible); + builder.ChangeTextP(ws_empty_text); + BuildTripleBar(builder, UPnP::device_field_location, gap); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + //rwidth = 250; + builder.ChangeWidth(rwidth); + builder.ChangeTopPos(savetop); + BuildTripleBar(builder, UPnP::device_field_server, gap); + rwidth = rwidth*2 + gap; + builder.ChangeWidth(rwidth); + builder.ChangeLeftPos(left); + builder.ChangeTopPos(builder.build_top_pos + builder.build_height + gap); + BuildTripleBar(builder, UPnP::device_field_USN, gap); + + builder.ChangeTopPos(savetop); + UPnP::control_deviceinfo.Build(builder, /*hwnd,*/ builder.build_left_pos + builder.build_width + gap, savetop, applybuttonwidth, rheight, gap); + UPnP::update_device::Location(L" no UPnP device"); + UPnP::update_device::Server(L" no UPnP device"); + UPnP::update_device::USN(L" no UPnP device"); + + rwidth = 70; + builder.ChangeWidth(rwidth); + builder.ChangeTopPos(savetop); + builder.ChangeLeftPos(left); + builder.ChangeStyle(NewEditStyle_Invisible); + builder.ChangeTextP(ws_empty_text); + firmware::challengeS2_part_1.Visit(&builder); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + firmware::challengeS2_part_2.Visit(&builder); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + firmware::challengeS2_part_3.Visit(&builder); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + firmware::challengeS2_part_4.Visit(&builder); + rwidth = 60; + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap*2); + builder.ChangeStyle(FlatButtonStyleInvisble); + builder.ChangeTextP(firmware::ws_generate); + firmware::generate_new_firmware.Visit(&builder); + + builder.ChangeLeftPos(left); + builder.ChangeTopPos(builder.build_top_pos + builder.build_height + gap); + rwidth2 = 20 + 70; + builder.ChangeWidth(rwidth2); + builder.ChangeTextP(firmware::ws_alwaysnew); + builder.ChangeStyle(FlatRadioButtonStyleInvisble); + firmware::generate_always_new.Visit(&builder); + builder.ChangeTopPos(builder.build_top_pos + builder.build_height + gap); + builder.ChangeTextP(firmware::ws_randall); + firmware::rand_all_firmware.Visit(&builder); +} + +void windows_accountpage::ApplyFonts(CWindowsFontApplier& fontappl) +{ + nickname.ApplyFont(fontappl); + title.ApplyFont(fontappl); + titletype.ApplyFont(fontappl); + emblem.ApplyFont(fontappl); + level.ApplyFont(fontappl); + prestige.ApplyFont(fontappl); + clantag.ApplyFont(fontappl); + control_nicknameetc.ApplyFont(fontappl); + nickname_autochage.Visit(&fontappl); + + xuidhwid_page.Visit(&fontappl); + xuidhwid_autochange.Visit(&fontappl);; + localexternalip_page.Visit(&fontappl);; + localexternalip_autochange.Visit(&fontappl); + upnp_page.Visit(&fontappl); + upnp_autochange.Visit(&fontappl); + + xuid_part1.ApplyFont(fontappl); + xuid_part2.ApplyFont(fontappl); + hwid_part1.ApplyFont(fontappl); + hwid_part2.ApplyFont(fontappl); + hwid_part3.ApplyFont(fontappl); + control_xuidhwid.ApplyFont(fontappl); + + localip.ApplyFont(fontappl); + lip_port.ApplyFont(fontappl); + externalip.ApplyFont(fontappl); + exip_port.ApplyFont(fontappl); + someip1.ApplyFont(fontappl); + someip1_port.ApplyFont(fontappl); + someip2.ApplyFont(fontappl); + someip2_port.ApplyFont(fontappl); + control_externallocalips.ApplyFont(fontappl); + + firmware_page.Visit(&fontappl); + firmware_autochange.Visit(&fontappl); + + UPnP::device_field_location.ApplyFont(fontappl); + UPnP::device_field_server.ApplyFont(fontappl); + UPnP::device_field_USN.ApplyFont(fontappl); + UPnP::control_deviceinfo.ApplyFont(fontappl); + + firmware::challengeS2_part_1.Visit(&fontappl); + firmware::challengeS2_part_2.Visit(&fontappl); + firmware::challengeS2_part_3.Visit(&fontappl); + firmware::challengeS2_part_4.Visit(&fontappl); + firmware::generate_new_firmware.Visit(&fontappl); + firmware::generate_always_new.Visit(&fontappl); + firmware::rand_all_firmware.Visit(&fontappl); +} + + +void windows_accountpage::WriteDefault() +{ + CWindowTextWriter_WriteText(&nickname.edit_new_randmask, L"uull0xdd"); + CWindowTextWriter_WriteText(&title.edit_new_randmask, L"my ip d.dd.dd.d"); + CWindowTextWriter_WriteText(&titletype.edit_new, L"124"); + CWindowTextWriter_WriteText(&emblem.edit_new, L"34"); + CWindowTextWriter_WriteText(&titletype.edit_new_randmask, L"0dd"); + CWindowTextWriter_WriteText(&emblem.edit_new_randmask, L"0dd"); + CWindowTextWriter_WriteText(&prestige.edit_new_randmask, L"0d"); + CWindowTextWriter_WriteText(&level.edit_new_randmask, L"0d"); + + CWindowTextWriter_WriteText(&xuid_part2.edit_new_randmask, L"01100001"); + CWindowTextWriter_WriteText(&xuid_part1.edit_new_randmask, ws_hhhhhhhh); + CWindowTextWriter_WriteText(&hwid_part1.edit_new_randmask, ws_hhhhhhhh); + CWindowTextWriter_WriteText(&hwid_part2.edit_new_randmask, ws_hhhhhhhh); + CWindowTextWriter_WriteText(&hwid_part3.edit_new_randmask, ws_hhhhhhhh); + + CWindowTextWriter_WriteText(&localip.edit_new_randmask, L"192.168.d.d"); + CWindowTextWriter_WriteText(&externalip.edit_new_randmask, L"76.dd.dd.dd"); + +} + +void windows_accountpage::ApplyTextLimits() +{ + + nickname.ApplyTextLimit(txtlimit_nickname); + title.ApplyTextLimit(txtlimit_title); + clantag.ApplyTextLimit(txtlimit_clantag); + emblem.ApplyTextLimit(txtlimit_emlem_and_title_types); + titletype.ApplyTextLimit(txtlimit_emlem_and_title_types); + prestige.ApplyTextLimit(txtlimit_level_and_prestiges_values); + level.ApplyTextLimit(txtlimit_level_and_prestiges_values); + xuid_part1.ApplyTextLimit(txtlimit_xuid_hwid_values); + xuid_part2.ApplyTextLimit(txtlimit_xuid_hwid_values); + hwid_part1.ApplyTextLimit(txtlimit_xuid_hwid_values); + hwid_part2.ApplyTextLimit(txtlimit_xuid_hwid_values); + hwid_part3.ApplyTextLimit(txtlimit_xuid_hwid_values); + UPnP::device_field_location.ApplyTextLimit(UPnP::textlim::device_field_location); + UPnP::device_field_server.ApplyTextLimit(UPnP::textlim::device_field_server); + UPnP::device_field_USN.ApplyTextLimit(UPnP::textlim::device_field_USN); +} + +void windows_accountpage::Show() +{ + nickname.Show(); + title.Show(); + titletype.Show(); + emblem.Show(); + level.Show(); + prestige.Show(); + clantag.Show(); + control_nicknameetc.Show(); + nickname_autochage.Show(); + + xuidhwid_page.Show(); + xuidhwid_autochange.Show(); + localexternalip_page.Show(); + localexternalip_autochange.Show(); + firmware_page.Show(); + firmware_autochange.Show(); + upnp_page.Show(); + upnp_autochange.Show(); + + + +} + +void windows_accountpage::Hide() +{ + nickname.Hide(); + title.Hide(); + titletype.Hide(); + emblem.Hide(); + level.Hide(); + prestige.Hide(); + clantag.Hide(); + control_nicknameetc.Hide(); + nickname_autochage.Hide(); + + xuidhwid_page.Hide(); + xuidhwid_autochange.Hide(); + localexternalip_page.Hide(); + localexternalip_autochange.Hide(); + + firmware_page.Hide(); + firmware_autochange.Hide(); + upnp_page.Hide(); + upnp_autochange.Hide(); + + Hide_XuidHwidPage(); + Hide_LocalExternalIPPage(); + Hide_FirmwarePage(); + Hide_UPnPPage(); +} + +void windows_accountpage::Show_XuidHwidPage() +{ + xuid_part1.Show(); + xuid_part2.Show(); + hwid_part1.Show(); + hwid_part2.Show(); + hwid_part3.Show(); + control_xuidhwid.Show(); +} + +void windows_accountpage::Hide_XuidHwidPage() +{ + xuid_part1.Hide(); + xuid_part2.Hide(); + hwid_part1.Hide(); + hwid_part2.Hide(); + hwid_part3.Hide(); + control_xuidhwid.Hide(); +} + +void windows_accountpage::Show_LocalExternalIPPage() +{ + localip.Show(); + lip_port.Show(); + externalip.Show(); + exip_port.Show(); + someip1.Show(); + someip1_port.Show(); + someip2.Show(); + someip2_port.Show(); + control_externallocalips.Show(); +} + +void windows_accountpage::Hide_LocalExternalIPPage() +{ + localip.Hide(); + lip_port.Hide(); + externalip.Hide(); + exip_port.Hide(); + someip1.Hide(); + someip1_port.Hide(); + someip2.Hide(); + someip2_port.Hide(); + control_externallocalips.Hide(); +} + +void windows_accountpage::Show_FirmwarePage() +{ + firmware::challengeS2_part_1.Show(); + firmware::challengeS2_part_2.Show(); + firmware::challengeS2_part_3.Show(); + firmware::challengeS2_part_4.Show(); + firmware::generate_new_firmware.Show(); + firmware::generate_always_new.Show(); + firmware::rand_all_firmware.Show(); + firmware_page_is_opened = true; +} + +void windows_accountpage::Hide_FirmwarePage() +{ + firmware::challengeS2_part_1.Hide(); + firmware::challengeS2_part_2.Hide(); + firmware::challengeS2_part_3.Hide(); + firmware::challengeS2_part_4.Hide(); + firmware::generate_new_firmware.Hide(); + firmware::generate_always_new.Hide(); + firmware::rand_all_firmware.Hide(); + firmware_page_is_opened = false; +} + +void windows_accountpage::Show_UPnPPage() +{ + UPnP::device_field_location.Show(); + UPnP::device_field_server.Show(); + UPnP::device_field_USN.Show(); + UPnP::control_deviceinfo.Show(); +} + +void windows_accountpage::Hide_UPnPPage() +{ + UPnP::device_field_location.Hide(); + UPnP::device_field_server.Hide(); + UPnP::device_field_USN.Hide(); + UPnP::control_deviceinfo.Hide(); +} + +void windows_accountpage::Show_XuidHwidPageHideOthers() +{ + Hide_LocalExternalIPPage(); + Hide_FirmwarePage(); + Hide_UPnPPage(); + Show_XuidHwidPage(); +} + +void windows_accountpage::Show_LocalExternalIPHideOthers() +{ + Hide_XuidHwidPage(); + Hide_FirmwarePage(); + Hide_UPnPPage(); + Show_LocalExternalIPPage(); +} + +void windows_accountpage::Show_FirmwareHideOthers() +{ + Hide_LocalExternalIPPage(); + Hide_XuidHwidPage(); + Hide_UPnPPage(); + Show_FirmwarePage(); +} + +void windows_accountpage::Show_UPnPPageHideOthers() +{ + Hide_LocalExternalIPPage(); + Hide_XuidHwidPage(); + Hide_FirmwarePage(); + Show_UPnPPage(); +} + + +void windows_accountpage::Handler_ClickButton(WPARAM wparam) +{ + + WORD low = LOWORD(wparam); + control_nicknameetc.ButtonHandler(wparam); + control_xuidhwid.ButtonHandler(wparam); + control_externallocalips.ButtonHandler(wparam); + UPnP::control_deviceinfo.ButtonHandler(wparam); + firmware::ButtonHandler(wparam); + if (low == xuidhwid_page.id) + { + Show_XuidHwidPageHideOthers(); + } + else if (low == localexternalip_page.id) + { + Show_LocalExternalIPHideOthers(); + } + else if (low == firmware_page.id) + { + Show_FirmwareHideOthers(); + } + else if (low == upnp_page.id) + { + Show_UPnPPageHideOthers(); + } + else if (low == nickname_autochage.id) + { + nickname_autochage.SwitchState(); + } + else if (low == xuidhwid_autochange.id) + { + xuidhwid_autochange.SwitchState(); + } + else if (low == localexternalip_autochange.id) + { + localexternalip_autochange.SwitchState(); + } + else if (low == firmware_autochange.id) + { + firmware_autochange.SwitchState(); + hooks::sysinfoapi_functions::GetSystemFirmwareTable_SetState_FakingDataEnabled(firmware_autochange.isPressed); + } + else if (low == upnp_autochange.id) + { + upnp_autochange.SwitchState(); + + } + else + { + + } + +} + + +void windows_accountpage::UPnP::SaveSettings_PreCreateVer(CWindowCfgWriter* writer) +{ + writer->SaveButtonStateW(&upnp_autochange); + writer->SaveTextSettingW(&UPnP::device_field_location.edit_new_randmask, UPnP::textlim::device_field_location); + writer->SaveTextSettingW(&UPnP::device_field_server.edit_new_randmask, UPnP::textlim::device_field_server); + writer->SaveTextSettingW(&UPnP::device_field_USN.edit_new_randmask, UPnP::textlim::device_field_USN); + writer->SaveTextSettingW(&UPnP::device_field_location.edit_new, UPnP::textlim::device_field_location); + writer->SaveTextSettingW(&UPnP::device_field_server.edit_new, UPnP::textlim::device_field_server); + writer->SaveTextSettingW(&UPnP::device_field_USN.edit_new, UPnP::textlim::device_field_USN); +} + +namespace windows_accountpage +{ + namespace UPnP + { + typedef void setinfo_t(const wchar_t*); + void SingleLoad(CWindowCfgReader* reader, WinCombo& edit, unsigned short sz, CWindow_button_cfg& cfgb, setinfo_t& func) + { + const wchar_t* pp = ws_empty_text; + pp = reader->LoadTextSettingW(sz); + WinStringsPostLoader.LoadTextSettingW(&edit.edit_new_randmask, pp, sz); + if (cfgb.isPressed) + { + wchar_t* data = lazysectionbuffer_3x512.GetNulledMem(sz + 4, 0); + parsers::ParseRandMaskTextW(pp, sz, data, sz); + func(data); + } + } + }; +}; + +void windows_accountpage::UPnP::LoadSettings_PreCreateVer(CWindowCfgReader* reader) +{ + upnp_autochange.isPressed = reader->LoadButtonStateW(); + SingleLoad(reader, UPnP::device_field_location, UPnP::textlim::device_field_location, upnp_autochange, hooks::bdUPnP_functions::SetDeviceInfo_location); + SingleLoad(reader, UPnP::device_field_server, UPnP::textlim::device_field_server, upnp_autochange, hooks::bdUPnP_functions::SetDeviceInfo_server); + SingleLoad(reader, UPnP::device_field_USN, UPnP::textlim::device_field_USN, upnp_autochange, hooks::bdUPnP_functions::SetDeviceInfo_USN); + const wchar_t* pp = nullptr; + pp = reader->LoadTextSettingW(UPnP::textlim::device_field_location); + WinStringsPostLoader.LoadTextSettingW(&UPnP::device_field_location.edit_new, pp, UPnP::textlim::device_field_location); + pp = reader->LoadTextSettingW(UPnP::textlim::device_field_server); + WinStringsPostLoader.LoadTextSettingW(&UPnP::device_field_server.edit_new, pp, UPnP::textlim::device_field_location); + pp = reader->LoadTextSettingW(UPnP::textlim::device_field_USN); + WinStringsPostLoader.LoadTextSettingW(&UPnP::device_field_USN.edit_new, pp, UPnP::textlim::device_field_location); + +} + +void windows_accountpage::Cfg_SavePreCreateWindowSettings(CWindowCfgWriter* writer) +{ + writer->SaveButtonStateW(&localexternalip_autochange); + firmware::SaveSettings_PreCreateVer(writer); + UPnP::SaveSettings_PreCreateVer(writer); +} + +void windows_accountpage::Cfg_LoadPreCreateWindowSettings(CWindowCfgReader* reader) +{ + WinStringsPostLoader.Register(256); + localexternalip_autochange.isPressed = reader->LoadButtonStateW(); + firmware::LoadSettings_PreCreateVer(reader); + UPnP::LoadSettings_PreCreateVer(reader); + + //ExecutionAfterSettingsPreload(); +} + +void windows_accountpage::ButtonStatesPostLoader() +{ + CWindowButtonStatePostLoader loader; + localexternalip_autochange.Visit(&loader); + firmware_autochange.Visit(&loader); + upnp_autochange.Visit(&loader); +} + +void windows_accountpage::Cfg_Save(CWindowCfgWriter* writer) +{ + + CWindowCfgWriter_Wrapper_SaveWinCombo(nickname, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(title, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(titletype, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(emblem, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(level, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(prestige, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(clantag, writer); + + writer->SaveButtonStateW(&nickname_autochage); + + CWindowCfgWriter_Wrapper_SaveWinCombo(xuid_part1, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(xuid_part2, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(hwid_part1, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(hwid_part2, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(hwid_part3, writer); + + writer->SaveButtonStateW(&xuidhwid_autochange); + + CWindowCfgWriter_Wrapper_SaveWinCombo(localip, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(lip_port, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(externalip, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(exip_port, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(someip1, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(someip1_port, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(someip2, writer); + CWindowCfgWriter_Wrapper_SaveWinCombo(someip2_port, writer); + + control_nicknameetc.SaveCfg(*writer); + control_externallocalips.SaveCfg(*writer); + control_xuidhwid.SaveCfg(*writer); + UPnP::control_deviceinfo.SaveCfg(*writer); + + firmware::SaveCfg(writer); +} + +void windows_accountpage::Cfg_Load(CWindowCfgReader* reader) +{ + + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, nickname); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, title); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, titletype); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, emblem); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, level); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, prestige); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, clantag); + + reader->LoadButtonStateW(&nickname_autochage); + + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, xuid_part1); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, xuid_part2); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, hwid_part1); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, hwid_part2); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, hwid_part3); + + reader->LoadButtonStateW(&xuidhwid_autochange); + + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, localip); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, lip_port); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, externalip); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, exip_port); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, someip1); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, someip1_port); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, someip2); + CWindowCfgWriter_Wrapper_LoadWinCombo(reader, someip2_port); + + control_nicknameetc.LoadCfg(*reader); + control_externallocalips.LoadCfg(*reader); + control_xuidhwid.LoadCfg(*reader); + UPnP::control_deviceinfo.LoadCfg(*reader); + + firmware::LoadCfg(reader); + + WinStringsPostLoader.LoadTextInEdits(); + WinStringsPostLoader.Unregister(); + ButtonStatesPostLoader(); +} + +namespace windows_accountpage +{ + template + void ReadSmth_ChangeNicknameEtc_andUpdate() + { + iw5mp_changedata::ChangeNickname(nickname.GetTextW(txtlimit_nickname + 4)); + iw5mp_changedata::ChangeTitle(title.GetTextW(txtlimit_title + 4)); + iw5mp_changedata::ChangeClanTag(clantag.GetTextW(txtlimit_clantag + 4)); + + iw5mp_changedata::ChangeTitleType(textconvertors::ConvertWTextDecTypeToU32(titletype.GetTextW(txtlimit_emlem_and_title_types + 4))); + iw5mp_changedata::ChangeEmblemType(textconvertors::ConvertWTextDecTypeToU32(emblem.GetTextW(txtlimit_emlem_and_title_types + 4))); + iw5mp_changedata::ChangePrestige(textconvertors::ConvertWTextDecTypeToU32(prestige.GetTextW(txtlimit_level_and_prestiges_values + 4))); + iw5mp_changedata::ChangeLevel(textconvertors::ConvertWTextDecTypeToU32(level.GetTextW(txtlimit_level_and_prestiges_values + 4))); + UpdateCurrentNickanameEtc(); + } +} + +void windows_accountpage::ReadData_ChangeNicknameEtc_andUpdate() +{ + ReadSmth_ChangeNicknameEtc_andUpdate<0>(); +} + +void windows_accountpage::ReadRandData_ChangeNicknameEtc_andUpdate() +{ + ReadSmth_ChangeNicknameEtc_andUpdate<1>(); +} + +void windows_accountpage::ReadRandDataMask_ChangeNicknameEtc_andUpdate() +{ + ReadSmth_ChangeNicknameEtc_andUpdate<2>(); +} + +namespace windows_accountpage +{ + template + void ReadSmth_ChangeXUIDHWID_andUpdate() + { + uint32_t xpart1 = 0; + uint32_t xpart2 = 0; + bool updateAllowed = false; + xpart1 = textconvertors::ConvertWTextHexTypeToU32(xuid_part1.GetTextW(txtlimit_xuid_hwid_values + 4)); + xpart2 = textconvertors::ConvertWTextHexTypeToU32(xuid_part2.GetTextW(txtlimit_xuid_hwid_values + 4)); + iw5mp_changedata::ChangeXUID(xpart1, xpart2); + iw5mp_changedata::ChangeSteamAPIXUID(xpart1, xpart2); + updateAllowed = iw5mp_changedata::ChangeSteamAPIsteamid(xpart1, xpart2); + iw5mp_changedata::ChangeHWID( + textconvertors::ConvertWTextHexTypeToU32(hwid_part1.GetTextW(txtlimit_xuid_hwid_values + 4)), + textconvertors::ConvertWTextHexTypeToU32(hwid_part2.GetTextW(txtlimit_xuid_hwid_values + 4)), + textconvertors::ConvertWTextHexTypeToU32(hwid_part3.GetTextW(txtlimit_xuid_hwid_values + 4)) + ); + if (updateAllowed == true) { + UpdateCurrentXUIDHWID(); + } + else + { + + } + } +}; + + +void windows_accountpage::ReadData_ChangeXUIDHWID_andUpdate() +{ + ReadSmth_ChangeXUIDHWID_andUpdate<0>(); +} + +void windows_accountpage::ReadRandData_ChangeXUIDHWID_andUpdate() +{ + ReadSmth_ChangeXUIDHWID_andUpdate<1>(); +} + +void windows_accountpage::ReadRandDataMask_ChangeXUIDHWID_andUpdate() +{ + ReadSmth_ChangeXUIDHWID_andUpdate<2>(); +} + +namespace windows_accountpage +{ + template + void ReadSmth_ChangeNETData() + { + uint8_t ExactlyNewIP[4] = { 0 }; + textconvertors::ConvertWTextToIP(externalip.GetTextW(txtlimit_ip + 4), ExactlyNewIP); + if (ExactlyNewIP[0]) { hooks::serializeNetData_change::ExternalIP(ExactlyNewIP); } + textconvertors::ConvertWTextToIP(localip.GetTextW(txtlimit_ip + 4), ExactlyNewIP); + if (ExactlyNewIP[0]) { hooks::serializeNetData_change::LocalIP(ExactlyNewIP); } + textconvertors::ConvertWTextToIP(someip1.GetTextW(txtlimit_ip + 4), ExactlyNewIP); + if (ExactlyNewIP[0]) { hooks::serializeNetData_change::OtherlIP1(ExactlyNewIP); } + textconvertors::ConvertWTextToIP(someip2.GetTextW(txtlimit_ip + 4), ExactlyNewIP); + if (ExactlyNewIP[0]) { hooks::serializeNetData_change::OtherlIP2(ExactlyNewIP); } + uint16_t Port = 0; + Port = textconvertors::ConvertWTextDecTypeToU16(exip_port.GetTextW(txtlimit_port + 4)); + if (Port != 0) { hooks::serializeNetData_change::ExternalPort(Port); } + Port = textconvertors::ConvertWTextDecTypeToU16(lip_port.GetTextW(txtlimit_port + 4)); + if (Port != 0) { hooks::serializeNetData_change::LocalPort(Port); } + Port = textconvertors::ConvertWTextDecTypeToU16(someip1_port.GetTextW(txtlimit_port + 4)); + if (Port != 0) { hooks::serializeNetData_change::OtherPort1(Port); } + Port = textconvertors::ConvertWTextDecTypeToU16(someip2_port.GetTextW(txtlimit_port + 4)); + if (Port != 0) { hooks::serializeNetData_change::OtherPort2(Port); } + } +} + + +void windows_accountpage::ReadData_ChangeNETData() +{ + ReadSmth_ChangeNETData<0>(); +} + +void windows_accountpage::ReadRandData_ChangeNETData() +{ + ReadSmth_ChangeNETData<1>(); +} + +void windows_accountpage::ReadRandDataMask_ChangeNETData() +{ + ReadSmth_ChangeNETData<2>(); +} + +void windows_accountpage::UpdateCurrentNickanameEtc() +{ + CWindowTextWriter_WriteText(&titletype.edit_show, textconvertors::ConvertDecTypeU32ToWText(iw5mp_getdata::GetTitleType())); + CWindowTextWriter_WriteText(&emblem.edit_show, textconvertors::ConvertDecTypeU32ToWText(iw5mp_getdata::GetEmblem())); + CWindowTextWriter_WriteText(&prestige.edit_show, textconvertors::ConvertDecTypeU32ToWText(iw5mp_getdata::GetPrestige())); + CWindowTextWriter_WriteText(&level.edit_show, textconvertors::ConvertDecTypeU32ToWText(iw5mp_getdata::GetLevel())); + + CWindowTextWriter_WriteText(&title.edit_show, iw5mp_getdata::GetTitle()); + CWindowTextWriter_WriteText(&clantag.edit_show, iw5mp_getdata::GetClanTag()); + + CWindowTextWriter_WriteText(&nickname.edit_show, iw5mp_getdata::GetNickname()); +} + +void windows_accountpage::UpdateCurrentXUIDHWID() +{ + CWindowTextWriter_WriteText(&xuid_part1.edit_show, textconvertors::ConvertHexTypeU32ToWText(iw5mp_getdata::GetXUID_part1())); + CWindowTextWriter_WriteText(&xuid_part2.edit_show, textconvertors::ConvertHexTypeU32ToWText(iw5mp_getdata::GetXUID_part2())); + + CWindowTextWriter_WriteText(&hwid_part1.edit_show, textconvertors::ConvertHexTypeU32ToWText(iw5mp_getdata::GetHWID_part1())); + CWindowTextWriter_WriteText(&hwid_part2.edit_show, textconvertors::ConvertHexTypeU32ToWText(iw5mp_getdata::GetHWID_part2())); + CWindowTextWriter_WriteText(&hwid_part3.edit_show, textconvertors::ConvertHexTypeU32ToWText(iw5mp_getdata::GetHWID_part3())); +} + +void windows_accountpage::UpdateCurrentNETData() +{ + uint8_t addrIP[4] = { 0 }; + hooks::serializeNetData_get::ExternalIP(addrIP); + CWindowTextWriter_WriteText(&externalip.edit_show, textconvertors::ConvertIPToWText(addrIP)); + hooks::serializeNetData_get::LocalIP(addrIP); + CWindowTextWriter_WriteText(&localip.edit_show, textconvertors::ConvertIPToWText(addrIP)); + hooks::serializeNetData_get::OtherlIP1(addrIP); + CWindowTextWriter_WriteText(&someip1.edit_show, textconvertors::ConvertIPToWText(addrIP)); + hooks::serializeNetData_get::OtherlIP2(addrIP); + CWindowTextWriter_WriteText(&someip2.edit_show, textconvertors::ConvertIPToWText(addrIP)); + + CWindowTextWriter_WriteText(&exip_port.edit_show, textconvertors::ConvertDecTypeToU16ToWText(hooks::serializeNetData_get::ExternalPort())); + CWindowTextWriter_WriteText(&lip_port.edit_show, textconvertors::ConvertDecTypeToU16ToWText(hooks::serializeNetData_get::LocalPort())); + CWindowTextWriter_WriteText(&someip1_port.edit_show, textconvertors::ConvertDecTypeToU16ToWText(hooks::serializeNetData_get::OtherPort1())); + CWindowTextWriter_WriteText(&someip2_port.edit_show, textconvertors::ConvertDecTypeToU16ToWText(hooks::serializeNetData_get::OtherPort2())); +} + +void windows_accountpage::UpdateCurrentChallengeS2() +{ + CWindowTextWriter_WriteText(&firmware::challengeS2_part_1, textconvertors::ConvertHexTypeU32ToWText(hooks::iw5mp_functions::ns_GetChallengeS2::Get_P1())); + CWindowTextWriter_WriteText(&firmware::challengeS2_part_2, textconvertors::ConvertHexTypeU32ToWText(hooks::iw5mp_functions::ns_GetChallengeS2::Get_P2())); + CWindowTextWriter_WriteText(&firmware::challengeS2_part_3, textconvertors::ConvertHexTypeU32ToWText(hooks::iw5mp_functions::ns_GetChallengeS2::Get_P3())); + CWindowTextWriter_WriteText(&firmware::challengeS2_part_4, textconvertors::ConvertHexTypeU32ToWText(hooks::iw5mp_functions::ns_GetChallengeS2::Get_P4())); +} + +void windows_accountpage::DoJobOnConnect() +{ + if (nickname_autochage.isPressed) + { + control_nicknameetc.ForceExecuteJob_ApplyRand(); + } + if (xuidhwid_autochange.isPressed) + { + control_xuidhwid.ForceExecuteJob_ApplyRand(); + } + if (localexternalip_autochange.isPressed) + { + control_externallocalips.ForceExecuteJob_ApplyRand(); + } + if (upnp_autochange.isPressed) + { + UPnP::control_deviceinfo.ForceExecuteJob_ApplyRand(); + } + UpdateCurrentNickanameEtc(); + +} + +void windows_accountpage::UPnP::update_device::Location(const wchar_t* text) +{ + CWindowTextWriter_WriteText(&UPnP::device_field_location.edit_show, text); +} + +void windows_accountpage::UPnP::update_device::Server(const wchar_t* text) +{ + CWindowTextWriter_WriteText(&UPnP::device_field_server.edit_show, text); +} + +void windows_accountpage::UPnP::update_device::USN(const wchar_t* text) +{ + CWindowTextWriter_WriteText(&UPnP::device_field_USN.edit_show, text); +} + + +namespace windows_accountpage +{ + template + void ReadSmth_ChangeDeviceInfo() + { + hooks::bdUPnP_functions::SetDeviceInfo_location(UPnP::device_field_location.GetTextW(UPnP::textlim::device_field_location)); + hooks::bdUPnP_functions::SetDeviceInfo_server(UPnP::device_field_server.GetTextW(UPnP::textlim::device_field_server)); + hooks::bdUPnP_functions::SetDeviceInfo_USN(UPnP::device_field_USN.GetTextW(UPnP::textlim::device_field_USN)); + hooks::bdUPnP_functions::SetDeviceInfo(); + } +} + +void windows_accountpage::UPnP::ReadData_ChangeDeviceInfo() +{ + ReadSmth_ChangeDeviceInfo<0>(); +} + + +void windows_accountpage::UPnP::ReadRandData_ChangeDeviceInfo() +{ + ReadSmth_ChangeDeviceInfo<1>(); + +} + +void windows_accountpage::UPnP::ReadRandDataMask_ChangeDeviceInfo() +{ + ReadSmth_ChangeDeviceInfo<2>(); +} diff --git a/ultimateteknotool.v2/windows_accountpage.h b/ultimateteknotool.v2/windows_accountpage.h new file mode 100644 index 0000000..a7b8035 --- /dev/null +++ b/ultimateteknotool.v2/windows_accountpage.h @@ -0,0 +1,146 @@ +#pragma once +#include "CWindowsBuilder.h" +#include "CWindowsFontApplier.h" +#include "CWindowTextWriter.h" +#include "CWindowTextReader.h" +#include "CWinAPIFileW.h" +#include "CWindowCfgWriter.h" +#include "CWindowCfgReader.h" +#include "CWindowTextLimiter.h" + +namespace windows_accountpage +{ + struct WinCombo + { + CWindow_edit edit_show; + CWindow_edit_cfg edit_new; + CWindow_edit_cfg edit_new_randmask; + void Show() + { + edit_show.Show(); + edit_new.Show(); + edit_new_randmask.Show(); + } + void Hide() + { + edit_show.Hide(); + edit_new.Hide(); + edit_new_randmask.Hide(); + } + void ApplyFont(CWindowsFontApplier& fontappl) + { + edit_show.Visit(&fontappl); + edit_new.Visit(&fontappl); + edit_new_randmask.Visit(&fontappl); + } + void ApplyTextLimit(size_t limit) + { + CWindowTextLimiter_LimitText(&edit_show, limit); + CWindowTextLimiter_LimitText(&edit_new, limit); + CWindowTextLimiter_LimitText(&edit_new_randmask, limit); + } + inline void SetTextInShowEdit(const wchar_t* txt) + { + CWindowTextWriter_WriteText(&edit_show, txt); + } + inline wchar_t* GetNormalWText(unsigned short sz) + { + return CWindowTextReader_GetTextW(&this->edit_new, sz); + } + inline wchar_t* GetRandWText(unsigned short sz) + { + return CWindowTextReader_GetTextW_ParseRandMask(&this->edit_new_randmask, sz); + } + inline wchar_t* GetRandmaskWText(unsigned short sz) + { + return CWindowTextReader_GetTextW_ParseRandMask_Overwrite(&this->edit_new, &this->edit_new_randmask, sz); + } + template + inline wchar_t* GetTextW(unsigned short sz) + { + /* decompiled versions of utt proved that compiles only 1 variant*/ + if (id == 0) { + return CWindowTextReader_GetTextW(&this->edit_new, sz); + } + else if (id == 1) + { + return CWindowTextReader_GetTextW_ParseRandMask(&this->edit_new_randmask, sz); + } + else if (id == 2) + { + return CWindowTextReader_GetTextW_ParseRandMask_Overwrite(&this->edit_new, &this->edit_new_randmask, sz); + } + else + { + return CWindowTextReader_GetTextW(&this->edit_new, sz); + } + } + }; + + namespace changeonconnect + { + extern bool xuidhwidetc; + extern bool nicknameetc; + extern bool localexternalipetc; + }; + + void Build(CWindowsBuilder& builder, int left, int width, int top, int height, HWND hwnd); + void ApplyFonts(CWindowsFontApplier& fontappl); + void WriteDefault(); + void ApplyTextLimits(); + void Show(); + void Hide(); + + void Show_XuidHwidPage(); + void Hide_XuidHwidPage(); + void Show_LocalExternalIPPage(); + void Hide_LocalExternalIPPage(); + void Show_FirmwarePage(); + void Hide_FirmwarePage(); + void Show_UPnPPage(); + void Hide_UPnPPage(); + + void Show_XuidHwidPageHideOthers(); + void Show_LocalExternalIPHideOthers(); + void Show_FirmwareHideOthers(); + void Show_UPnPPageHideOthers(); + + void Handler_ClickButton(WPARAM wparam); + + void Cfg_SavePreCreateWindowSettings(CWindowCfgWriter* writer); + void Cfg_LoadPreCreateWindowSettings(CWindowCfgReader* reader); + void Cfg_Save(CWindowCfgWriter* writer); + void Cfg_Load(CWindowCfgReader* reader); + + void ReadData_ChangeNicknameEtc_andUpdate(); + void ReadRandData_ChangeNicknameEtc_andUpdate(); + void ReadRandDataMask_ChangeNicknameEtc_andUpdate(); + void ReadData_ChangeXUIDHWID_andUpdate(); + void ReadRandData_ChangeXUIDHWID_andUpdate(); + void ReadRandDataMask_ChangeXUIDHWID_andUpdate(); + void ReadData_ChangeNETData(); + void ReadRandData_ChangeNETData(); + void ReadRandDataMask_ChangeNETData(); + + + void UpdateCurrentNickanameEtc(); + void UpdateCurrentXUIDHWID(); + void UpdateCurrentNETData(); + + namespace UPnP + { + namespace update_device + { + void Location(const wchar_t* text); + void Server(const wchar_t* text); + void USN(const wchar_t* text); + }; + void ReadData_ChangeDeviceInfo(); + void ReadRandData_ChangeDeviceInfo(); + void ReadRandDataMask_ChangeDeviceInfo(); + }; + + void UpdateCurrentChallengeS2(); + + void DoJobOnConnect(); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/windows_cfgbuttons.cpp b/ultimateteknotool.v2/windows_cfgbuttons.cpp new file mode 100644 index 0000000..dab47ca --- /dev/null +++ b/ultimateteknotool.v2/windows_cfgbuttons.cpp @@ -0,0 +1,58 @@ +#include "pch.h" +#include "windows_cfgbuttons.h" +#include "compiletime_XORstring.h" + +namespace windows_cfgbuttons +{ + CWindow_button saveCfg; + CWindow_button loadCfg; + wchar_t ws_saveCfg[wstringSzFromSizeof(sizeof(L"save"))] = { 0 }; + wchar_t ws_loadCfg[wstringSzFromSizeof(sizeof(L"load"))] = { 0 }; +}; + +static CONSTEXPRENCRYPTSTRW(ws_saveCfg, L"save", 0x5690); +static CONSTEXPRENCRYPTSTRW(ws_loadCfg, L"load", 0x1690); +#define DECRYPT_saveCfg DECRYPTCONSTENCSTRW(ws_saveCfg, sizeof(L"save") / sizeof(wchar_t), 0x5690) +#define DECRYPT_loadCfg DECRYPTCONSTENCSTRW(ws_loadCfg, sizeof(L"load") / sizeof(wchar_t), 0x1690) + +void windows_cfgbuttons::Build(CWindowsBuilder& builder, int left, int width, int top, int height, int gap, HWND hwnd) +{ + DWORD FlatButtonStyleInvisble = (WS_CHILD & ~WS_VISIBLE) | BS_PUSHBUTTON | BS_CENTER | BS_FLAT; + builder.ChangeStyle(FlatButtonStyleInvisble); + + int rwidth = width / 2 - gap * 2; + int rheight = height - gap * 2; + + builder.ChangeHeight(rheight); + builder.ChangeWidth(rwidth); + builder.ChangeParentHWND(hwnd); + builder.ChangeLeftPos(left); + builder.ChangeTopPos(top); + copy_string_w((wchar_t*)ws_saveCfg, wstringSzFromSizeof(sizeof(ws_saveCfg)), DECRYPT_saveCfg, wstringSzFromSizeof(sizeof(L"save"))); + builder.ChangeTextP(ws_saveCfg); + saveCfg.Visit(&builder); + copy_string_w((wchar_t*)ws_loadCfg, wstringSzFromSizeof(sizeof(ws_loadCfg)), DECRYPT_loadCfg, wstringSzFromSizeof(sizeof(L"load"))); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeTextP(ws_loadCfg); + loadCfg.Visit(&builder); +} + +void windows_cfgbuttons::ApplyFonts(CWindowsFontApplier& fontappl) +{ + loadCfg.Visit(&fontappl); + saveCfg.Visit(&fontappl); +} + +void windows_cfgbuttons::Show() +{ + loadCfg.Show(); + saveCfg.Show(); +} + +void windows_cfgbuttons::Hide() +{ + loadCfg.Hide(); + saveCfg.Hide(); +} + + diff --git a/ultimateteknotool.v2/windows_cfgbuttons.h b/ultimateteknotool.v2/windows_cfgbuttons.h new file mode 100644 index 0000000..ebcbe06 --- /dev/null +++ b/ultimateteknotool.v2/windows_cfgbuttons.h @@ -0,0 +1,15 @@ +#pragma once +#include "CWindowsBuilder.h" +#include "CWindowsFontApplier.h" + +namespace windows_cfgbuttons +{ + extern CWindow_button saveCfg; + extern CWindow_button loadCfg; + + void Build(CWindowsBuilder& builder, int left, int width, int top, int height, int gap, HWND hwnd); + void ApplyFonts(CWindowsFontApplier& fontappl); + void Show(); + void Hide(); + +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/windows_injectorpage.cpp b/ultimateteknotool.v2/windows_injectorpage.cpp new file mode 100644 index 0000000..3953a53 --- /dev/null +++ b/ultimateteknotool.v2/windows_injectorpage.cpp @@ -0,0 +1,105 @@ +#include "pch.h" +#include "windows_injectorpage.h" +#include "Injector.h" +#include "debugconsole.h" + +namespace windows_injectorpage { + + const wchar_t ws_inject[] = L"inject"; + const wchar_t ws_emptytext[] = L""; + constexpr unsigned short maxlen_injectpathtofile = (128 - 32); + + class PathAndInjectButton + { + private: + CWindow_edit_cfg path; + CWindow_button injectorbutton; + public: + PathAndInjectButton() = default; + ~PathAndInjectButton() = default; + void Build(CWindowsBuilder& builder, int editwidth, int buttonwidth, int height, int gap) + { + constexpr DWORD FlatButtonStyleInvisble = (WS_CHILD & ~WS_VISIBLE) | BS_PUSHBUTTON | BS_CENTER | BS_FLAT; + constexpr DWORD NewEditStyle_Invisible = WS_CHILD & ~WS_VISIBLE | WS_BORDER; + + builder.ChangeStyle(NewEditStyle_Invisible); + builder.ChangeHeight(height); + builder.ChangeWidth(editwidth); + builder.ChangeTextP(ws_emptytext); + this->path.Visit(&builder); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeStyle(FlatButtonStyleInvisble); + builder.ChangeWidth(buttonwidth); + builder.ChangeTextP(ws_inject); + this->injectorbutton.Visit(&builder); + } + void Show() const + { + path.Show(); + injectorbutton.Show(); + } + void Hide() const + { + path.Hide(); + injectorbutton.Hide(); + } + void ButtonHandler(WPARAM& wparam) + { + if (injectorbutton.id == LOWORD(wparam)) + { + Injector::Inject0r().APC_Inject(CWindowTextReader_GetTextW(&path, maxlen_injectpathtofile)); + } + } + void ApplyFonts(CWindowsFontApplier& fontmaster) + { + this->injectorbutton.Visit(&fontmaster); + this->path.Visit(&fontmaster); + } + }; + + PathAndInjectButton path1; + PathAndInjectButton path2; + +}; + +void windows_injectorpage::Build(CWindowsBuilder& builder, int left, int width, int top, int height, HWND hwnd) +{ + builder.ChangeParentHWND(hwnd); + builder.ChangeLeftPos(left); + builder.ChangeTopPos(top); + + int gap = 5; + int bwidth = 50; + int editwidth = width - (left*2 + gap + bwidth); + int rheight = 20; + + path1.Build(builder, editwidth, bwidth, rheight, gap); + builder.ChangeLeftPos(left); + builder.ChangeTopPos(builder.build_top_pos + builder.build_height + gap); + path2.Build(builder, editwidth, bwidth, rheight, gap); +} + +void windows_injectorpage::ApplyFonts(CWindowsFontApplier& fontappl) +{ + path1.ApplyFonts(fontappl); + path2.ApplyFonts(fontappl); +} + +void windows_injectorpage::Show() +{ + path1.Show(); + path2.Show(); +} + +void windows_injectorpage::Hide() +{ + path1.Hide(); + path2.Hide(); +} + +void windows_injectorpage::ButtonHandler(WPARAM& param) +{ + path1.ButtonHandler(param); + path2.ButtonHandler(param); +} + diff --git a/ultimateteknotool.v2/windows_injectorpage.h b/ultimateteknotool.v2/windows_injectorpage.h new file mode 100644 index 0000000..2ac7692 --- /dev/null +++ b/ultimateteknotool.v2/windows_injectorpage.h @@ -0,0 +1,14 @@ +#pragma once +#include "CWindowsBuilder.h" +#include "CWindowsFontApplier.h" +#include "CWindowTextWriter.h" +#include "CWindowTextReader.h" + +namespace windows_injectorpage { + + void Build(CWindowsBuilder& builder, int left, int width, int top, int height, HWND hwnd); + void ApplyFonts(CWindowsFontApplier& fontappl); + void Show(); + void Hide(); + void ButtonHandler(WPARAM& param); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/windows_maincontrolbuttons.cpp b/ultimateteknotool.v2/windows_maincontrolbuttons.cpp new file mode 100644 index 0000000..5b663de --- /dev/null +++ b/ultimateteknotool.v2/windows_maincontrolbuttons.cpp @@ -0,0 +1,95 @@ +#include "pch.h" +#include "windows_maincontrolbuttons.h" + +namespace windows_maincontrolbuttons { + CWindow_button Account; + CWindow_button Players; + CWindow_button Injector; + + void Build(CWindowsBuilder& builder, int left, int width, int top, int height, HWND hwnd) + { + builder.ChangeParentHWND(hwnd); + builder.ChangeLeftPos(left); + builder.ChangeTopPos(top); + + + DWORD FlatButtonStyleInvisble = (WS_CHILD & ~WS_VISIBLE) | BS_PUSHBUTTON | BS_CENTER | BS_FLAT; + builder.ChangeStyle(FlatButtonStyleInvisble); + + + int freewidth = width - left * 2; + int numberofbuttons = 3; + int gap = 5; + int rwidth = (freewidth - numberofbuttons * gap) / numberofbuttons; + + builder.ChangeTextP(ws_Account); + builder.ChangeWidth(rwidth); + builder.ChangeHeight(20); + + Account.Visit(&builder); + + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeTextP(ws_Players); + + Players.Visit(&builder); + + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + gap); + builder.ChangeTextP(ws_Injector); + + Injector.Visit(&builder); + } + void ApplyFonts(CWindowsFontApplier& fontappl) + { + if (Account.hwnd != 0) { Account.Visit(&fontappl); } + if (Players.hwnd != 0) { Players.Visit(&fontappl); } + if (Injector.hwnd != 0) { Injector.Visit(&fontappl); } + } + void Show() + { + Account.Show(); + Players.Show(); + Injector.Show(); + } + + void Show_Account_HideOthers() + { + windows_injectorpage::Hide(); + windows_playerspage::Hide(); + windows_accountpage::Show(); + } + + void Show_Injector_HideOthers() + { + windows_accountpage::Hide(); + windows_playerspage::Hide(); + windows_injectorpage::Show(); + } + + void Show_Players_HideOthers() + { + windows_injectorpage::Hide(); + windows_accountpage::Hide(); + windows_playerspage::Show(); + } + + void ButtonHandler(WPARAM& param) + { + + if (LOWORD(param) == Account.id) + { + Show_Account_HideOthers(); + } + else if (LOWORD(param) == Players.id) + { + Show_Players_HideOthers(); + } + else if (LOWORD(param) == Injector.id) + { + Show_Injector_HideOthers(); + } + else + { + + } + } +}; diff --git a/ultimateteknotool.v2/windows_maincontrolbuttons.h b/ultimateteknotool.v2/windows_maincontrolbuttons.h new file mode 100644 index 0000000..2942478 --- /dev/null +++ b/ultimateteknotool.v2/windows_maincontrolbuttons.h @@ -0,0 +1,21 @@ +#pragma once +#include "CWindowsBuilder.h" +#include "CWindowsFontApplier.h" +#include "windows_accountpage.h" +#include "windows_injectorpage.h" +#include "windows_playerspage.h" + +namespace windows_maincontrolbuttons { + constexpr wchar_t ws_Account[] = L"Account"; + constexpr wchar_t ws_Players[] = L"Players"; + constexpr wchar_t ws_Injector[] = L"Injector"; + extern CWindow_button Account; + extern CWindow_button Players; + extern CWindow_button Injector; + + + void Build(CWindowsBuilder& builder, int left, int width, int top, int height, HWND hwnd); + void ApplyFonts(CWindowsFontApplier& fontappl); + void Show(); + void ButtonHandler(WPARAM& param); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/windows_playerspage.cpp b/ultimateteknotool.v2/windows_playerspage.cpp new file mode 100644 index 0000000..99b9e67 --- /dev/null +++ b/ultimateteknotool.v2/windows_playerspage.cpp @@ -0,0 +1,134 @@ +#include "pch.h" +#include "windows_playerspage.h" +#include "TextConvertors.h" +#include "iw5mp_players_functions.h" +#include "compiletime_XORstring.h" + +static CONSTEXPRENCRYPTSTRW(str18, L"18", 0x13FA); +static CONSTEXPRENCRYPTSTRW(str_initial, L"initial", 0x12FA); +static CONSTEXPRENCRYPTSTRW(str_refresh, L"refresh", 0x3031); +static CONSTEXPRENCRYPTSTRW(str_kick, L"kick", 0x5690); +#define DECRYPT_18 DECRYPTCONSTENCSTRW(str18, sizeof(L"18") / sizeof(wchar_t), 0x13FA) +#define DECRYPT_initial DECRYPTCONSTENCSTRW(str_initial, sizeof(L"initial") / sizeof(wchar_t), 0x12FA) +#define DECRYPT_refresh DECRYPTCONSTENCSTRW(str_refresh, sizeof(L"refresh") / sizeof(wchar_t), 0x3031) +#define DECRYPT_kick DECRYPTCONSTENCSTRW(str_kick, sizeof(L"kick") / sizeof(wchar_t), 0x5690) + +namespace windows_playerspage +{ + CWindow_edit playersDataOutput; + CWindow_button forceRefresh; + CWindow_edit player_index; + CWindow_button kickbutton; + wchar_t ws_index[wstringSzFromSizeof(sizeof(L"18"))] = { 0 }; + wchar_t ws_initial[wstringSzFromSizeof(sizeof(L"initial"))] = { 0 }; + wchar_t ws_refresh[wstringSzFromSizeof(sizeof(L"refresh"))] = { 0 }; + wchar_t ws_kick[wstringSzFromSizeof(sizeof(L"kick"))] = { 0 }; + void SetText(const wchar_t* text) + { + ::SendMessageW(playersDataOutput.hwnd, WM_SETTEXT, 0 /*not used */, reinterpret_cast(text)); + } + static bool shown = false; + + static uint32_t currentPlayerIndex = 20; + +}; + +void windows_playerspage::Build(CWindowsBuilder& builder, int left, int width, int top, int height, HWND hwnd) +{ + constexpr DWORD EDITSTYLE = WS_CHILD & ~WS_VISIBLE | WS_BORDER | WS_VSCROLL | ES_MULTILINE | ES_AUTOVSCROLL | ES_READONLY; + constexpr DWORD FlatButtonStyleInvisble = (WS_CHILD & ~WS_VISIBLE) | BS_PUSHBUTTON | BS_CENTER | BS_FLAT; + constexpr DWORD NewEditStyle_Invisible = WS_CHILD & ~WS_VISIBLE | WS_BORDER; + builder.ChangeParentHWND(hwnd); + builder.ChangeLeftPos(left); + builder.ChangeTopPos(top); + + int rwidth = width - width / 8; + int rheight = height - height / 4; + builder.ChangeHeight(rheight); + builder.ChangeWidth(rwidth); + builder.ChangeStyle(EDITSTYLE); + copy_string_w((wchar_t*)ws_initial, wstringSzFromSizeof(sizeof(ws_initial)), DECRYPT_initial, wstringSzFromSizeof(sizeof(L"initial"))); + builder.ChangeTextP(ws_initial); + playersDataOutput.Visit(&builder); + + builder.ChangeTopPos(builder.build_top_pos + builder.build_height + 5); + rwidth = 70; + rheight = 20; + builder.ChangeHeight(rheight); + builder.ChangeWidth(rwidth); + builder.ChangeStyle(FlatButtonStyleInvisble); + copy_string_w((wchar_t*)ws_refresh, wstringSzFromSizeof(sizeof(ws_refresh)), DECRYPT_refresh, wstringSzFromSizeof(sizeof(L"refresh"))); + builder.ChangeTextP(ws_refresh); + forceRefresh.Visit(&builder); + + rwidth = 30; + builder.ChangeStyle(NewEditStyle_Invisible); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + 5); + copy_string_w((wchar_t*)ws_index, wstringSzFromSizeof(sizeof(ws_index)), DECRYPT_18, wstringSzFromSizeof(sizeof(L"18"))); + builder.ChangeTextP(ws_index); + player_index.Visit(&builder); + + rwidth = 60; + builder.ChangeStyle(FlatButtonStyleInvisble); + builder.ChangeLeftPos(builder.build_left_pos + builder.build_width + 5); + copy_string_w((wchar_t*)ws_kick, wstringSzFromSizeof(sizeof(ws_kick)), DECRYPT_kick, wstringSzFromSizeof(sizeof(L"kick"))); + builder.ChangeTextP(ws_kick); + kickbutton.Visit(&builder); +} + +void windows_playerspage::ApplyFonts(CWindowsFontApplier& fontappl) +{ + playersDataOutput.Visit(&fontappl); + forceRefresh.Visit(&fontappl); + kickbutton.Visit(&fontappl); + player_index.Visit(&fontappl); +} + +void windows_playerspage::ApplyTextLimits() +{ + CWindowTextLimiter_LimitText(&playersDataOutput, iw5mp_getdata::players_data::XUIDandNETData_BUFFER_SIZE); +} + +void windows_playerspage::Show() +{ + playersDataOutput.Show(); + forceRefresh.Show(); + kickbutton.Show(); + player_index.Show(); + shown = true; +} + +void windows_playerspage::Hide() +{ + playersDataOutput.Hide(); + forceRefresh.Hide(); + kickbutton.Hide(); + player_index.Hide(); + shown = false; +} + +void windows_playerspage::PrintPlayersData() +{ + SetText(iw5mp_getdata::players_data::GetPackedData_XUIDandNETData()); +} + + + +void windows_playerspage::Handler_ClickButton(WPARAM wparam) +{ + if (LOWORD(wparam) == forceRefresh.id) + { + SetText(iw5mp_getdata::players_data::GetPackedData_XUIDandNETData()); + } + else if (LOWORD(wparam) == kickbutton.id) + { + currentPlayerIndex = textconvertors::ConvertWTextDecTypeToU16(CWindowTextReader_GetTextW(&player_index, 4)); + WCWOUT("Kicking player, index: ", std::dec, currentPlayerIndex); + iw5mp_exploits::KickUserViaND(currentPlayerIndex); + } + else + { + + } + +} diff --git a/ultimateteknotool.v2/windows_playerspage.h b/ultimateteknotool.v2/windows_playerspage.h new file mode 100644 index 0000000..5594444 --- /dev/null +++ b/ultimateteknotool.v2/windows_playerspage.h @@ -0,0 +1,21 @@ +#pragma once +#include "CWindowsBuilder.h" +#include "CWindowsFontApplier.h" +#include "CWindowTextWriter.h" +#include "CWindowTextReader.h" +#include "CWinAPIFileW.h" +#include "CWindowCfgWriter.h" +#include "CWindowCfgReader.h" +#include "CWindowTextLimiter.h" + +namespace windows_playerspage +{ + void Build(CWindowsBuilder& builder, int left, int width, int top, int height, HWND hwnd); + void ApplyFonts(CWindowsFontApplier& fontappl); + void ApplyTextLimits(); + void Show(); + void Hide(); + + void PrintPlayersData(); + void Handler_ClickButton(WPARAM wparam); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/windows_quickbuttons.cpp b/ultimateteknotool.v2/windows_quickbuttons.cpp new file mode 100644 index 0000000..0db9069 --- /dev/null +++ b/ultimateteknotool.v2/windows_quickbuttons.cpp @@ -0,0 +1,53 @@ +#include "pch.h" +#include "windows_quickbuttons.h" +#include "iw5mp_quickbuttons_functions.h" +#include "compiletime_XORstring.h" + +namespace windows_quickbuttons +{ + CWindow_button forceDisconnect; + wchar_t ws_forceDisconnect[wstringSzFromSizeof(sizeof(L"fdisc"))] = { 0 } ; +}; + +static CONSTEXPRENCRYPTSTRW(ws_forceDisconnect, L"fdisc", 0x6690); +#define DECRYPT_fdisconnect DECRYPTCONSTENCSTRW(ws_forceDisconnect, sizeof(L"fdisc") / sizeof(wchar_t), 0x6690) + +void windows_quickbuttons::Build(CWindowsBuilder& builder, int left, int width, int top, int height, int gap, HWND hwnd) +{ + constexpr DWORD FlatButtonStyleInvisble = (WS_CHILD & ~WS_VISIBLE) | BS_PUSHBUTTON | BS_CENTER | BS_FLAT; + builder.ChangeParentHWND(hwnd); + builder.ChangeLeftPos(left); + builder.ChangeTopPos(top); + copy_string_w((wchar_t*)ws_forceDisconnect, wstringSzFromSizeof(sizeof(ws_forceDisconnect)), DECRYPT_fdisconnect, wstringSzFromSizeof(sizeof(L"fdisc"))); + builder.ChangeTextP(ws_forceDisconnect); + int rwidth = width - gap * 2; + int rheight = height - gap * 2; + builder.ChangeHeight(rheight); + builder.ChangeWidth(rwidth); + builder.ChangeStyle(FlatButtonStyleInvisble); + + forceDisconnect.Visit(&builder); +} + +void windows_quickbuttons::ApplyFonts(CWindowsFontApplier& fontappl) +{ + forceDisconnect.Visit(&fontappl); +} + +void windows_quickbuttons::Show() +{ + forceDisconnect.Show(); +} + +void windows_quickbuttons::Hide() +{ + forceDisconnect.Hide(); +} + +void windows_quickbuttons::Handler_ClickButton(WPARAM wparam) +{ + if (LOWORD(wparam) == forceDisconnect.id) + { + iw5mp_changedata::ForceJumpToMenu(); + } +} diff --git a/ultimateteknotool.v2/windows_quickbuttons.h b/ultimateteknotool.v2/windows_quickbuttons.h new file mode 100644 index 0000000..71b92d3 --- /dev/null +++ b/ultimateteknotool.v2/windows_quickbuttons.h @@ -0,0 +1,20 @@ +#pragma once +#include "CWindowsBuilder.h" +#include "CWindowsFontApplier.h" +#include "CWindowTextWriter.h" +#include "CWindowTextReader.h" +#include "CWinAPIFileW.h" +#include "CWindowCfgWriter.h" +#include "CWindowCfgReader.h" +#include "CWindowTextLimiter.h" + +namespace windows_quickbuttons +{ + void Build(CWindowsBuilder& builder, int left, int width, int top, int height, int gap, HWND hwnd); + void ApplyFonts(CWindowsFontApplier& fontappl); + //void ApplyTextLimits(); + void Show(); + void Hide(); + + void Handler_ClickButton(WPARAM wparam); +}; \ No newline at end of file diff --git a/ultimateteknotool.v2/СWindowTextWriter.cpp b/ultimateteknotool.v2/СWindowTextWriter.cpp new file mode 100644 index 0000000..a1a4c79 --- /dev/null +++ b/ultimateteknotool.v2/СWindowTextWriter.cpp @@ -0,0 +1,2 @@ +#include "pch.h" +#include "CWindowTextWriter.h"