X-Git-Url: http://git.silcnet.org/gitweb/?p=crypto.git;a=blobdiff_plain;f=lib%2Fsilcmath%2Ftfm.h;fp=lib%2Fsilcmath%2Ftfm.h;h=aedf42a1cad8248e32140fe429dc43992ccb8ae9;hp=677f2885469c1236f3c42947cc01817e6262064a;hb=abd261065eac46a2d2c970833f3fa701bc1516e3;hpb=63da89e60c01aa62254648b3aafc88261181da65 diff --git a/lib/silcmath/tfm.h b/lib/silcmath/tfm.h index 677f2885..aedf42a1 100644 --- a/lib/silcmath/tfm.h +++ b/lib/silcmath/tfm.h @@ -5,7 +5,7 @@ * * This project is public domain and free for all purposes. * - * Tom St Denis, tomstdenis@iahu.ca + * Tom St Denis, tomstdenis@gmail.com */ #ifndef TFM_H_ #define TFM_H_ @@ -16,44 +16,89 @@ #include #include -/* Assure these -Pekka */ +typedef struct tfm_fp_int_struct tfm_fp_int; + +#include + #undef CRYPT -#undef MIN -#define MIN(x,y) ((x)<(y)?(x):(y)) -#undef MAX -#define MAX(x,y) ((x)>(y)?(x):(y)) +#ifdef SILC_X86_64 +#define TFM_X86_64 +#endif /* SILC_X86_64 */ -/* do we want large code? */ -#define TFM_LARGE +#ifdef SILC_I386 +#define TFM_X86 +#ifdef SILC_CPU_SSE2 +#define TFM_SSE2 +#endif /* SILC_CPU_SSE2 */ +#endif /* SILC_I386 */ -/* do we want huge code (implies large)? The answer is, yes. */ -#define TFM_HUGE +#ifndef MIN + #define MIN(x,y) ((x)<(y)?(x):(y)) +#endif + +#ifndef MAX + #define MAX(x,y) ((x)>(y)?(x):(y)) +#endif + +/* externally define this symbol to ignore the default settings, useful for changing the build from the make process */ +#ifndef TFM_ALREADY_SET + +/* do we want the large set of small multiplications ? + Enable these if you are going to be doing a lot of small (<= 16 digit) multiplications say in ECC + Or if you're on a 64-bit machine doing RSA as a 1024-bit integer == 16 digits ;-) + */ +#define TFM_SMALL_SET + +/* do we want huge code + Enable these if you are doing 20, 24, 28, 32, 48, 64 digit multiplications (useful for RSA) + Less important on 64-bit machines as 32 digits == 2048 bits + */ +#define TFM_MUL20 +#define TFM_MUL24 +#define TFM_MUL28 +#define TFM_MUL32 +#define TFM_MUL48 +#define TFM_MUL64 + +#define TFM_SQR20 +#define TFM_SQR24 +#define TFM_SQR28 +#define TFM_SQR32 +#define TFM_SQR48 +#define TFM_SQR64 + +/* do we want some overflow checks + Not required if you make sure your numbers are within range (e.g. by default a modulus for tfm_fp_exptmod() can only be upto 2048 bits long) + */ +#define TFM_CHECK + +/* Is the target a P4 Prescott + */ +/* #define TFM_PRESCOTT */ + +/* Do we want timing resistant tfm_fp_exptmod() ? + * This makes it slower but also timing invariant with respect to the exponent + */ +/* #define TFM_TIMING_RESISTANT */ -/* imply TFM_LARGE as required */ -#if defined(TFM_HUGE) - #if !defined(TFM_LARGE) - #define TFM_LARGE - #endif #endif /* Max size of any number in bits. Basically the largest size you will be multiplying - * should be half [or smaller] of FP_MAX_SIZE-four_digit + * should be half [or smaller] of TFM_FP_MAX_SIZE-four_digit * - * You can externally define this or it defaults to 4096-bits. + * You can externally define this or it defaults to 4096-bits [allowing multiplications upto 2048x2048 bits ] */ -#ifndef FP_MAX_SIZE -/* For SILC -Pekka */ - #define FP_MAX_SIZE (8192+(4*DIGIT_BIT)) -/* #define FP_MAX_SIZE (4096+(4*DIGIT_BIT))*/ +#ifndef TFM_FP_MAX_SIZE + #define TFM_FP_MAX_SIZE (8192+(8*DIGIT_BIT)) #endif /* will this lib work? */ #if (CHAR_BIT & 7) #error CHAR_BIT must be a multiple of eight. #endif -#if FP_MAX_SIZE % CHAR_BIT - #error FP_MAX_SIZE must be a multiple of CHAR_BIT +#if TFM_FP_MAX_SIZE % CHAR_BIT + #error TFM_FP_MAX_SIZE must be a multiple of CHAR_BIT #endif /* autodetect x86-64 and make sure we are using 64-bit digits with x86-64 asm */ @@ -66,8 +111,8 @@ #endif #endif #if defined(TFM_X86_64) - #if !defined(FP_64BIT) - #define FP_64BIT + #if !defined(TFM_FP_64BIT) + #define TFM_FP_64BIT #endif #endif @@ -81,10 +126,10 @@ #endif #endif -/* make sure we're 32-bit for x86-32/sse/arm */ -#if (defined(TFM_X86) || defined(TFM_SSE2) || defined(TFM_ARM)) && defined(FP_64BIT) - #warning x86-32, SSE2 and ARM optimizations require 32-bit digits (undefining) - #undef FP_64BIT +/* make sure we're 32-bit for x86-32/sse/arm/ppc32 */ +#if (defined(TFM_X86) || defined(TFM_SSE2) || defined(TFM_ARM) || defined(TFM_PPC32)) && defined(TFM_FP_64BIT) + #warning x86-32, SSE2 and ARM, PPC32 optimizations require 32-bit digits (undefining) + #undef TFM_FP_64BIT #endif /* multi asms? */ @@ -109,6 +154,24 @@ #endif #define TFM_ASM #endif +#ifdef TFM_PPC32 + #ifdef TFM_ASM + #error TFM_ASM already defined! + #endif + #define TFM_ASM +#endif +#ifdef TFM_PPC64 + #ifdef TFM_ASM + #error TFM_ASM already defined! + #endif + #define TFM_ASM +#endif +#ifdef TFM_AVR32 + #ifdef TFM_ASM + #error TFM_ASM already defined! + #endif + #define TFM_ASM +#endif /* we want no asm? */ #ifdef TFM_NO_ASM @@ -116,18 +179,73 @@ #undef TFM_X86_64 #undef TFM_SSE2 #undef TFM_ARM + #undef TFM_PPC32 + #undef TFM_PPC64 + #undef TFM_AVR32 #undef TFM_ASM #endif +/* ECC helpers */ +#ifdef TFM_ECC192 + #ifdef TFM_FP_64BIT + #define TFM_MUL3 + #define TFM_SQR3 + #else + #define TFM_MUL6 + #define TFM_SQR6 + #endif +#endif + +#ifdef TFM_ECC224 + #ifdef TFM_FP_64BIT + #define TFM_MUL4 + #define TFM_SQR4 + #else + #define TFM_MUL7 + #define TFM_SQR7 + #endif +#endif + +#ifdef TFM_ECC256 + #ifdef TFM_FP_64BIT + #define TFM_MUL4 + #define TFM_SQR4 + #else + #define TFM_MUL8 + #define TFM_SQR8 + #endif +#endif + +#ifdef TFM_ECC384 + #ifdef TFM_FP_64BIT + #define TFM_MUL6 + #define TFM_SQR6 + #else + #define TFM_MUL12 + #define TFM_SQR12 + #endif +#endif + +#ifdef TFM_ECC521 + #ifdef TFM_FP_64BIT + #define TFM_MUL9 + #define TFM_SQR9 + #else + #define TFM_MUL17 + #define TFM_SQR17 + #endif +#endif + + /* some default configurations. */ -#if defined(FP_64BIT) +#if defined(TFM_FP_64BIT) /* for GCC only on supported platforms */ #ifndef CRYPT - typedef unsigned long ulong64; + typedef SilcUInt64 ulong64; #endif - typedef ulong64 fp_digit; - typedef unsigned long fp_word __attribute__ ((mode(TI))); + typedef ulong64 tfm_fp_digit; + typedef unsigned long tfm_fp_word __attribute__ ((mode(TI))); #else /* this is to make porting into LibTomCrypt easier :-) */ #ifndef CRYPT @@ -139,224 +257,241 @@ typedef signed long long long64; #endif #endif - typedef unsigned long fp_digit; - typedef ulong64 fp_word; + typedef unsigned long tfm_fp_digit; + typedef ulong64 tfm_fp_word; #endif /* # of digits this is */ -#define DIGIT_BIT (int)((CHAR_BIT) * sizeof(fp_digit)) -#define FP_MASK (fp_digit)(-1) -#define FP_SIZE (FP_MAX_SIZE/DIGIT_BIT) +#define DIGIT_BIT (int)((CHAR_BIT) * sizeof(tfm_fp_digit)) +#define TFM_FP_MASK (tfm_fp_digit)(-1) +#define TFM_FP_SIZE (TFM_FP_MAX_SIZE/DIGIT_BIT) /* signs */ -#define FP_ZPOS 0 -#define FP_NEG 1 +#define TFM_FP_ZPOS 0 +#define TFM_FP_NEG 1 /* return codes */ -#define FP_OKAY 0 -#define FP_VAL 1 -#define FP_MEM 2 +#define TFM_FP_OKAY 0 +#define TFM_FP_VAL 1 +#define TFM_FP_MEM 2 /* equalities */ -#define FP_LT -1 /* less than */ -#define FP_EQ 0 /* equal to */ -#define FP_GT 1 /* greater than */ +#define TFM_FP_LT -1 /* less than */ +#define TFM_FP_EQ 0 /* equal to */ +#define TFM_FP_GT 1 /* greater than */ /* replies */ -#define FP_YES 1 /* yes response */ -#define FP_NO 0 /* no response */ +#define TFM_FP_YES 1 /* yes response */ +#define TFM_FP_NO 0 /* no response */ /* a FP type */ -typedef struct { - fp_digit dp[FP_SIZE]; - int used, - sign; -} fp_int; +struct tfm_fp_int_struct { + SilcStack stack; + tfm_fp_digit *dp; + unsigned int used; + unsigned int alloc : 31; + unsigned int sign : 1; +}; /* functions */ -/* returns a TFM ident string useful for debugging... */ -const char *fp_ident(void); - /* initialize [or zero] an fp int */ -#define fp_init(a) (void)memset((a), 0, sizeof(fp_int)) -#define fp_zero(a) fp_init(a) +#define tfm_fp_init(a) tfm_fp_sinit(NULL, a) +#define tfm_fp_sinit(s, a) \ + { (a)->stack = s; (a)->dp = NULL; (a)->alloc = (a)->used = (a)->sign = 0; } +int tfm_fp_init_size(SilcStack stack, tfm_fp_int *a, int size); +void tfm_fp_zero(tfm_fp_int *a); /* zero/even/odd ? */ -#define fp_iszero(a) (((a)->used == 0) ? FP_YES : FP_NO) -#define fp_iseven(a) (((a)->used > 0 && (((a)->dp[0] & 1) == 0)) ? FP_YES : FP_NO) -#define fp_isodd(a) (((a)->used > 0 && (((a)->dp[0] & 1) == 1)) ? FP_YES : FP_NO) +#define tfm_fp_iszero(a) (((a)->used == 0) ? TFM_FP_YES : TFM_FP_NO) +#define tfm_fp_iseven(a) (((a)->used >= 0 && (((a)->dp[0] & 1) == 0)) ? TFM_FP_YES : TFM_FP_NO) +#define tfm_fp_isodd(a) (((a)->used > 0 && (((a)->dp[0] & 1) == 1)) ? TFM_FP_YES : TFM_FP_NO) /* set to a small digit */ -void fp_set(fp_int *a, fp_digit b); +int tfm_fp_set(tfm_fp_int *a, tfm_fp_digit b); /* copy from a to b */ -#define fp_copy(a, b) (void)(((a) != (b)) && memcpy((b), (a), sizeof(fp_int))) -#define fp_init_copy(a, b) fp_copy(b, a) - -/* negate and absolute */ -#define fp_neg(a, b) { fp_copy(a, b); (b)->sign ^= 1; } -#define fp_abs(a, b) { fp_copy(a, b); (b)->sign = 0; } +int tfm_fp_copy(tfm_fp_int *a, tfm_fp_int *b); +int tfm_fp_init_copy(tfm_fp_int *a, tfm_fp_int *b, SilcStack stack); +void tfm_fp_exch(tfm_fp_int *a, tfm_fp_int *b); /* clamp digits */ -#define fp_clamp(a) { while ((a)->used && (a)->dp[(a)->used-1] == 0) --((a)->used); (a)->sign = (a)->used ? (a)->sign : FP_ZPOS; } +#define tfm_fp_clamp(a) { while ((a)->used && (a)->dp[(a)->used-1] == 0) --((a)->used); (a)->sign = (a)->used ? (a)->sign : TFM_FP_ZPOS; } + +/* negate and absolute */ +#define tfm_fp_neg(a, b) { tfm_fp_copy(a, b); (b)->sign ^= 1; tfm_fp_clamp(b); } +#define tfm_fp_abs(a, b) { tfm_fp_copy(a, b); (b)->sign = 0; } /* right shift x digits */ -void fp_rshd(fp_int *a, int x); +void tfm_fp_rshd(tfm_fp_int *a, int x); /* left shift x digits */ -void fp_lshd(fp_int *a, int x); +int tfm_fp_lshd(tfm_fp_int *a, int x); /* signed comparison */ -int fp_cmp(fp_int *a, fp_int *b); +int tfm_fp_cmp(tfm_fp_int *a, tfm_fp_int *b); /* unsigned comparison */ -int fp_cmp_mag(fp_int *a, fp_int *b); +int tfm_fp_cmp_mag(tfm_fp_int *a, tfm_fp_int *b); /* power of 2 operations */ -void fp_div_2d(fp_int *a, int b, fp_int *c, fp_int *d); -void fp_mod_2d(fp_int *a, int b, fp_int *c); -void fp_mul_2d(fp_int *a, int b, fp_int *c); -void fp_2expt (fp_int *a, int b); -void fp_mul_2(fp_int *a, fp_int *c); -void fp_div_2(fp_int *a, fp_int *c); +int tfm_fp_div_2d(tfm_fp_int *a, int b, tfm_fp_int *c, tfm_fp_int *d); +int tfm_fp_mod_2d(tfm_fp_int *a, int b, tfm_fp_int *c); +int tfm_fp_mul_2d(tfm_fp_int *a, int b, tfm_fp_int *c); +int tfm_fp_2expt (tfm_fp_int *a, int b); +int tfm_fp_mul_2(tfm_fp_int *a, tfm_fp_int *c); +int tfm_fp_div_2(tfm_fp_int *a, tfm_fp_int *c); /* Counts the number of lsbs which are zero before the first zero bit */ -int fp_cnt_lsb(fp_int *a); +int tfm_fp_cnt_lsb(tfm_fp_int *a); /* c = a + b */ -void fp_add(fp_int *a, fp_int *b, fp_int *c); +int tfm_fp_add(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c); /* c = a - b */ -void fp_sub(fp_int *a, fp_int *b, fp_int *c); +int tfm_fp_sub(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c); /* c = a * b */ -void fp_mul(fp_int *a, fp_int *b, fp_int *c); +int tfm_fp_mul(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c); /* b = a*a */ -void fp_sqr(fp_int *a, fp_int *b); +int tfm_fp_sqr(tfm_fp_int *a, tfm_fp_int *b); /* a/b => cb + d == a */ -int fp_div(fp_int *a, fp_int *b, fp_int *c, fp_int *d); +int tfm_fp_div(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c, tfm_fp_int *d); /* c = a mod b, 0 <= c < b */ -int fp_mod(fp_int *a, fp_int *b, fp_int *c); +int tfm_fp_mod(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c); /* compare against a single digit */ -int fp_cmp_d(fp_int *a, fp_digit b); +int tfm_fp_cmp_d(tfm_fp_int *a, tfm_fp_digit b); /* c = a + b */ -void fp_add_d(fp_int *a, fp_digit b, fp_int *c); +int tfm_fp_add_d(tfm_fp_int *a, tfm_fp_digit b, tfm_fp_int *c); /* c = a - b */ -void fp_sub_d(fp_int *a, fp_digit b, fp_int *c); +int tfm_fp_sub_d(tfm_fp_int *a, tfm_fp_digit b, tfm_fp_int *c); /* c = a * b */ -void fp_mul_d(fp_int *a, fp_digit b, fp_int *c); +int tfm_fp_mul_d(tfm_fp_int *a, tfm_fp_digit b, tfm_fp_int *c); /* a/b => cb + d == a */ -int fp_div_d(fp_int *a, fp_digit b, fp_int *c, fp_digit *d); +int tfm_fp_div_d(tfm_fp_int *a, tfm_fp_digit b, tfm_fp_int *c, tfm_fp_digit *d); /* c = a mod b, 0 <= c < b */ -int fp_mod_d(fp_int *a, fp_digit b, fp_digit *c); +int tfm_fp_mod_d(tfm_fp_int *a, tfm_fp_digit b, tfm_fp_digit *c); /* ---> number theory <--- */ /* d = a + b (mod c) */ -int fp_addmod(fp_int *a, fp_int *b, fp_int *c, fp_int *d); +int tfm_fp_addmod(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c, tfm_fp_int *d); /* d = a - b (mod c) */ -int fp_submod(fp_int *a, fp_int *b, fp_int *c, fp_int *d); +int tfm_fp_submod(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c, tfm_fp_int *d); /* d = a * b (mod c) */ -int fp_mulmod(fp_int *a, fp_int *b, fp_int *c, fp_int *d); +int tfm_fp_mulmod(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c, tfm_fp_int *d); /* c = a * a (mod b) */ -int fp_sqrmod(fp_int *a, fp_int *b, fp_int *c); +int tfm_fp_sqrmod(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c); /* c = 1/a (mod b) */ -int fp_invmod(fp_int *a, fp_int *b, fp_int *c); +int tfm_fp_invmod(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c); /* c = (a, b) */ -void fp_gcd(fp_int *a, fp_int *b, fp_int *c); +int tfm_fp_gcd(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c); /* c = [a, b] */ -void fp_lcm(fp_int *a, fp_int *b, fp_int *c); +int tfm_fp_lcm(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c); + +int tfm_fp_sqrt(tfm_fp_int *arg, tfm_fp_int *ret); +int tfm_fp_expt_d(tfm_fp_int * a, tfm_fp_digit b, tfm_fp_int * c); +int tfm_fp_xor(tfm_fp_int * a, tfm_fp_int * b, tfm_fp_int * c); +int tfm_fp_and(tfm_fp_int * a, tfm_fp_int * b, tfm_fp_int * c); +int tfm_fp_or(tfm_fp_int * a, tfm_fp_int * b, tfm_fp_int * c); /* setups the montgomery reduction */ -int fp_montgomery_setup(fp_int *a, fp_digit *mp); +int tfm_fp_montgomery_setup(tfm_fp_int *a, tfm_fp_digit *mp); /* computes a = B**n mod b without division or multiplication useful for * normalizing numbers in a Montgomery system. */ -void fp_montgomery_calc_normalization(fp_int *a, fp_int *b); +int tfm_fp_montgomery_calc_normalization(tfm_fp_int *a, tfm_fp_int *b); /* computes x/R == x (mod N) via Montgomery Reduction */ -void fp_montgomery_reduce(fp_int *a, fp_int *m, fp_digit mp); +int tfm_fp_montgomery_reduce(tfm_fp_int *a, tfm_fp_int *m, tfm_fp_digit mp); /* d = a**b (mod c) */ -int fp_exptmod(fp_int *a, fp_int *b, fp_int *c, fp_int *d); +int tfm_fp_exptmod(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c, tfm_fp_int *d); -/* primality stuff */ +/* radix conersions */ +int tfm_fp_count_bits(tfm_fp_int *a); -/* perform a Miller-Rabin test of a to the base b and store result in "result" */ -void fp_prime_miller_rabin (fp_int * a, fp_int * b, int *result); +int tfm_fp_unsigned_bin_size(tfm_fp_int *a); +void tfm_fp_read_unsigned_bin(tfm_fp_int *a, unsigned char *b, int c); +void tfm_fp_to_unsigned_bin(tfm_fp_int *a, unsigned char *b); -/* 256 trial divisions + 8 Miller-Rabins, returns FP_YES if probable prime */ -int fp_isprime(fp_int *a); +int tfm_fp_signed_bin_size(tfm_fp_int *a); +void tfm_fp_to_signed_bin(tfm_fp_int *a, unsigned char *b); -/* Primality generation flags */ -#define TFM_PRIME_BBS 0x0001 /* BBS style prime */ -#define TFM_PRIME_SAFE 0x0002 /* Safe prime (p-1)/2 == prime */ -#define TFM_PRIME_2MSB_OFF 0x0004 /* force 2nd MSB to 0 */ -#define TFM_PRIME_2MSB_ON 0x0008 /* force 2nd MSB to 1 */ +int tfm_fp_read_radix(tfm_fp_int *a, char *str, int radix); +int tfm_fp_toradix(tfm_fp_int *a, char *str, int radix); +int tfm_fp_toradix_n(tfm_fp_int * a, char *str, int radix, int maxlen); +int tfm_fp_radix_size(tfm_fp_int *a, int radix, int *size); -/* callback for fp_prime_random, should fill dst with random bytes and return how many read [upto len] */ -typedef int tfm_prime_callback(unsigned char *dst, int len, void *dat); -#define fp_prime_random(a, t, size, bbs, cb, dat) fp_prime_random_ex(a, t, ((size) * 8) + 1, (bbs==1)?TFM_PRIME_BBS:0, cb, dat) +/* VARIOUS LOW LEVEL STUFFS */ +int s_tfm_fp_add(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c); +int s_tfm_fp_sub(tfm_fp_int *a, tfm_fp_int *b, tfm_fp_int *c); +void tfm_fp_reverse(unsigned char *s, int len); -int fp_prime_random_ex(fp_int *a, int t, int size, int flags, tfm_prime_callback cb, void *dat); +int tfm_fp_mul_comba(tfm_fp_int *A, tfm_fp_int *B, tfm_fp_int *C); -/* radix conersions */ -int fp_count_bits(fp_int *a); +#ifdef TFM_SMALL_SET +void tfm_fp_mul_comba_small(tfm_fp_int *A, tfm_fp_int *B, tfm_fp_int *C); +#endif -int fp_unsigned_bin_size(fp_int *a); -void fp_read_unsigned_bin(fp_int *a, unsigned char *b, int c); -void fp_to_unsigned_bin(fp_int *a, unsigned char *b); +#ifdef TFM_MUL20 +void tfm_fp_mul_comba20(tfm_fp_int *A, tfm_fp_int *B, tfm_fp_int *C); +#endif +#ifdef TFM_MUL24 +void tfm_fp_mul_comba24(tfm_fp_int *A, tfm_fp_int *B, tfm_fp_int *C); +#endif +#ifdef TFM_MUL28 +void tfm_fp_mul_comba28(tfm_fp_int *A, tfm_fp_int *B, tfm_fp_int *C); +#endif +#ifdef TFM_MUL32 +void tfm_fp_mul_comba32(tfm_fp_int *A, tfm_fp_int *B, tfm_fp_int *C); +#endif +#ifdef TFM_MUL48 +void tfm_fp_mul_comba48(tfm_fp_int *A, tfm_fp_int *B, tfm_fp_int *C); +#endif +#ifdef TFM_MUL64 +void tfm_fp_mul_comba64(tfm_fp_int *A, tfm_fp_int *B, tfm_fp_int *C); +#endif -int fp_signed_bin_size(fp_int *a); -void fp_read_signed_bin(fp_int *a, unsigned char *b, int c); -void fp_to_signed_bin(fp_int *a, unsigned char *b); +int tfm_fp_sqr_comba(tfm_fp_int *A, tfm_fp_int *B); -int fp_read_radix(fp_int *a, char *str, int radix); -int fp_toradix(fp_int *a, char *str, int radix); -int fp_toradix_n(fp_int * a, char *str, int radix, int maxlen); -int fp_radix_size(fp_int *a, int radix, int *size); +#ifdef TFM_SMALL_SET +void tfm_fp_sqr_comba_small(tfm_fp_int *A, tfm_fp_int *B); +#endif -/* VARIOUS LOW LEVEL STUFFS */ -void s_fp_add(fp_int *a, fp_int *b, fp_int *c); -void s_fp_sub(fp_int *a, fp_int *b, fp_int *c); -void bn_reverse(unsigned char *s, int len); -void fp_mul_comba(fp_int *A, fp_int *B, fp_int *C); -#ifdef TFM_HUGE -void fp_mul_comba32(fp_int *A, fp_int *B, fp_int *C); -#endif -#ifdef TFM_LARGE -void fp_mul_comba16(fp_int *A, fp_int *B, fp_int *C); -#endif -void fp_mul_comba8(fp_int *A, fp_int *B, fp_int *C); -void fp_mul_comba4(fp_int *A, fp_int *B, fp_int *C); - -void fp_sqr_comba(fp_int *A, fp_int *B); -void fp_sqr_comba4(fp_int *A, fp_int *B); -void fp_sqr_comba8(fp_int *A, fp_int *B); -#ifdef TFM_LARGE -void fp_sqr_comba16(fp_int *A, fp_int *B); -#endif -#ifdef TFM_HUGE -void fp_sqr_comba32(fp_int *A, fp_int *B); -void fp_sqr_comba64(fp_int *A, fp_int *B); -#endif -extern const char *fp_s_rmap; +#ifdef TFM_SQR20 +void tfm_fp_sqr_comba20(tfm_fp_int *A, tfm_fp_int *B); +#endif +#ifdef TFM_SQR24 +void tfm_fp_sqr_comba24(tfm_fp_int *A, tfm_fp_int *B); +#endif +#ifdef TFM_SQR28 +void tfm_fp_sqr_comba28(tfm_fp_int *A, tfm_fp_int *B); +#endif +#ifdef TFM_SQR32 +void tfm_fp_sqr_comba32(tfm_fp_int *A, tfm_fp_int *B); +#endif +#ifdef TFM_SQR48 +void tfm_fp_sqr_comba48(tfm_fp_int *A, tfm_fp_int *B); +#endif +#ifdef TFM_SQR64 +void tfm_fp_sqr_comba64(tfm_fp_int *A, tfm_fp_int *B); +#endif #endif