diff options
author | djm <> | 2009-01-09 12:14:11 +0000 |
---|---|---|
committer | djm <> | 2009-01-09 12:14:11 +0000 |
commit | a0fdc9ec41594852f67ec77dfad9cb06bacc4186 (patch) | |
tree | c43f6b3a4d93ad2cb3dcf93275295679d895a033 /src/lib/libcrypto/bn | |
parent | 5a3c0a05c7f2c5d3c584b7c8d6aec836dd724c80 (diff) | |
download | openbsd-a0fdc9ec41594852f67ec77dfad9cb06bacc4186.tar.gz openbsd-a0fdc9ec41594852f67ec77dfad9cb06bacc4186.tar.bz2 openbsd-a0fdc9ec41594852f67ec77dfad9cb06bacc4186.zip |
import openssl-0.9.8j
Diffstat (limited to 'src/lib/libcrypto/bn')
-rw-r--r-- | src/lib/libcrypto/bn/bn.h | 15 | ||||
-rw-r--r-- | src/lib/libcrypto/bn/bn_div.c | 15 | ||||
-rw-r--r-- | src/lib/libcrypto/bn/bn_gf2m.c | 6 | ||||
-rw-r--r-- | src/lib/libcrypto/bn/bn_lib.c | 19 | ||||
-rw-r--r-- | src/lib/libcrypto/bn/bn_nist.c | 776 | ||||
-rw-r--r-- | src/lib/libcrypto/bn/bn_rand.c | 6 | ||||
-rw-r--r-- | src/lib/libcrypto/bn/bn_shift.c | 2 | ||||
-rw-r--r-- | src/lib/libcrypto/bn/bn_x931p.c | 40 |
8 files changed, 510 insertions, 369 deletions
diff --git a/src/lib/libcrypto/bn/bn.h b/src/lib/libcrypto/bn/bn.h index 6d754d5547..f1719a5877 100644 --- a/src/lib/libcrypto/bn/bn.h +++ b/src/lib/libcrypto/bn/bn.h | |||
@@ -408,8 +408,8 @@ BIGNUM *BN_CTX_get(BN_CTX *ctx); | |||
408 | void BN_CTX_end(BN_CTX *ctx); | 408 | void BN_CTX_end(BN_CTX *ctx); |
409 | int BN_rand(BIGNUM *rnd, int bits, int top,int bottom); | 409 | int BN_rand(BIGNUM *rnd, int bits, int top,int bottom); |
410 | int BN_pseudo_rand(BIGNUM *rnd, int bits, int top,int bottom); | 410 | int BN_pseudo_rand(BIGNUM *rnd, int bits, int top,int bottom); |
411 | int BN_rand_range(BIGNUM *rnd, BIGNUM *range); | 411 | int BN_rand_range(BIGNUM *rnd, const BIGNUM *range); |
412 | int BN_pseudo_rand_range(BIGNUM *rnd, BIGNUM *range); | 412 | int BN_pseudo_rand_range(BIGNUM *rnd, const BIGNUM *range); |
413 | int BN_num_bits(const BIGNUM *a); | 413 | int BN_num_bits(const BIGNUM *a); |
414 | int BN_num_bits_word(BN_ULONG); | 414 | int BN_num_bits_word(BN_ULONG); |
415 | BIGNUM *BN_new(void); | 415 | BIGNUM *BN_new(void); |
@@ -531,6 +531,17 @@ int BN_is_prime_ex(const BIGNUM *p,int nchecks, BN_CTX *ctx, BN_GENCB *cb); | |||
531 | int BN_is_prime_fasttest_ex(const BIGNUM *p,int nchecks, BN_CTX *ctx, | 531 | int BN_is_prime_fasttest_ex(const BIGNUM *p,int nchecks, BN_CTX *ctx, |
532 | int do_trial_division, BN_GENCB *cb); | 532 | int do_trial_division, BN_GENCB *cb); |
533 | 533 | ||
534 | int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx); | ||
535 | |||
536 | int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, | ||
537 | const BIGNUM *Xp, const BIGNUM *Xp1, const BIGNUM *Xp2, | ||
538 | const BIGNUM *e, BN_CTX *ctx, BN_GENCB *cb); | ||
539 | int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, | ||
540 | BIGNUM *Xp1, BIGNUM *Xp2, | ||
541 | const BIGNUM *Xp, | ||
542 | const BIGNUM *e, BN_CTX *ctx, | ||
543 | BN_GENCB *cb); | ||
544 | |||
534 | BN_MONT_CTX *BN_MONT_CTX_new(void ); | 545 | BN_MONT_CTX *BN_MONT_CTX_new(void ); |
535 | void BN_MONT_CTX_init(BN_MONT_CTX *ctx); | 546 | void BN_MONT_CTX_init(BN_MONT_CTX *ctx); |
536 | int BN_mod_mul_montgomery(BIGNUM *r,const BIGNUM *a,const BIGNUM *b, | 547 | int BN_mod_mul_montgomery(BIGNUM *r,const BIGNUM *a,const BIGNUM *b, |
diff --git a/src/lib/libcrypto/bn/bn_div.c b/src/lib/libcrypto/bn/bn_div.c index 8655eb118e..1e8e57626b 100644 --- a/src/lib/libcrypto/bn/bn_div.c +++ b/src/lib/libcrypto/bn/bn_div.c | |||
@@ -187,6 +187,17 @@ int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor, | |||
187 | BN_ULONG d0,d1; | 187 | BN_ULONG d0,d1; |
188 | int num_n,div_n; | 188 | int num_n,div_n; |
189 | 189 | ||
190 | /* Invalid zero-padding would have particularly bad consequences | ||
191 | * in the case of 'num', so don't just rely on bn_check_top() for this one | ||
192 | * (bn_check_top() works only for BN_DEBUG builds) */ | ||
193 | if (num->top > 0 && num->d[num->top - 1] == 0) | ||
194 | { | ||
195 | BNerr(BN_F_BN_DIV,BN_R_NOT_INITIALIZED); | ||
196 | return 0; | ||
197 | } | ||
198 | |||
199 | bn_check_top(num); | ||
200 | |||
190 | if ((BN_get_flags(num, BN_FLG_CONSTTIME) != 0) || (BN_get_flags(divisor, BN_FLG_CONSTTIME) != 0)) | 201 | if ((BN_get_flags(num, BN_FLG_CONSTTIME) != 0) || (BN_get_flags(divisor, BN_FLG_CONSTTIME) != 0)) |
191 | { | 202 | { |
192 | return BN_div_no_branch(dv, rm, num, divisor, ctx); | 203 | return BN_div_no_branch(dv, rm, num, divisor, ctx); |
@@ -194,7 +205,7 @@ int BN_div(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, const BIGNUM *divisor, | |||
194 | 205 | ||
195 | bn_check_top(dv); | 206 | bn_check_top(dv); |
196 | bn_check_top(rm); | 207 | bn_check_top(rm); |
197 | bn_check_top(num); | 208 | /* bn_check_top(num); */ /* 'num' has been checked already */ |
198 | bn_check_top(divisor); | 209 | bn_check_top(divisor); |
199 | 210 | ||
200 | if (BN_is_zero(divisor)) | 211 | if (BN_is_zero(divisor)) |
@@ -419,7 +430,7 @@ static int BN_div_no_branch(BIGNUM *dv, BIGNUM *rm, const BIGNUM *num, | |||
419 | 430 | ||
420 | bn_check_top(dv); | 431 | bn_check_top(dv); |
421 | bn_check_top(rm); | 432 | bn_check_top(rm); |
422 | bn_check_top(num); | 433 | /* bn_check_top(num); */ /* 'num' has been checked in BN_div() */ |
423 | bn_check_top(divisor); | 434 | bn_check_top(divisor); |
424 | 435 | ||
425 | if (BN_is_zero(divisor)) | 436 | if (BN_is_zero(divisor)) |
diff --git a/src/lib/libcrypto/bn/bn_gf2m.c b/src/lib/libcrypto/bn/bn_gf2m.c index 6a793857e1..306f029f27 100644 --- a/src/lib/libcrypto/bn/bn_gf2m.c +++ b/src/lib/libcrypto/bn/bn_gf2m.c | |||
@@ -384,7 +384,11 @@ int BN_GF2m_mod_arr(BIGNUM *r, const BIGNUM *a, const unsigned int p[]) | |||
384 | if (zz == 0) break; | 384 | if (zz == 0) break; |
385 | d1 = BN_BITS2 - d0; | 385 | d1 = BN_BITS2 - d0; |
386 | 386 | ||
387 | if (d0) z[dN] = (z[dN] << d1) >> d1; /* clear up the top d1 bits */ | 387 | /* clear up the top d1 bits */ |
388 | if (d0) | ||
389 | z[dN] = (z[dN] << d1) >> d1; | ||
390 | else | ||
391 | z[dN] = 0; | ||
388 | z[0] ^= zz; /* reduction t^0 component */ | 392 | z[0] ^= zz; /* reduction t^0 component */ |
389 | 393 | ||
390 | for (k = 1; p[k] != 0; k++) | 394 | for (k = 1; p[k] != 0; k++) |
diff --git a/src/lib/libcrypto/bn/bn_lib.c b/src/lib/libcrypto/bn/bn_lib.c index 2649b8c538..32a8fbaf51 100644 --- a/src/lib/libcrypto/bn/bn_lib.c +++ b/src/lib/libcrypto/bn/bn_lib.c | |||
@@ -139,25 +139,6 @@ const BIGNUM *BN_value_one(void) | |||
139 | return(&const_one); | 139 | return(&const_one); |
140 | } | 140 | } |
141 | 141 | ||
142 | char *BN_options(void) | ||
143 | { | ||
144 | static int init=0; | ||
145 | static char data[16]; | ||
146 | |||
147 | if (!init) | ||
148 | { | ||
149 | init++; | ||
150 | #ifdef BN_LLONG | ||
151 | BIO_snprintf(data,sizeof data,"bn(%d,%d)", | ||
152 | (int)sizeof(BN_ULLONG)*8,(int)sizeof(BN_ULONG)*8); | ||
153 | #else | ||
154 | BIO_snprintf(data,sizeof data,"bn(%d,%d)", | ||
155 | (int)sizeof(BN_ULONG)*8,(int)sizeof(BN_ULONG)*8); | ||
156 | #endif | ||
157 | } | ||
158 | return(data); | ||
159 | } | ||
160 | |||
161 | int BN_num_bits_word(BN_ULONG l) | 142 | int BN_num_bits_word(BN_ULONG l) |
162 | { | 143 | { |
163 | static const char bits[256]={ | 144 | static const char bits[256]={ |
diff --git a/src/lib/libcrypto/bn/bn_nist.c b/src/lib/libcrypto/bn/bn_nist.c index e14232fdbb..2ca5b01391 100644 --- a/src/lib/libcrypto/bn/bn_nist.c +++ b/src/lib/libcrypto/bn/bn_nist.c | |||
@@ -59,109 +59,266 @@ | |||
59 | #include "bn_lcl.h" | 59 | #include "bn_lcl.h" |
60 | #include "cryptlib.h" | 60 | #include "cryptlib.h" |
61 | 61 | ||
62 | |||
62 | #define BN_NIST_192_TOP (192+BN_BITS2-1)/BN_BITS2 | 63 | #define BN_NIST_192_TOP (192+BN_BITS2-1)/BN_BITS2 |
63 | #define BN_NIST_224_TOP (224+BN_BITS2-1)/BN_BITS2 | 64 | #define BN_NIST_224_TOP (224+BN_BITS2-1)/BN_BITS2 |
64 | #define BN_NIST_256_TOP (256+BN_BITS2-1)/BN_BITS2 | 65 | #define BN_NIST_256_TOP (256+BN_BITS2-1)/BN_BITS2 |
65 | #define BN_NIST_384_TOP (384+BN_BITS2-1)/BN_BITS2 | 66 | #define BN_NIST_384_TOP (384+BN_BITS2-1)/BN_BITS2 |
66 | #define BN_NIST_521_TOP (521+BN_BITS2-1)/BN_BITS2 | 67 | #define BN_NIST_521_TOP (521+BN_BITS2-1)/BN_BITS2 |
67 | 68 | ||
69 | /* pre-computed tables are "carry-less" values of modulus*(i+1) */ | ||
68 | #if BN_BITS2 == 64 | 70 | #if BN_BITS2 == 64 |
69 | static const BN_ULONG _nist_p_192[] = | 71 | static const BN_ULONG _nist_p_192[][BN_NIST_192_TOP] = { |
70 | {0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFEULL, | 72 | {0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFEULL,0xFFFFFFFFFFFFFFFFULL}, |
71 | 0xFFFFFFFFFFFFFFFFULL}; | 73 | {0xFFFFFFFFFFFFFFFEULL,0xFFFFFFFFFFFFFFFDULL,0xFFFFFFFFFFFFFFFFULL}, |
72 | static const BN_ULONG _nist_p_224[] = | 74 | {0xFFFFFFFFFFFFFFFDULL,0xFFFFFFFFFFFFFFFCULL,0xFFFFFFFFFFFFFFFFULL} |
75 | }; | ||
76 | static const BN_ULONG _nist_p_192_sqr[] = { | ||
77 | 0x0000000000000001ULL,0x0000000000000002ULL,0x0000000000000001ULL, | ||
78 | 0xFFFFFFFFFFFFFFFEULL,0xFFFFFFFFFFFFFFFDULL,0xFFFFFFFFFFFFFFFFULL | ||
79 | }; | ||
80 | static const BN_ULONG _nist_p_224[][BN_NIST_224_TOP] = { | ||
73 | {0x0000000000000001ULL,0xFFFFFFFF00000000ULL, | 81 | {0x0000000000000001ULL,0xFFFFFFFF00000000ULL, |
74 | 0xFFFFFFFFFFFFFFFFULL,0x00000000FFFFFFFFULL}; | 82 | 0xFFFFFFFFFFFFFFFFULL,0x00000000FFFFFFFFULL}, |
75 | static const BN_ULONG _nist_p_256[] = | 83 | {0x0000000000000002ULL,0xFFFFFFFE00000000ULL, |
84 | 0xFFFFFFFFFFFFFFFFULL,0x00000001FFFFFFFFULL} /* this one is "carry-full" */ | ||
85 | }; | ||
86 | static const BN_ULONG _nist_p_224_sqr[] = { | ||
87 | 0x0000000000000001ULL,0xFFFFFFFE00000000ULL, | ||
88 | 0xFFFFFFFFFFFFFFFFULL,0x0000000200000000ULL, | ||
89 | 0x0000000000000000ULL,0xFFFFFFFFFFFFFFFEULL, | ||
90 | 0xFFFFFFFFFFFFFFFFULL | ||
91 | }; | ||
92 | static const BN_ULONG _nist_p_256[][BN_NIST_256_TOP] = { | ||
76 | {0xFFFFFFFFFFFFFFFFULL,0x00000000FFFFFFFFULL, | 93 | {0xFFFFFFFFFFFFFFFFULL,0x00000000FFFFFFFFULL, |
77 | 0x0000000000000000ULL,0xFFFFFFFF00000001ULL}; | 94 | 0x0000000000000000ULL,0xFFFFFFFF00000001ULL}, |
78 | static const BN_ULONG _nist_p_384[] = | 95 | {0xFFFFFFFFFFFFFFFEULL,0x00000001FFFFFFFFULL, |
79 | {0x00000000FFFFFFFFULL,0xFFFFFFFF00000000ULL, | 96 | 0x0000000000000000ULL,0xFFFFFFFE00000002ULL}, |
80 | 0xFFFFFFFFFFFFFFFEULL,0xFFFFFFFFFFFFFFFFULL, | 97 | {0xFFFFFFFFFFFFFFFDULL,0x00000002FFFFFFFFULL, |
81 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL}; | 98 | 0x0000000000000000ULL,0xFFFFFFFD00000003ULL}, |
99 | {0xFFFFFFFFFFFFFFFCULL,0x00000003FFFFFFFFULL, | ||
100 | 0x0000000000000000ULL,0xFFFFFFFC00000004ULL}, | ||
101 | {0xFFFFFFFFFFFFFFFBULL,0x00000004FFFFFFFFULL, | ||
102 | 0x0000000000000000ULL,0xFFFFFFFB00000005ULL}, | ||
103 | }; | ||
104 | static const BN_ULONG _nist_p_256_sqr[] = { | ||
105 | 0x0000000000000001ULL,0xFFFFFFFE00000000ULL, | ||
106 | 0xFFFFFFFFFFFFFFFFULL,0x00000001FFFFFFFEULL, | ||
107 | 0x00000001FFFFFFFEULL,0x00000001FFFFFFFEULL, | ||
108 | 0xFFFFFFFE00000001ULL,0xFFFFFFFE00000002ULL | ||
109 | }; | ||
110 | static const BN_ULONG _nist_p_384[][BN_NIST_384_TOP] = { | ||
111 | {0x00000000FFFFFFFFULL,0xFFFFFFFF00000000ULL,0xFFFFFFFFFFFFFFFEULL, | ||
112 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL}, | ||
113 | {0x00000001FFFFFFFEULL,0xFFFFFFFE00000000ULL,0xFFFFFFFFFFFFFFFDULL, | ||
114 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL}, | ||
115 | {0x00000002FFFFFFFDULL,0xFFFFFFFD00000000ULL,0xFFFFFFFFFFFFFFFCULL, | ||
116 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL}, | ||
117 | {0x00000003FFFFFFFCULL,0xFFFFFFFC00000000ULL,0xFFFFFFFFFFFFFFFBULL, | ||
118 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL}, | ||
119 | {0x00000004FFFFFFFBULL,0xFFFFFFFB00000000ULL,0xFFFFFFFFFFFFFFFAULL, | ||
120 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL}, | ||
121 | }; | ||
122 | static const BN_ULONG _nist_p_384_sqr[] = { | ||
123 | 0xFFFFFFFE00000001ULL,0x0000000200000000ULL,0xFFFFFFFE00000000ULL, | ||
124 | 0x0000000200000000ULL,0x0000000000000001ULL,0x0000000000000000ULL, | ||
125 | 0x00000001FFFFFFFEULL,0xFFFFFFFE00000000ULL,0xFFFFFFFFFFFFFFFDULL, | ||
126 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL | ||
127 | }; | ||
82 | static const BN_ULONG _nist_p_521[] = | 128 | static const BN_ULONG _nist_p_521[] = |
83 | {0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL, | 129 | {0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL, |
84 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL, | 130 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL, |
85 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL, | 131 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL, |
86 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL, | 132 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL, |
87 | 0x00000000000001FFULL}; | 133 | 0x00000000000001FFULL}; |
134 | static const BN_ULONG _nist_p_521_sqr[] = { | ||
135 | 0x0000000000000001ULL,0x0000000000000000ULL,0x0000000000000000ULL, | ||
136 | 0x0000000000000000ULL,0x0000000000000000ULL,0x0000000000000000ULL, | ||
137 | 0x0000000000000000ULL,0x0000000000000000ULL,0xFFFFFFFFFFFFFC00ULL, | ||
138 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL, | ||
139 | 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL, | ||
140 | 0xFFFFFFFFFFFFFFFFULL,0x000000000003FFFFULL | ||
141 | }; | ||
88 | #elif BN_BITS2 == 32 | 142 | #elif BN_BITS2 == 32 |
89 | static const BN_ULONG _nist_p_192[] = {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFE, | 143 | static const BN_ULONG _nist_p_192[][BN_NIST_192_TOP] = { |
90 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF}; | 144 | {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFE,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF}, |
91 | static const BN_ULONG _nist_p_224[] = {0x00000001,0x00000000,0x00000000, | 145 | {0xFFFFFFFE,0xFFFFFFFF,0xFFFFFFFD,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF}, |
92 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF}; | 146 | {0xFFFFFFFD,0xFFFFFFFF,0xFFFFFFFC,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF} |
93 | static const BN_ULONG _nist_p_256[] = {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF, | 147 | }; |
94 | 0x00000000,0x00000000,0x00000000,0x00000001,0xFFFFFFFF}; | 148 | static const BN_ULONG _nist_p_192_sqr[] = { |
95 | static const BN_ULONG _nist_p_384[] = {0xFFFFFFFF,0x00000000,0x00000000, | 149 | 0x00000001,0x00000000,0x00000002,0x00000000,0x00000001,0x00000000, |
96 | 0xFFFFFFFF,0xFFFFFFFE,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF, | 150 | 0xFFFFFFFE,0xFFFFFFFF,0xFFFFFFFD,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF |
97 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF}; | 151 | }; |
152 | static const BN_ULONG _nist_p_224[][BN_NIST_224_TOP] = { | ||
153 | {0x00000001,0x00000000,0x00000000,0xFFFFFFFF, | ||
154 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF}, | ||
155 | {0x00000002,0x00000000,0x00000000,0xFFFFFFFE, | ||
156 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF} | ||
157 | }; | ||
158 | static const BN_ULONG _nist_p_224_sqr[] = { | ||
159 | 0x00000001,0x00000000,0x00000000,0xFFFFFFFE, | ||
160 | 0xFFFFFFFF,0xFFFFFFFF,0x00000000,0x00000002, | ||
161 | 0x00000000,0x00000000,0xFFFFFFFE,0xFFFFFFFF, | ||
162 | 0xFFFFFFFF,0xFFFFFFFF | ||
163 | }; | ||
164 | static const BN_ULONG _nist_p_256[][BN_NIST_256_TOP] = { | ||
165 | {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0x00000000, | ||
166 | 0x00000000,0x00000000,0x00000001,0xFFFFFFFF}, | ||
167 | {0xFFFFFFFE,0xFFFFFFFF,0xFFFFFFFF,0x00000001, | ||
168 | 0x00000000,0x00000000,0x00000002,0xFFFFFFFE}, | ||
169 | {0xFFFFFFFD,0xFFFFFFFF,0xFFFFFFFF,0x00000002, | ||
170 | 0x00000000,0x00000000,0x00000003,0xFFFFFFFD}, | ||
171 | {0xFFFFFFFC,0xFFFFFFFF,0xFFFFFFFF,0x00000003, | ||
172 | 0x00000000,0x00000000,0x00000004,0xFFFFFFFC}, | ||
173 | {0xFFFFFFFB,0xFFFFFFFF,0xFFFFFFFF,0x00000004, | ||
174 | 0x00000000,0x00000000,0x00000005,0xFFFFFFFB}, | ||
175 | }; | ||
176 | static const BN_ULONG _nist_p_256_sqr[] = { | ||
177 | 0x00000001,0x00000000,0x00000000,0xFFFFFFFE, | ||
178 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFE,0x00000001, | ||
179 | 0xFFFFFFFE,0x00000001,0xFFFFFFFE,0x00000001, | ||
180 | 0x00000001,0xFFFFFFFE,0x00000002,0xFFFFFFFE | ||
181 | }; | ||
182 | static const BN_ULONG _nist_p_384[][BN_NIST_384_TOP] = { | ||
183 | {0xFFFFFFFF,0x00000000,0x00000000,0xFFFFFFFF,0xFFFFFFFE,0xFFFFFFFF, | ||
184 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF}, | ||
185 | {0xFFFFFFFE,0x00000001,0x00000000,0xFFFFFFFE,0xFFFFFFFD,0xFFFFFFFF, | ||
186 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF}, | ||
187 | {0xFFFFFFFD,0x00000002,0x00000000,0xFFFFFFFD,0xFFFFFFFC,0xFFFFFFFF, | ||
188 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF}, | ||
189 | {0xFFFFFFFC,0x00000003,0x00000000,0xFFFFFFFC,0xFFFFFFFB,0xFFFFFFFF, | ||
190 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF}, | ||
191 | {0xFFFFFFFB,0x00000004,0x00000000,0xFFFFFFFB,0xFFFFFFFA,0xFFFFFFFF, | ||
192 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF}, | ||
193 | }; | ||
194 | static const BN_ULONG _nist_p_384_sqr[] = { | ||
195 | 0x00000001,0xFFFFFFFE,0x00000000,0x00000002,0x00000000,0xFFFFFFFE, | ||
196 | 0x00000000,0x00000002,0x00000001,0x00000000,0x00000000,0x00000000, | ||
197 | 0xFFFFFFFE,0x00000001,0x00000000,0xFFFFFFFE,0xFFFFFFFD,0xFFFFFFFF, | ||
198 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF | ||
199 | }; | ||
98 | static const BN_ULONG _nist_p_521[] = {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF, | 200 | static const BN_ULONG _nist_p_521[] = {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF, |
99 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF, | 201 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF, |
100 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF, | 202 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF, |
101 | 0xFFFFFFFF,0x000001FF}; | 203 | 0xFFFFFFFF,0x000001FF}; |
204 | static const BN_ULONG _nist_p_521_sqr[] = { | ||
205 | 0x00000001,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000, | ||
206 | 0x00000000,0x00000000,0x00000000,0x00000000,0x00000000,0x00000000, | ||
207 | 0x00000000,0x00000000,0x00000000,0x00000000,0xFFFFFC00,0xFFFFFFFF, | ||
208 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF, | ||
209 | 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF, | ||
210 | 0xFFFFFFFF,0xFFFFFFFF,0x0003FFFF | ||
211 | }; | ||
212 | #else | ||
213 | #error "unsupported BN_BITS2" | ||
102 | #endif | 214 | #endif |
103 | 215 | ||
216 | |||
217 | static const BIGNUM _bignum_nist_p_192 = | ||
218 | { | ||
219 | (BN_ULONG *)_nist_p_192[0], | ||
220 | BN_NIST_192_TOP, | ||
221 | BN_NIST_192_TOP, | ||
222 | 0, | ||
223 | BN_FLG_STATIC_DATA | ||
224 | }; | ||
225 | |||
226 | static const BIGNUM _bignum_nist_p_224 = | ||
227 | { | ||
228 | (BN_ULONG *)_nist_p_224[0], | ||
229 | BN_NIST_224_TOP, | ||
230 | BN_NIST_224_TOP, | ||
231 | 0, | ||
232 | BN_FLG_STATIC_DATA | ||
233 | }; | ||
234 | |||
235 | static const BIGNUM _bignum_nist_p_256 = | ||
236 | { | ||
237 | (BN_ULONG *)_nist_p_256[0], | ||
238 | BN_NIST_256_TOP, | ||
239 | BN_NIST_256_TOP, | ||
240 | 0, | ||
241 | BN_FLG_STATIC_DATA | ||
242 | }; | ||
243 | |||
244 | static const BIGNUM _bignum_nist_p_384 = | ||
245 | { | ||
246 | (BN_ULONG *)_nist_p_384[0], | ||
247 | BN_NIST_384_TOP, | ||
248 | BN_NIST_384_TOP, | ||
249 | 0, | ||
250 | BN_FLG_STATIC_DATA | ||
251 | }; | ||
252 | |||
253 | static const BIGNUM _bignum_nist_p_521 = | ||
254 | { | ||
255 | (BN_ULONG *)_nist_p_521, | ||
256 | BN_NIST_521_TOP, | ||
257 | BN_NIST_521_TOP, | ||
258 | 0, | ||
259 | BN_FLG_STATIC_DATA | ||
260 | }; | ||
261 | |||
262 | |||
104 | const BIGNUM *BN_get0_nist_prime_192(void) | 263 | const BIGNUM *BN_get0_nist_prime_192(void) |
105 | { | 264 | { |
106 | static BIGNUM const_nist_192 = { (BN_ULONG *)_nist_p_192, | 265 | return &_bignum_nist_p_192; |
107 | BN_NIST_192_TOP, BN_NIST_192_TOP, 0, BN_FLG_STATIC_DATA }; | ||
108 | return &const_nist_192; | ||
109 | } | 266 | } |
110 | 267 | ||
111 | const BIGNUM *BN_get0_nist_prime_224(void) | 268 | const BIGNUM *BN_get0_nist_prime_224(void) |
112 | { | 269 | { |
113 | static BIGNUM const_nist_224 = { (BN_ULONG *)_nist_p_224, | 270 | return &_bignum_nist_p_224; |
114 | BN_NIST_224_TOP, BN_NIST_224_TOP, 0, BN_FLG_STATIC_DATA }; | ||
115 | return &const_nist_224; | ||
116 | } | 271 | } |
117 | 272 | ||
118 | const BIGNUM *BN_get0_nist_prime_256(void) | 273 | const BIGNUM *BN_get0_nist_prime_256(void) |
119 | { | 274 | { |
120 | static BIGNUM const_nist_256 = { (BN_ULONG *)_nist_p_256, | 275 | return &_bignum_nist_p_256; |
121 | BN_NIST_256_TOP, BN_NIST_256_TOP, 0, BN_FLG_STATIC_DATA }; | ||
122 | return &const_nist_256; | ||
123 | } | 276 | } |
124 | 277 | ||
125 | const BIGNUM *BN_get0_nist_prime_384(void) | 278 | const BIGNUM *BN_get0_nist_prime_384(void) |
126 | { | 279 | { |
127 | static BIGNUM const_nist_384 = { (BN_ULONG *)_nist_p_384, | 280 | return &_bignum_nist_p_384; |
128 | BN_NIST_384_TOP, BN_NIST_384_TOP, 0, BN_FLG_STATIC_DATA }; | ||
129 | return &const_nist_384; | ||
130 | } | 281 | } |
131 | 282 | ||
132 | const BIGNUM *BN_get0_nist_prime_521(void) | 283 | const BIGNUM *BN_get0_nist_prime_521(void) |
133 | { | 284 | { |
134 | static BIGNUM const_nist_521 = { (BN_ULONG *)_nist_p_521, | 285 | return &_bignum_nist_p_521; |
135 | BN_NIST_521_TOP, BN_NIST_521_TOP, 0, BN_FLG_STATIC_DATA }; | ||
136 | return &const_nist_521; | ||
137 | } | 286 | } |
138 | 287 | ||
139 | #define BN_NIST_ADD_ONE(a) while (!(*(a)=(*(a)+1)&BN_MASK2)) ++(a); | ||
140 | 288 | ||
141 | static void nist_cp_bn_0(BN_ULONG *buf, BN_ULONG *a, int top, int max) | 289 | static void nist_cp_bn_0(BN_ULONG *buf, BN_ULONG *a, int top, int max) |
142 | { | 290 | { |
143 | int i; | 291 | int i; |
144 | BN_ULONG *_tmp1 = (buf), *_tmp2 = (a); | 292 | BN_ULONG *_tmp1 = (buf), *_tmp2 = (a); |
145 | for (i = (top); i != 0; i--) | 293 | |
146 | *_tmp1++ = *_tmp2++; | 294 | #ifdef BN_DEBUG |
147 | for (i = (max) - (top); i != 0; i--) | 295 | OPENSSL_assert(top <= max); |
148 | *_tmp1++ = (BN_ULONG) 0; | 296 | #endif |
149 | } | 297 | for (i = (top); i != 0; i--) |
298 | *_tmp1++ = *_tmp2++; | ||
299 | for (i = (max) - (top); i != 0; i--) | ||
300 | *_tmp1++ = (BN_ULONG) 0; | ||
301 | } | ||
150 | 302 | ||
151 | static void nist_cp_bn(BN_ULONG *buf, BN_ULONG *a, int top) | 303 | static void nist_cp_bn(BN_ULONG *buf, BN_ULONG *a, int top) |
152 | { | 304 | { |
153 | int i; | 305 | int i; |
154 | BN_ULONG *_tmp1 = (buf), *_tmp2 = (a); | 306 | BN_ULONG *_tmp1 = (buf), *_tmp2 = (a); |
155 | for (i = (top); i != 0; i--) | 307 | for (i = (top); i != 0; i--) |
156 | *_tmp1++ = *_tmp2++; | 308 | *_tmp1++ = *_tmp2++; |
157 | } | 309 | } |
158 | 310 | ||
159 | #if BN_BITS2 == 64 | 311 | #if BN_BITS2 == 64 |
160 | #define bn_cp_64(to, n, from, m) (to)[n] = (m>=0)?((from)[m]):0; | 312 | #define bn_cp_64(to, n, from, m) (to)[n] = (m>=0)?((from)[m]):0; |
161 | #define bn_64_set_0(to, n) (to)[n] = (BN_ULONG)0; | 313 | #define bn_64_set_0(to, n) (to)[n] = (BN_ULONG)0; |
162 | /* TBD */ | 314 | /* |
163 | #define bn_cp_32(to, n, from, m) (to)[n] = (m>=0)?((from)[m]):0; | 315 | * two following macros are implemented under assumption that they |
164 | #define bn_32_set_0(to, n) (to)[n] = (BN_ULONG)0; | 316 | * are called in a sequence with *ascending* n, i.e. as they are... |
317 | */ | ||
318 | #define bn_cp_32_naked(to, n, from, m) (((n)&1)?(to[(n)/2]|=((m)&1)?(from[(m)/2]&BN_MASK2h):(from[(m)/2]<<32))\ | ||
319 | :(to[(n)/2] =((m)&1)?(from[(m)/2]>>32):(from[(m)/2]&BN_MASK2l))) | ||
320 | #define bn_32_set_0(to, n) (((n)&1)?(to[(n)/2]&=BN_MASK2l):(to[(n)/2]=0)); | ||
321 | #define bn_cp_32(to,n,from,m) ((m)>=0)?bn_cp_32_naked(to,n,from,m):bn_32_set_0(to,n) | ||
165 | #else | 322 | #else |
166 | #define bn_cp_64(to, n, from, m) \ | 323 | #define bn_cp_64(to, n, from, m) \ |
167 | { \ | 324 | { \ |
@@ -182,9 +339,9 @@ static void nist_cp_bn(BN_ULONG *buf, BN_ULONG *a, int top) | |||
182 | 339 | ||
183 | #define nist_set_192(to, from, a1, a2, a3) \ | 340 | #define nist_set_192(to, from, a1, a2, a3) \ |
184 | { \ | 341 | { \ |
185 | if (a3 != 0) bn_cp_64(to, 0, from, (a3) - 3) else bn_64_set_0(to, 0)\ | 342 | bn_cp_64(to, 0, from, (a3) - 3) \ |
186 | bn_cp_64(to, 1, from, (a2) - 3) \ | 343 | bn_cp_64(to, 1, from, (a2) - 3) \ |
187 | if (a1 != 0) bn_cp_64(to, 2, from, (a1) - 3) else bn_64_set_0(to, 2)\ | 344 | bn_cp_64(to, 2, from, (a1) - 3) \ |
188 | } | 345 | } |
189 | 346 | ||
190 | int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | 347 | int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, |
@@ -198,6 +355,16 @@ int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | |||
198 | c_d[BN_NIST_192_TOP], | 355 | c_d[BN_NIST_192_TOP], |
199 | *res; | 356 | *res; |
200 | size_t mask; | 357 | size_t mask; |
358 | static const BIGNUM _bignum_nist_p_192_sqr = { | ||
359 | (BN_ULONG *)_nist_p_192_sqr, | ||
360 | sizeof(_nist_p_192_sqr)/sizeof(_nist_p_192_sqr[0]), | ||
361 | sizeof(_nist_p_192_sqr)/sizeof(_nist_p_192_sqr[0]), | ||
362 | 0,BN_FLG_STATIC_DATA }; | ||
363 | |||
364 | field = &_bignum_nist_p_192; /* just to make sure */ | ||
365 | |||
366 | if (BN_is_negative(a) || BN_ucmp(a,&_bignum_nist_p_192_sqr)>=0) | ||
367 | return BN_nnmod(r, a, field, ctx); | ||
201 | 368 | ||
202 | i = BN_ucmp(field, a); | 369 | i = BN_ucmp(field, a); |
203 | if (i == 0) | 370 | if (i == 0) |
@@ -208,9 +375,6 @@ int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | |||
208 | else if (i > 0) | 375 | else if (i > 0) |
209 | return (r == a) ? 1 : (BN_copy(r ,a) != NULL); | 376 | return (r == a) ? 1 : (BN_copy(r ,a) != NULL); |
210 | 377 | ||
211 | if (top == BN_NIST_192_TOP) | ||
212 | return BN_usub(r, a, field); | ||
213 | |||
214 | if (r != a) | 378 | if (r != a) |
215 | { | 379 | { |
216 | if (!bn_wexpand(r, BN_NIST_192_TOP)) | 380 | if (!bn_wexpand(r, BN_NIST_192_TOP)) |
@@ -224,23 +388,26 @@ int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | |||
224 | nist_cp_bn_0(buf, a_d + BN_NIST_192_TOP, top - BN_NIST_192_TOP, BN_NIST_192_TOP); | 388 | nist_cp_bn_0(buf, a_d + BN_NIST_192_TOP, top - BN_NIST_192_TOP, BN_NIST_192_TOP); |
225 | 389 | ||
226 | nist_set_192(t_d, buf, 0, 3, 3); | 390 | nist_set_192(t_d, buf, 0, 3, 3); |
227 | carry = bn_add_words(r_d, r_d, t_d, BN_NIST_192_TOP); | 391 | carry = (int)bn_add_words(r_d, r_d, t_d, BN_NIST_192_TOP); |
228 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_192,BN_NIST_192_TOP); | ||
229 | mask = ~mask | (0-(size_t)carry); | ||
230 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
231 | |||
232 | nist_set_192(t_d, buf, 4, 4, 0); | 392 | nist_set_192(t_d, buf, 4, 4, 0); |
233 | carry = bn_add_words(r_d, res, t_d, BN_NIST_192_TOP); | 393 | carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_192_TOP); |
234 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_192,BN_NIST_192_TOP); | ||
235 | mask = ~mask | (0-(size_t)carry); | ||
236 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
237 | |||
238 | nist_set_192(t_d, buf, 5, 5, 5) | 394 | nist_set_192(t_d, buf, 5, 5, 5) |
239 | carry = bn_add_words(r_d, res, t_d, BN_NIST_192_TOP); | 395 | carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_192_TOP); |
240 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_192,BN_NIST_192_TOP); | ||
241 | mask = ~mask | (0-(size_t)carry); | ||
242 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
243 | 396 | ||
397 | if (carry > 0) | ||
398 | carry = (int)bn_sub_words(r_d,r_d,_nist_p_192[carry-1],BN_NIST_192_TOP); | ||
399 | else | ||
400 | carry = 1; | ||
401 | |||
402 | /* | ||
403 | * we need 'if (carry==0 || result>=modulus) result-=modulus;' | ||
404 | * as comparison implies subtraction, we can write | ||
405 | * 'tmp=result-modulus; if (!carry || !borrow) result=tmp;' | ||
406 | * this is what happens below, but without explicit if:-) a. | ||
407 | */ | ||
408 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_192[0],BN_NIST_192_TOP); | ||
409 | mask &= 0-(size_t)carry; | ||
410 | res = (BN_ULONG *)(((size_t)c_d&~mask) | ((size_t)r_d&mask)); | ||
244 | nist_cp_bn(r_d, res, BN_NIST_192_TOP); | 411 | nist_cp_bn(r_d, res, BN_NIST_192_TOP); |
245 | r->top = BN_NIST_192_TOP; | 412 | r->top = BN_NIST_192_TOP; |
246 | bn_correct_top(r); | 413 | bn_correct_top(r); |
@@ -248,21 +415,22 @@ int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | |||
248 | return 1; | 415 | return 1; |
249 | } | 416 | } |
250 | 417 | ||
418 | typedef BN_ULONG (*bn_addsub_f)(BN_ULONG *,const BN_ULONG *,const BN_ULONG *,int); | ||
419 | |||
251 | #define nist_set_224(to, from, a1, a2, a3, a4, a5, a6, a7) \ | 420 | #define nist_set_224(to, from, a1, a2, a3, a4, a5, a6, a7) \ |
252 | { \ | 421 | { \ |
253 | if (a7 != 0) bn_cp_32(to, 0, from, (a7) - 7) else bn_32_set_0(to, 0)\ | 422 | bn_cp_32(to, 0, from, (a7) - 7) \ |
254 | if (a6 != 0) bn_cp_32(to, 1, from, (a6) - 7) else bn_32_set_0(to, 1)\ | 423 | bn_cp_32(to, 1, from, (a6) - 7) \ |
255 | if (a5 != 0) bn_cp_32(to, 2, from, (a5) - 7) else bn_32_set_0(to, 2)\ | 424 | bn_cp_32(to, 2, from, (a5) - 7) \ |
256 | if (a4 != 0) bn_cp_32(to, 3, from, (a4) - 7) else bn_32_set_0(to, 3)\ | 425 | bn_cp_32(to, 3, from, (a4) - 7) \ |
257 | if (a3 != 0) bn_cp_32(to, 4, from, (a3) - 7) else bn_32_set_0(to, 4)\ | 426 | bn_cp_32(to, 4, from, (a3) - 7) \ |
258 | if (a2 != 0) bn_cp_32(to, 5, from, (a2) - 7) else bn_32_set_0(to, 5)\ | 427 | bn_cp_32(to, 5, from, (a2) - 7) \ |
259 | if (a1 != 0) bn_cp_32(to, 6, from, (a1) - 7) else bn_32_set_0(to, 6)\ | 428 | bn_cp_32(to, 6, from, (a1) - 7) \ |
260 | } | 429 | } |
261 | 430 | ||
262 | int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | 431 | int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, |
263 | BN_CTX *ctx) | 432 | BN_CTX *ctx) |
264 | { | 433 | { |
265 | #if BN_BITS2 == 32 | ||
266 | int top = a->top, i; | 434 | int top = a->top, i; |
267 | int carry; | 435 | int carry; |
268 | BN_ULONG *r_d, *a_d = a->d; | 436 | BN_ULONG *r_d, *a_d = a->d; |
@@ -271,6 +439,18 @@ int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | |||
271 | c_d[BN_NIST_224_TOP], | 439 | c_d[BN_NIST_224_TOP], |
272 | *res; | 440 | *res; |
273 | size_t mask; | 441 | size_t mask; |
442 | union { bn_addsub_f f; size_t p; } u; | ||
443 | static const BIGNUM _bignum_nist_p_224_sqr = { | ||
444 | (BN_ULONG *)_nist_p_224_sqr, | ||
445 | sizeof(_nist_p_224_sqr)/sizeof(_nist_p_224_sqr[0]), | ||
446 | sizeof(_nist_p_224_sqr)/sizeof(_nist_p_224_sqr[0]), | ||
447 | 0,BN_FLG_STATIC_DATA }; | ||
448 | |||
449 | |||
450 | field = &_bignum_nist_p_224; /* just to make sure */ | ||
451 | |||
452 | if (BN_is_negative(a) || BN_ucmp(a,&_bignum_nist_p_224_sqr)>=0) | ||
453 | return BN_nnmod(r, a, field, ctx); | ||
274 | 454 | ||
275 | i = BN_ucmp(field, a); | 455 | i = BN_ucmp(field, a); |
276 | if (i == 0) | 456 | if (i == 0) |
@@ -281,9 +461,6 @@ int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | |||
281 | else if (i > 0) | 461 | else if (i > 0) |
282 | return (r == a)? 1 : (BN_copy(r ,a) != NULL); | 462 | return (r == a)? 1 : (BN_copy(r ,a) != NULL); |
283 | 463 | ||
284 | if (top == BN_NIST_224_TOP) | ||
285 | return BN_usub(r, a, field); | ||
286 | |||
287 | if (r != a) | 464 | if (r != a) |
288 | { | 465 | { |
289 | if (!bn_wexpand(r, BN_NIST_224_TOP)) | 466 | if (!bn_wexpand(r, BN_NIST_224_TOP)) |
@@ -294,67 +471,77 @@ int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | |||
294 | else | 471 | else |
295 | r_d = a_d; | 472 | r_d = a_d; |
296 | 473 | ||
474 | #if BN_BITS2==64 | ||
475 | /* copy upper 256 bits of 448 bit number ... */ | ||
476 | nist_cp_bn_0(t_d, a_d + (BN_NIST_224_TOP-1), top - (BN_NIST_224_TOP-1), BN_NIST_224_TOP); | ||
477 | /* ... and right shift by 32 to obtain upper 224 bits */ | ||
478 | nist_set_224(buf, t_d, 14, 13, 12, 11, 10, 9, 8); | ||
479 | /* truncate lower part to 224 bits too */ | ||
480 | r_d[BN_NIST_224_TOP-1] &= BN_MASK2l; | ||
481 | #else | ||
297 | nist_cp_bn_0(buf, a_d + BN_NIST_224_TOP, top - BN_NIST_224_TOP, BN_NIST_224_TOP); | 482 | nist_cp_bn_0(buf, a_d + BN_NIST_224_TOP, top - BN_NIST_224_TOP, BN_NIST_224_TOP); |
298 | 483 | #endif | |
299 | nist_set_224(t_d, buf, 10, 9, 8, 7, 0, 0, 0); | 484 | nist_set_224(t_d, buf, 10, 9, 8, 7, 0, 0, 0); |
300 | carry = bn_add_words(r_d, r_d, t_d, BN_NIST_224_TOP); | 485 | carry = (int)bn_add_words(r_d, r_d, t_d, BN_NIST_224_TOP); |
301 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_224,BN_NIST_224_TOP); | ||
302 | mask = ~mask | (0-(size_t)carry); | ||
303 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
304 | |||
305 | nist_set_224(t_d, buf, 0, 13, 12, 11, 0, 0, 0); | 486 | nist_set_224(t_d, buf, 0, 13, 12, 11, 0, 0, 0); |
306 | carry = bn_add_words(r_d, res, t_d, BN_NIST_224_TOP); | 487 | carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_224_TOP); |
307 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_224,BN_NIST_224_TOP); | ||
308 | mask = ~mask | (0-(size_t)carry); | ||
309 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
310 | |||
311 | nist_set_224(t_d, buf, 13, 12, 11, 10, 9, 8, 7); | 488 | nist_set_224(t_d, buf, 13, 12, 11, 10, 9, 8, 7); |
312 | #if BRANCH_FREE | 489 | carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_224_TOP); |
313 | carry = bn_sub_words(r_d, res, t_d, BN_NIST_224_TOP); | ||
314 | bn_add_words(c_d,r_d,_nist_p_224,BN_NIST_224_TOP); | ||
315 | mask = 0-(size_t)carry; | ||
316 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
317 | #else | ||
318 | if (bn_sub_words(r_d, res, t_d, BN_NIST_224_TOP)) | ||
319 | bn_add_words(r_d,r_d,_nist_p_224,BN_NIST_224_TOP); | ||
320 | #endif | ||
321 | nist_set_224(t_d, buf, 0, 0, 0, 0, 13, 12, 11); | 490 | nist_set_224(t_d, buf, 0, 0, 0, 0, 13, 12, 11); |
322 | #if BRANCH_FREE | 491 | carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_224_TOP); |
323 | carry = bn_sub_words(r_d, res, t_d, BN_NIST_224_TOP); | ||
324 | bn_add_words(c_d,r_d,_nist_p_224,BN_NIST_224_TOP); | ||
325 | mask = 0-(size_t)carry; | ||
326 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
327 | 492 | ||
328 | nist_cp_bn(r_d, res, BN_NIST_224_TOP); | 493 | #if BN_BITS2==64 |
329 | #else | 494 | carry = (int)(r_d[BN_NIST_224_TOP-1]>>32); |
330 | if (bn_sub_words(r_d, r_d, t_d, BN_NIST_224_TOP)) | 495 | #endif |
331 | bn_add_words(r_d,r_d,_nist_p_224,BN_NIST_224_TOP); | 496 | u.f = bn_sub_words; |
497 | if (carry > 0) | ||
498 | { | ||
499 | carry = (int)bn_sub_words(r_d,r_d,_nist_p_224[carry-1],BN_NIST_224_TOP); | ||
500 | #if BN_BITS2==64 | ||
501 | carry=(int)(~(r_d[BN_NIST_224_TOP-1]>>32))&1; | ||
332 | #endif | 502 | #endif |
503 | } | ||
504 | else if (carry < 0) | ||
505 | { | ||
506 | /* it's a bit more comlicated logic in this case. | ||
507 | * if bn_add_words yields no carry, then result | ||
508 | * has to be adjusted by unconditionally *adding* | ||
509 | * the modulus. but if it does, then result has | ||
510 | * to be compared to the modulus and conditionally | ||
511 | * adjusted by *subtracting* the latter. */ | ||
512 | carry = (int)bn_add_words(r_d,r_d,_nist_p_224[-carry-1],BN_NIST_224_TOP); | ||
513 | mask = 0-(size_t)carry; | ||
514 | u.p = ((size_t)bn_sub_words&mask) | ((size_t)bn_add_words&~mask); | ||
515 | } | ||
516 | else | ||
517 | carry = 1; | ||
518 | |||
519 | /* otherwise it's effectively same as in BN_nist_mod_192... */ | ||
520 | mask = 0-(size_t)(*u.f)(c_d,r_d,_nist_p_224[0],BN_NIST_224_TOP); | ||
521 | mask &= 0-(size_t)carry; | ||
522 | res = (BN_ULONG *)(((size_t)c_d&~mask) | ((size_t)r_d&mask)); | ||
523 | nist_cp_bn(r_d, res, BN_NIST_224_TOP); | ||
333 | r->top = BN_NIST_224_TOP; | 524 | r->top = BN_NIST_224_TOP; |
334 | bn_correct_top(r); | 525 | bn_correct_top(r); |
335 | 526 | ||
336 | return 1; | 527 | return 1; |
337 | #else /* BN_BITS!=32 */ | ||
338 | return 0; | ||
339 | #endif | ||
340 | } | 528 | } |
341 | 529 | ||
342 | #define nist_set_256(to, from, a1, a2, a3, a4, a5, a6, a7, a8) \ | 530 | #define nist_set_256(to, from, a1, a2, a3, a4, a5, a6, a7, a8) \ |
343 | { \ | 531 | { \ |
344 | if (a8 != 0) bn_cp_32(to, 0, from, (a8) - 8) else bn_32_set_0(to, 0)\ | 532 | bn_cp_32(to, 0, from, (a8) - 8) \ |
345 | if (a7 != 0) bn_cp_32(to, 1, from, (a7) - 8) else bn_32_set_0(to, 1)\ | 533 | bn_cp_32(to, 1, from, (a7) - 8) \ |
346 | if (a6 != 0) bn_cp_32(to, 2, from, (a6) - 8) else bn_32_set_0(to, 2)\ | 534 | bn_cp_32(to, 2, from, (a6) - 8) \ |
347 | if (a5 != 0) bn_cp_32(to, 3, from, (a5) - 8) else bn_32_set_0(to, 3)\ | 535 | bn_cp_32(to, 3, from, (a5) - 8) \ |
348 | if (a4 != 0) bn_cp_32(to, 4, from, (a4) - 8) else bn_32_set_0(to, 4)\ | 536 | bn_cp_32(to, 4, from, (a4) - 8) \ |
349 | if (a3 != 0) bn_cp_32(to, 5, from, (a3) - 8) else bn_32_set_0(to, 5)\ | 537 | bn_cp_32(to, 5, from, (a3) - 8) \ |
350 | if (a2 != 0) bn_cp_32(to, 6, from, (a2) - 8) else bn_32_set_0(to, 6)\ | 538 | bn_cp_32(to, 6, from, (a2) - 8) \ |
351 | if (a1 != 0) bn_cp_32(to, 7, from, (a1) - 8) else bn_32_set_0(to, 7)\ | 539 | bn_cp_32(to, 7, from, (a1) - 8) \ |
352 | } | 540 | } |
353 | 541 | ||
354 | int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | 542 | int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, |
355 | BN_CTX *ctx) | 543 | BN_CTX *ctx) |
356 | { | 544 | { |
357 | #if BN_BITS2 == 32 | ||
358 | int i, top = a->top; | 545 | int i, top = a->top; |
359 | int carry = 0; | 546 | int carry = 0; |
360 | register BN_ULONG *a_d = a->d, *r_d; | 547 | register BN_ULONG *a_d = a->d, *r_d; |
@@ -363,6 +550,17 @@ int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | |||
363 | c_d[BN_NIST_256_TOP], | 550 | c_d[BN_NIST_256_TOP], |
364 | *res; | 551 | *res; |
365 | size_t mask; | 552 | size_t mask; |
553 | union { bn_addsub_f f; size_t p; } u; | ||
554 | static const BIGNUM _bignum_nist_p_256_sqr = { | ||
555 | (BN_ULONG *)_nist_p_256_sqr, | ||
556 | sizeof(_nist_p_256_sqr)/sizeof(_nist_p_256_sqr[0]), | ||
557 | sizeof(_nist_p_256_sqr)/sizeof(_nist_p_256_sqr[0]), | ||
558 | 0,BN_FLG_STATIC_DATA }; | ||
559 | |||
560 | field = &_bignum_nist_p_256; /* just to make sure */ | ||
561 | |||
562 | if (BN_is_negative(a) || BN_ucmp(a,&_bignum_nist_p_256_sqr)>=0) | ||
563 | return BN_nnmod(r, a, field, ctx); | ||
366 | 564 | ||
367 | i = BN_ucmp(field, a); | 565 | i = BN_ucmp(field, a); |
368 | if (i == 0) | 566 | if (i == 0) |
@@ -373,9 +571,6 @@ int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | |||
373 | else if (i > 0) | 571 | else if (i > 0) |
374 | return (r == a)? 1 : (BN_copy(r ,a) != NULL); | 572 | return (r == a)? 1 : (BN_copy(r ,a) != NULL); |
375 | 573 | ||
376 | if (top == BN_NIST_256_TOP) | ||
377 | return BN_usub(r, a, field); | ||
378 | |||
379 | if (r != a) | 574 | if (r != a) |
380 | { | 575 | { |
381 | if (!bn_wexpand(r, BN_NIST_256_TOP)) | 576 | if (!bn_wexpand(r, BN_NIST_256_TOP)) |
@@ -391,111 +586,84 @@ int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | |||
391 | /*S1*/ | 586 | /*S1*/ |
392 | nist_set_256(t_d, buf, 15, 14, 13, 12, 11, 0, 0, 0); | 587 | nist_set_256(t_d, buf, 15, 14, 13, 12, 11, 0, 0, 0); |
393 | /*S2*/ | 588 | /*S2*/ |
394 | nist_set_256(c_d,buf, 0, 15, 14, 13, 12, 0, 0, 0); | 589 | nist_set_256(c_d, buf, 0, 15, 14, 13, 12, 0, 0, 0); |
395 | carry = bn_add_words(t_d, t_d, c_d, BN_NIST_256_TOP); | 590 | carry = (int)bn_add_words(t_d, t_d, c_d, BN_NIST_256_TOP); |
396 | mask = 0-(size_t)bn_sub_words(c_d,t_d,_nist_p_256,BN_NIST_256_TOP); | 591 | /* left shift */ |
397 | mask = ~mask | (0-(size_t)carry); | 592 | { |
398 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)t_d&~mask)); | 593 | register BN_ULONG *ap,t,c; |
399 | 594 | ap = t_d; | |
400 | carry = bn_add_words(t_d, res, res, BN_NIST_256_TOP); | 595 | c=0; |
401 | mask = 0-(size_t)bn_sub_words(c_d,t_d,_nist_p_256,BN_NIST_256_TOP); | 596 | for (i = BN_NIST_256_TOP; i != 0; --i) |
402 | mask = ~mask | (0-(size_t)carry); | 597 | { |
403 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)t_d&~mask)); | 598 | t= *ap; |
404 | 599 | *(ap++)=((t<<1)|c)&BN_MASK2; | |
405 | carry = bn_add_words(r_d, r_d, res, BN_NIST_256_TOP); | 600 | c=(t & BN_TBIT)?1:0; |
406 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_256,BN_NIST_256_TOP); | 601 | } |
407 | mask = ~mask | (0-(size_t)carry); | 602 | carry <<= 1; |
408 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | 603 | carry |= c; |
409 | 604 | } | |
605 | carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_256_TOP); | ||
410 | /*S3*/ | 606 | /*S3*/ |
411 | nist_set_256(t_d, buf, 15, 14, 0, 0, 0, 10, 9, 8); | 607 | nist_set_256(t_d, buf, 15, 14, 0, 0, 0, 10, 9, 8); |
412 | carry = bn_add_words(r_d, res, t_d, BN_NIST_256_TOP); | 608 | carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_256_TOP); |
413 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_256,BN_NIST_256_TOP); | ||
414 | mask = ~mask | (0-(size_t)carry); | ||
415 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
416 | |||
417 | /*S4*/ | 609 | /*S4*/ |
418 | nist_set_256(t_d, buf, 8, 13, 15, 14, 13, 11, 10, 9); | 610 | nist_set_256(t_d, buf, 8, 13, 15, 14, 13, 11, 10, 9); |
419 | carry = bn_add_words(r_d, res, t_d, BN_NIST_256_TOP); | 611 | carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_256_TOP); |
420 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_256,BN_NIST_256_TOP); | ||
421 | mask = ~mask | (0-(size_t)carry); | ||
422 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
423 | |||
424 | /*D1*/ | 612 | /*D1*/ |
425 | nist_set_256(t_d, buf, 10, 8, 0, 0, 0, 13, 12, 11); | 613 | nist_set_256(t_d, buf, 10, 8, 0, 0, 0, 13, 12, 11); |
426 | #if BRANCH_FREE | 614 | carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP); |
427 | carry = bn_sub_words(r_d, res, t_d, BN_NIST_256_TOP); | ||
428 | bn_add_words(c_d,r_d,_nist_p_256,BN_NIST_256_TOP); | ||
429 | mask = 0-(size_t)carry; | ||
430 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
431 | #else | ||
432 | if (bn_sub_words(r_d, res, t_d, BN_NIST_256_TOP)) | ||
433 | bn_add_words(r_d,r_d,_nist_p_256,BN_NIST_256_TOP); | ||
434 | #endif | ||
435 | /*D2*/ | 615 | /*D2*/ |
436 | nist_set_256(t_d, buf, 11, 9, 0, 0, 15, 14, 13, 12); | 616 | nist_set_256(t_d, buf, 11, 9, 0, 0, 15, 14, 13, 12); |
437 | #if BRANCH_FREE | 617 | carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP); |
438 | carry = bn_sub_words(r_d, res, t_d, BN_NIST_256_TOP); | ||
439 | bn_add_words(c_d,r_d,_nist_p_256,BN_NIST_256_TOP); | ||
440 | mask = 0-(size_t)carry; | ||
441 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
442 | #else | ||
443 | if (bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP)) | ||
444 | bn_add_words(r_d,r_d,_nist_p_256,BN_NIST_256_TOP); | ||
445 | #endif | ||
446 | /*D3*/ | 618 | /*D3*/ |
447 | nist_set_256(t_d, buf, 12, 0, 10, 9, 8, 15, 14, 13); | 619 | nist_set_256(t_d, buf, 12, 0, 10, 9, 8, 15, 14, 13); |
448 | #if BRANCH_FREE | 620 | carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP); |
449 | carry = bn_sub_words(r_d, res, t_d, BN_NIST_256_TOP); | ||
450 | bn_add_words(c_d,r_d,_nist_p_256,BN_NIST_256_TOP); | ||
451 | mask = 0-(size_t)carry; | ||
452 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
453 | #else | ||
454 | if (bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP)) | ||
455 | bn_add_words(r_d,r_d,_nist_p_256,BN_NIST_256_TOP); | ||
456 | #endif | ||
457 | /*D4*/ | 621 | /*D4*/ |
458 | nist_set_256(t_d, buf, 13, 0, 11, 10, 9, 0, 15, 14); | 622 | nist_set_256(t_d, buf, 13, 0, 11, 10, 9, 0, 15, 14); |
459 | #if BRANCH_FREE | 623 | carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP); |
460 | carry = bn_sub_words(r_d, res, t_d, BN_NIST_256_TOP); | ||
461 | bn_add_words(c_d,r_d,_nist_p_256,BN_NIST_256_TOP); | ||
462 | mask = 0-(size_t)carry; | ||
463 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
464 | 624 | ||
465 | nist_cp_bn(r_d, res, BN_NIST_384_TOP); | 625 | /* see BN_nist_mod_224 for explanation */ |
466 | #else | 626 | u.f = bn_sub_words; |
467 | if (bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP)) | 627 | if (carry > 0) |
468 | bn_add_words(r_d,r_d,_nist_p_256,BN_NIST_256_TOP); | 628 | carry = (int)bn_sub_words(r_d,r_d,_nist_p_256[carry-1],BN_NIST_256_TOP); |
469 | #endif | 629 | else if (carry < 0) |
630 | { | ||
631 | carry = (int)bn_add_words(r_d,r_d,_nist_p_256[-carry-1],BN_NIST_256_TOP); | ||
632 | mask = 0-(size_t)carry; | ||
633 | u.p = ((size_t)bn_sub_words&mask) | ((size_t)bn_add_words&~mask); | ||
634 | } | ||
635 | else | ||
636 | carry = 1; | ||
637 | |||
638 | mask = 0-(size_t)(*u.f)(c_d,r_d,_nist_p_256[0],BN_NIST_256_TOP); | ||
639 | mask &= 0-(size_t)carry; | ||
640 | res = (BN_ULONG *)(((size_t)c_d&~mask) | ((size_t)r_d&mask)); | ||
641 | nist_cp_bn(r_d, res, BN_NIST_256_TOP); | ||
470 | r->top = BN_NIST_256_TOP; | 642 | r->top = BN_NIST_256_TOP; |
471 | bn_correct_top(r); | 643 | bn_correct_top(r); |
472 | 644 | ||
473 | return 1; | 645 | return 1; |
474 | #else /* BN_BITS!=32 */ | ||
475 | return 0; | ||
476 | #endif | ||
477 | } | 646 | } |
478 | 647 | ||
479 | #define nist_set_384(to,from,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) \ | 648 | #define nist_set_384(to,from,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) \ |
480 | { \ | 649 | { \ |
481 | if (a12 != 0) bn_cp_32(to, 0, from, (a12) - 12) else bn_32_set_0(to, 0)\ | 650 | bn_cp_32(to, 0, from, (a12) - 12) \ |
482 | if (a11 != 0) bn_cp_32(to, 1, from, (a11) - 12) else bn_32_set_0(to, 1)\ | 651 | bn_cp_32(to, 1, from, (a11) - 12) \ |
483 | if (a10 != 0) bn_cp_32(to, 2, from, (a10) - 12) else bn_32_set_0(to, 2)\ | 652 | bn_cp_32(to, 2, from, (a10) - 12) \ |
484 | if (a9 != 0) bn_cp_32(to, 3, from, (a9) - 12) else bn_32_set_0(to, 3)\ | 653 | bn_cp_32(to, 3, from, (a9) - 12) \ |
485 | if (a8 != 0) bn_cp_32(to, 4, from, (a8) - 12) else bn_32_set_0(to, 4)\ | 654 | bn_cp_32(to, 4, from, (a8) - 12) \ |
486 | if (a7 != 0) bn_cp_32(to, 5, from, (a7) - 12) else bn_32_set_0(to, 5)\ | 655 | bn_cp_32(to, 5, from, (a7) - 12) \ |
487 | if (a6 != 0) bn_cp_32(to, 6, from, (a6) - 12) else bn_32_set_0(to, 6)\ | 656 | bn_cp_32(to, 6, from, (a6) - 12) \ |
488 | if (a5 != 0) bn_cp_32(to, 7, from, (a5) - 12) else bn_32_set_0(to, 7)\ | 657 | bn_cp_32(to, 7, from, (a5) - 12) \ |
489 | if (a4 != 0) bn_cp_32(to, 8, from, (a4) - 12) else bn_32_set_0(to, 8)\ | 658 | bn_cp_32(to, 8, from, (a4) - 12) \ |
490 | if (a3 != 0) bn_cp_32(to, 9, from, (a3) - 12) else bn_32_set_0(to, 9)\ | 659 | bn_cp_32(to, 9, from, (a3) - 12) \ |
491 | if (a2 != 0) bn_cp_32(to, 10, from, (a2) - 12) else bn_32_set_0(to, 10)\ | 660 | bn_cp_32(to, 10, from, (a2) - 12) \ |
492 | if (a1 != 0) bn_cp_32(to, 11, from, (a1) - 12) else bn_32_set_0(to, 11)\ | 661 | bn_cp_32(to, 11, from, (a1) - 12) \ |
493 | } | 662 | } |
494 | 663 | ||
495 | int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | 664 | int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, |
496 | BN_CTX *ctx) | 665 | BN_CTX *ctx) |
497 | { | 666 | { |
498 | #if BN_BITS2 == 32 | ||
499 | int i, top = a->top; | 667 | int i, top = a->top; |
500 | int carry = 0; | 668 | int carry = 0; |
501 | register BN_ULONG *r_d, *a_d = a->d; | 669 | register BN_ULONG *r_d, *a_d = a->d; |
@@ -504,6 +672,18 @@ int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | |||
504 | c_d[BN_NIST_384_TOP], | 672 | c_d[BN_NIST_384_TOP], |
505 | *res; | 673 | *res; |
506 | size_t mask; | 674 | size_t mask; |
675 | union { bn_addsub_f f; size_t p; } u; | ||
676 | static const BIGNUM _bignum_nist_p_384_sqr = { | ||
677 | (BN_ULONG *)_nist_p_384_sqr, | ||
678 | sizeof(_nist_p_384_sqr)/sizeof(_nist_p_384_sqr[0]), | ||
679 | sizeof(_nist_p_384_sqr)/sizeof(_nist_p_384_sqr[0]), | ||
680 | 0,BN_FLG_STATIC_DATA }; | ||
681 | |||
682 | |||
683 | field = &_bignum_nist_p_384; /* just to make sure */ | ||
684 | |||
685 | if (BN_is_negative(a) || BN_ucmp(a,&_bignum_nist_p_384_sqr)>=0) | ||
686 | return BN_nnmod(r, a, field, ctx); | ||
507 | 687 | ||
508 | i = BN_ucmp(field, a); | 688 | i = BN_ucmp(field, a); |
509 | if (i == 0) | 689 | if (i == 0) |
@@ -514,9 +694,6 @@ int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | |||
514 | else if (i > 0) | 694 | else if (i > 0) |
515 | return (r == a)? 1 : (BN_copy(r ,a) != NULL); | 695 | return (r == a)? 1 : (BN_copy(r ,a) != NULL); |
516 | 696 | ||
517 | if (top == BN_NIST_384_TOP) | ||
518 | return BN_usub(r, a, field); | ||
519 | |||
520 | if (r != a) | 697 | if (r != a) |
521 | { | 698 | { |
522 | if (!bn_wexpand(r, BN_NIST_384_TOP)) | 699 | if (!bn_wexpand(r, BN_NIST_384_TOP)) |
@@ -544,149 +721,116 @@ int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | |||
544 | } | 721 | } |
545 | *ap=c; | 722 | *ap=c; |
546 | } | 723 | } |
547 | carry = bn_add_words(r_d+(128/BN_BITS2), r_d+(128/BN_BITS2), | 724 | carry = (int)bn_add_words(r_d+(128/BN_BITS2), r_d+(128/BN_BITS2), |
548 | t_d, BN_NIST_256_TOP); | 725 | t_d, BN_NIST_256_TOP); |
549 | /* | ||
550 | * we need if (result>=modulus) subtract(result,modulus); | ||
551 | * in n-bit space this can be expressed as | ||
552 | * if (carry || result>=modulus) subtract(result,modulus); | ||
553 | * the catch is that comparison implies subtraction and | ||
554 | * therefore one can write tmp=subtract(result,modulus); | ||
555 | * and then if(carry || !borrow) result=tmp; this's what | ||
556 | * happens below, but without explicit if:-) a. | ||
557 | */ | ||
558 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_384,BN_NIST_384_TOP); | ||
559 | mask = ~mask | (0-(size_t)carry); | ||
560 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
561 | |||
562 | /*S2 */ | 726 | /*S2 */ |
563 | carry = bn_add_words(r_d, res, buf, BN_NIST_384_TOP); | 727 | carry += (int)bn_add_words(r_d, r_d, buf, BN_NIST_384_TOP); |
564 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_384,BN_NIST_384_TOP); | ||
565 | mask = ~mask | (0-(size_t)carry); | ||
566 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
567 | |||
568 | /*S3*/ | 728 | /*S3*/ |
569 | nist_set_384(t_d,buf,20,19,18,17,16,15,14,13,12,23,22,21); | 729 | nist_set_384(t_d,buf,20,19,18,17,16,15,14,13,12,23,22,21); |
570 | carry = bn_add_words(r_d, res, t_d, BN_NIST_384_TOP); | 730 | carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP); |
571 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_384,BN_NIST_384_TOP); | ||
572 | mask = ~mask | (0-(size_t)carry); | ||
573 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
574 | |||
575 | /*S4*/ | 731 | /*S4*/ |
576 | nist_set_384(t_d,buf,19,18,17,16,15,14,13,12,20,0,23,0); | 732 | nist_set_384(t_d,buf,19,18,17,16,15,14,13,12,20,0,23,0); |
577 | carry = bn_add_words(r_d, res, t_d, BN_NIST_384_TOP); | 733 | carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP); |
578 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_384,BN_NIST_384_TOP); | ||
579 | mask = ~mask | (0-(size_t)carry); | ||
580 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
581 | |||
582 | /*S5*/ | 734 | /*S5*/ |
583 | nist_set_384(t_d, buf,0,0,0,0,23,22,21,20,0,0,0,0); | 735 | nist_set_384(t_d, buf,0,0,0,0,23,22,21,20,0,0,0,0); |
584 | carry = bn_add_words(r_d, res, t_d, BN_NIST_384_TOP); | 736 | carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP); |
585 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_384,BN_NIST_384_TOP); | ||
586 | mask = ~mask | (0-(size_t)carry); | ||
587 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
588 | |||
589 | /*S6*/ | 737 | /*S6*/ |
590 | nist_set_384(t_d,buf,0,0,0,0,0,0,23,22,21,0,0,20); | 738 | nist_set_384(t_d,buf,0,0,0,0,0,0,23,22,21,0,0,20); |
591 | carry = bn_add_words(r_d, res, t_d, BN_NIST_384_TOP); | 739 | carry += (int)bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP); |
592 | mask = 0-(size_t)bn_sub_words(c_d,r_d,_nist_p_384,BN_NIST_384_TOP); | ||
593 | mask = ~mask | (0-(size_t)carry); | ||
594 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
595 | |||
596 | /*D1*/ | 740 | /*D1*/ |
597 | nist_set_384(t_d,buf,22,21,20,19,18,17,16,15,14,13,12,23); | 741 | nist_set_384(t_d,buf,22,21,20,19,18,17,16,15,14,13,12,23); |
598 | #if BRANCH_FREE | 742 | carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_384_TOP); |
599 | carry = bn_sub_words(r_d, res, t_d, BN_NIST_384_TOP); | ||
600 | bn_add_words(c_d,r_d,_nist_p_384,BN_NIST_384_TOP); | ||
601 | mask = 0-(size_t)carry; | ||
602 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
603 | #else | ||
604 | if (bn_sub_words(r_d, res, t_d, BN_NIST_384_TOP)) | ||
605 | bn_add_words(r_d,r_d,_nist_p_384,BN_NIST_384_TOP); | ||
606 | #endif | ||
607 | /*D2*/ | 743 | /*D2*/ |
608 | nist_set_384(t_d,buf,0,0,0,0,0,0,0,23,22,21,20,0); | 744 | nist_set_384(t_d,buf,0,0,0,0,0,0,0,23,22,21,20,0); |
609 | #if BRANCH_FREE | 745 | carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_384_TOP); |
610 | carry = bn_sub_words(r_d, res, t_d, BN_NIST_384_TOP); | ||
611 | bn_add_words(c_d,r_d,_nist_p_384,BN_NIST_384_TOP); | ||
612 | mask = 0-(size_t)carry; | ||
613 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | ||
614 | #else | ||
615 | if (bn_sub_words(r_d, r_d, t_d, BN_NIST_384_TOP)) | ||
616 | bn_add_words(r_d,r_d,_nist_p_384,BN_NIST_384_TOP); | ||
617 | #endif | ||
618 | /*D3*/ | 746 | /*D3*/ |
619 | nist_set_384(t_d,buf,0,0,0,0,0,0,0,23,23,0,0,0); | 747 | nist_set_384(t_d,buf,0,0,0,0,0,0,0,23,23,0,0,0); |
620 | #if BRANCH_FREE | 748 | carry -= (int)bn_sub_words(r_d, r_d, t_d, BN_NIST_384_TOP); |
621 | carry = bn_sub_words(r_d, res, t_d, BN_NIST_384_TOP); | 749 | |
622 | bn_add_words(c_d,r_d,_nist_p_384,BN_NIST_384_TOP); | 750 | /* see BN_nist_mod_224 for explanation */ |
623 | mask = 0-(size_t)carry; | 751 | u.f = bn_sub_words; |
624 | res = (BN_ULONG *)(((size_t)c_d&mask) | ((size_t)r_d&~mask)); | 752 | if (carry > 0) |
753 | carry = (int)bn_sub_words(r_d,r_d,_nist_p_384[carry-1],BN_NIST_384_TOP); | ||
754 | else if (carry < 0) | ||
755 | { | ||
756 | carry = (int)bn_add_words(r_d,r_d,_nist_p_384[-carry-1],BN_NIST_384_TOP); | ||
757 | mask = 0-(size_t)carry; | ||
758 | u.p = ((size_t)bn_sub_words&mask) | ((size_t)bn_add_words&~mask); | ||
759 | } | ||
760 | else | ||
761 | carry = 1; | ||
625 | 762 | ||
763 | mask = 0-(size_t)(*u.f)(c_d,r_d,_nist_p_384[0],BN_NIST_384_TOP); | ||
764 | mask &= 0-(size_t)carry; | ||
765 | res = (BN_ULONG *)(((size_t)c_d&~mask) | ((size_t)r_d&mask)); | ||
626 | nist_cp_bn(r_d, res, BN_NIST_384_TOP); | 766 | nist_cp_bn(r_d, res, BN_NIST_384_TOP); |
627 | #else | ||
628 | if (bn_sub_words(r_d, r_d, t_d, BN_NIST_384_TOP)) | ||
629 | bn_add_words(r_d,r_d,_nist_p_384,BN_NIST_384_TOP); | ||
630 | #endif | ||
631 | r->top = BN_NIST_384_TOP; | 767 | r->top = BN_NIST_384_TOP; |
632 | bn_correct_top(r); | 768 | bn_correct_top(r); |
633 | 769 | ||
634 | return 1; | 770 | return 1; |
635 | #else /* BN_BITS!=32 */ | ||
636 | return 0; | ||
637 | #endif | ||
638 | } | 771 | } |
639 | 772 | ||
773 | #define BN_NIST_521_RSHIFT (521%BN_BITS2) | ||
774 | #define BN_NIST_521_LSHIFT (BN_BITS2-BN_NIST_521_RSHIFT) | ||
775 | #define BN_NIST_521_TOP_MASK ((BN_ULONG)BN_MASK2>>BN_NIST_521_LSHIFT) | ||
776 | |||
640 | int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, | 777 | int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *field, |
641 | BN_CTX *ctx) | 778 | BN_CTX *ctx) |
642 | { | 779 | { |
643 | #if BN_BITS2 == 64 | 780 | int top = a->top, i; |
644 | #define BN_NIST_521_TOP_MASK (BN_ULONG)0x1FF | 781 | BN_ULONG *r_d, *a_d = a->d, |
645 | #elif BN_BITS2 == 32 | 782 | t_d[BN_NIST_521_TOP], |
646 | #define BN_NIST_521_TOP_MASK (BN_ULONG)0x1FF | 783 | val,tmp,*res; |
647 | #endif | 784 | size_t mask; |
648 | int top, ret = 0; | 785 | static const BIGNUM _bignum_nist_p_521_sqr = { |
649 | BN_ULONG *r_d; | 786 | (BN_ULONG *)_nist_p_521_sqr, |
650 | BIGNUM *tmp; | 787 | sizeof(_nist_p_521_sqr)/sizeof(_nist_p_521_sqr[0]), |
651 | 788 | sizeof(_nist_p_521_sqr)/sizeof(_nist_p_521_sqr[0]), | |
652 | /* check whether a reduction is necessary */ | 789 | 0,BN_FLG_STATIC_DATA }; |
653 | top = a->top; | ||
654 | if (top < BN_NIST_521_TOP || ( top == BN_NIST_521_TOP && | ||
655 | (!(a->d[BN_NIST_521_TOP-1] & ~(BN_NIST_521_TOP_MASK))))) | ||
656 | return (r == a)? 1 : (BN_copy(r ,a) != NULL); | ||
657 | 790 | ||
658 | BN_CTX_start(ctx); | 791 | field = &_bignum_nist_p_521; /* just to make sure */ |
659 | tmp = BN_CTX_get(ctx); | ||
660 | if (!tmp) | ||
661 | goto err; | ||
662 | 792 | ||
663 | if (!bn_wexpand(tmp, BN_NIST_521_TOP)) | 793 | if (BN_is_negative(a) || BN_ucmp(a,&_bignum_nist_p_521_sqr)>=0) |
664 | goto err; | 794 | return BN_nnmod(r, a, field, ctx); |
665 | nist_cp_bn(tmp->d, a->d, BN_NIST_521_TOP); | ||
666 | 795 | ||
667 | tmp->top = BN_NIST_521_TOP; | 796 | i = BN_ucmp(field, a); |
668 | tmp->d[BN_NIST_521_TOP-1] &= BN_NIST_521_TOP_MASK; | 797 | if (i == 0) |
669 | bn_correct_top(tmp); | 798 | { |
799 | BN_zero(r); | ||
800 | return 1; | ||
801 | } | ||
802 | else if (i > 0) | ||
803 | return (r == a)? 1 : (BN_copy(r ,a) != NULL); | ||
670 | 804 | ||
671 | if (!BN_rshift(r, a, 521)) | 805 | if (r != a) |
672 | goto err; | 806 | { |
807 | if (!bn_wexpand(r,BN_NIST_521_TOP)) | ||
808 | return 0; | ||
809 | r_d = r->d; | ||
810 | nist_cp_bn(r_d,a_d, BN_NIST_521_TOP); | ||
811 | } | ||
812 | else | ||
813 | r_d = a_d; | ||
673 | 814 | ||
674 | if (!BN_uadd(r, tmp, r)) | 815 | /* upper 521 bits, copy ... */ |
675 | goto err; | 816 | nist_cp_bn_0(t_d,a_d + (BN_NIST_521_TOP-1), top - (BN_NIST_521_TOP-1),BN_NIST_521_TOP); |
676 | top = r->top; | 817 | /* ... and right shift */ |
677 | r_d = r->d; | 818 | for (val=t_d[0],i=0; i<BN_NIST_521_TOP-1; i++) |
678 | if (top == BN_NIST_521_TOP && | ||
679 | (r_d[BN_NIST_521_TOP-1] & ~(BN_NIST_521_TOP_MASK))) | ||
680 | { | 819 | { |
681 | BN_NIST_ADD_ONE(r_d) | 820 | tmp = val>>BN_NIST_521_RSHIFT; |
682 | r->d[BN_NIST_521_TOP-1] &= BN_NIST_521_TOP_MASK; | 821 | val = t_d[i+1]; |
822 | t_d[i] = (tmp | val<<BN_NIST_521_LSHIFT) & BN_MASK2; | ||
683 | } | 823 | } |
824 | t_d[i] = val>>BN_NIST_521_RSHIFT; | ||
825 | /* lower 521 bits */ | ||
826 | r_d[i] &= BN_NIST_521_TOP_MASK; | ||
827 | |||
828 | bn_add_words(r_d,r_d,t_d,BN_NIST_521_TOP); | ||
829 | mask = 0-(size_t)bn_sub_words(t_d,r_d,_nist_p_521,BN_NIST_521_TOP); | ||
830 | res = (BN_ULONG *)(((size_t)t_d&~mask) | ((size_t)r_d&mask)); | ||
831 | nist_cp_bn(r_d,res,BN_NIST_521_TOP); | ||
832 | r->top = BN_NIST_521_TOP; | ||
684 | bn_correct_top(r); | 833 | bn_correct_top(r); |
685 | 834 | ||
686 | ret = 1; | 835 | return 1; |
687 | err: | ||
688 | BN_CTX_end(ctx); | ||
689 | |||
690 | bn_check_top(r); | ||
691 | return ret; | ||
692 | } | 836 | } |
diff --git a/src/lib/libcrypto/bn/bn_rand.c b/src/lib/libcrypto/bn/bn_rand.c index f51830b12b..b376c28ff3 100644 --- a/src/lib/libcrypto/bn/bn_rand.c +++ b/src/lib/libcrypto/bn/bn_rand.c | |||
@@ -227,7 +227,7 @@ int BN_bntest_rand(BIGNUM *rnd, int bits, int top, int bottom) | |||
227 | 227 | ||
228 | 228 | ||
229 | /* random number r: 0 <= r < range */ | 229 | /* random number r: 0 <= r < range */ |
230 | static int bn_rand_range(int pseudo, BIGNUM *r, BIGNUM *range) | 230 | static int bn_rand_range(int pseudo, BIGNUM *r, const BIGNUM *range) |
231 | { | 231 | { |
232 | int (*bn_rand)(BIGNUM *, int, int, int) = pseudo ? BN_pseudo_rand : BN_rand; | 232 | int (*bn_rand)(BIGNUM *, int, int, int) = pseudo ? BN_pseudo_rand : BN_rand; |
233 | int n; | 233 | int n; |
@@ -294,12 +294,12 @@ static int bn_rand_range(int pseudo, BIGNUM *r, BIGNUM *range) | |||
294 | } | 294 | } |
295 | 295 | ||
296 | 296 | ||
297 | int BN_rand_range(BIGNUM *r, BIGNUM *range) | 297 | int BN_rand_range(BIGNUM *r, const BIGNUM *range) |
298 | { | 298 | { |
299 | return bn_rand_range(0, r, range); | 299 | return bn_rand_range(0, r, range); |
300 | } | 300 | } |
301 | 301 | ||
302 | int BN_pseudo_rand_range(BIGNUM *r, BIGNUM *range) | 302 | int BN_pseudo_rand_range(BIGNUM *r, const BIGNUM *range) |
303 | { | 303 | { |
304 | return bn_rand_range(1, r, range); | 304 | return bn_rand_range(1, r, range); |
305 | } | 305 | } |
diff --git a/src/lib/libcrypto/bn/bn_shift.c b/src/lib/libcrypto/bn/bn_shift.c index de9312dce2..c4d301afc4 100644 --- a/src/lib/libcrypto/bn/bn_shift.c +++ b/src/lib/libcrypto/bn/bn_shift.c | |||
@@ -177,7 +177,7 @@ int BN_rshift(BIGNUM *r, const BIGNUM *a, int n) | |||
177 | nw=n/BN_BITS2; | 177 | nw=n/BN_BITS2; |
178 | rb=n%BN_BITS2; | 178 | rb=n%BN_BITS2; |
179 | lb=BN_BITS2-rb; | 179 | lb=BN_BITS2-rb; |
180 | if (nw > a->top || a->top == 0) | 180 | if (nw >= a->top || a->top == 0) |
181 | { | 181 | { |
182 | BN_zero(r); | 182 | BN_zero(r); |
183 | return(1); | 183 | return(1); |
diff --git a/src/lib/libcrypto/bn/bn_x931p.c b/src/lib/libcrypto/bn/bn_x931p.c index c64410dd3a..04c5c874ec 100644 --- a/src/lib/libcrypto/bn/bn_x931p.c +++ b/src/lib/libcrypto/bn/bn_x931p.c | |||
@@ -1,5 +1,5 @@ | |||
1 | /* bn_x931p.c */ | 1 | /* bn_x931p.c */ |
2 | /* Written by Dr Stephen N Henson (shenson@bigfoot.com) for the OpenSSL | 2 | /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL |
3 | * project 2005. | 3 | * project 2005. |
4 | */ | 4 | */ |
5 | /* ==================================================================== | 5 | /* ==================================================================== |
@@ -59,18 +59,15 @@ | |||
59 | #include <stdio.h> | 59 | #include <stdio.h> |
60 | #include <openssl/bn.h> | 60 | #include <openssl/bn.h> |
61 | 61 | ||
62 | #ifdef OPENSSL_FIPS | ||
63 | |||
64 | /* X9.31 routines for prime derivation */ | 62 | /* X9.31 routines for prime derivation */ |
65 | 63 | ||
66 | |||
67 | /* X9.31 prime derivation. This is used to generate the primes pi | 64 | /* X9.31 prime derivation. This is used to generate the primes pi |
68 | * (p1, p2, q1, q2) from a parameter Xpi by checking successive odd | 65 | * (p1, p2, q1, q2) from a parameter Xpi by checking successive odd |
69 | * integers. | 66 | * integers. |
70 | */ | 67 | */ |
71 | 68 | ||
72 | static int bn_x931_derive_pi(BIGNUM *pi, const BIGNUM *Xpi, BN_CTX *ctx, | 69 | static int bn_x931_derive_pi(BIGNUM *pi, const BIGNUM *Xpi, BN_CTX *ctx, |
73 | void (*cb)(int, int, void *), void *cb_arg) | 70 | BN_GENCB *cb) |
74 | { | 71 | { |
75 | int i = 0; | 72 | int i = 0; |
76 | if (!BN_copy(pi, Xpi)) | 73 | if (!BN_copy(pi, Xpi)) |
@@ -80,16 +77,14 @@ static int bn_x931_derive_pi(BIGNUM *pi, const BIGNUM *Xpi, BN_CTX *ctx, | |||
80 | for(;;) | 77 | for(;;) |
81 | { | 78 | { |
82 | i++; | 79 | i++; |
83 | if (cb) | 80 | BN_GENCB_call(cb, 0, i); |
84 | cb(0, i, cb_arg); | ||
85 | /* NB 27 MR is specificed in X9.31 */ | 81 | /* NB 27 MR is specificed in X9.31 */ |
86 | if (BN_is_prime_fasttest(pi, 27, cb, ctx, cb_arg, 1)) | 82 | if (BN_is_prime_fasttest_ex(pi, 27, ctx, 1, cb)) |
87 | break; | 83 | break; |
88 | if (!BN_add_word(pi, 2)) | 84 | if (!BN_add_word(pi, 2)) |
89 | return 0; | 85 | return 0; |
90 | } | 86 | } |
91 | if (cb) | 87 | BN_GENCB_call(cb, 2, i); |
92 | cb(2, i, cb_arg); | ||
93 | return 1; | 88 | return 1; |
94 | } | 89 | } |
95 | 90 | ||
@@ -98,10 +93,9 @@ static int bn_x931_derive_pi(BIGNUM *pi, const BIGNUM *Xpi, BN_CTX *ctx, | |||
98 | * not NULL they will be returned too: this is needed for testing. | 93 | * not NULL they will be returned too: this is needed for testing. |
99 | */ | 94 | */ |
100 | 95 | ||
101 | int BN_X931_derive_prime(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, | 96 | int BN_X931_derive_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, |
102 | void (*cb)(int, int, void *), void *cb_arg, | ||
103 | const BIGNUM *Xp, const BIGNUM *Xp1, const BIGNUM *Xp2, | 97 | const BIGNUM *Xp, const BIGNUM *Xp1, const BIGNUM *Xp2, |
104 | const BIGNUM *e, BN_CTX *ctx) | 98 | const BIGNUM *e, BN_CTX *ctx, BN_GENCB *cb) |
105 | { | 99 | { |
106 | int ret = 0; | 100 | int ret = 0; |
107 | 101 | ||
@@ -124,10 +118,10 @@ int BN_X931_derive_prime(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, | |||
124 | 118 | ||
125 | pm1 = BN_CTX_get(ctx); | 119 | pm1 = BN_CTX_get(ctx); |
126 | 120 | ||
127 | if (!bn_x931_derive_pi(p1, Xp1, ctx, cb, cb_arg)) | 121 | if (!bn_x931_derive_pi(p1, Xp1, ctx, cb)) |
128 | goto err; | 122 | goto err; |
129 | 123 | ||
130 | if (!bn_x931_derive_pi(p2, Xp2, ctx, cb, cb_arg)) | 124 | if (!bn_x931_derive_pi(p2, Xp2, ctx, cb)) |
131 | goto err; | 125 | goto err; |
132 | 126 | ||
133 | if (!BN_mul(p1p2, p1, p2, ctx)) | 127 | if (!BN_mul(p1p2, p1, p2, ctx)) |
@@ -166,8 +160,7 @@ int BN_X931_derive_prime(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, | |||
166 | for (;;) | 160 | for (;;) |
167 | { | 161 | { |
168 | int i = 1; | 162 | int i = 1; |
169 | if (cb) | 163 | BN_GENCB_call(cb, 0, i++); |
170 | cb(0, i++, cb_arg); | ||
171 | if (!BN_copy(pm1, p)) | 164 | if (!BN_copy(pm1, p)) |
172 | goto err; | 165 | goto err; |
173 | if (!BN_sub_word(pm1, 1)) | 166 | if (!BN_sub_word(pm1, 1)) |
@@ -179,14 +172,13 @@ int BN_X931_derive_prime(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, | |||
179 | * offering similar or better guarantees 50 MR is considerably | 172 | * offering similar or better guarantees 50 MR is considerably |
180 | * better. | 173 | * better. |
181 | */ | 174 | */ |
182 | && BN_is_prime_fasttest(p, 50, cb, ctx, cb_arg, 1)) | 175 | && BN_is_prime_fasttest_ex(p, 50, ctx, 1, cb)) |
183 | break; | 176 | break; |
184 | if (!BN_add(p, p, p1p2)) | 177 | if (!BN_add(p, p, p1p2)) |
185 | goto err; | 178 | goto err; |
186 | } | 179 | } |
187 | 180 | ||
188 | if (cb) | 181 | BN_GENCB_call(cb, 3, 0); |
189 | cb(3, 0, cb_arg); | ||
190 | 182 | ||
191 | ret = 1; | 183 | ret = 1; |
192 | 184 | ||
@@ -248,11 +240,11 @@ int BN_X931_generate_Xpq(BIGNUM *Xp, BIGNUM *Xq, int nbits, BN_CTX *ctx) | |||
248 | * are generated using the previous function and supplied as input. | 240 | * are generated using the previous function and supplied as input. |
249 | */ | 241 | */ |
250 | 242 | ||
251 | int BN_X931_generate_prime(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, | 243 | int BN_X931_generate_prime_ex(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, |
252 | BIGNUM *Xp1, BIGNUM *Xp2, | 244 | BIGNUM *Xp1, BIGNUM *Xp2, |
253 | const BIGNUM *Xp, | 245 | const BIGNUM *Xp, |
254 | const BIGNUM *e, BN_CTX *ctx, | 246 | const BIGNUM *e, BN_CTX *ctx, |
255 | void (*cb)(int, int, void *), void *cb_arg) | 247 | BN_GENCB *cb) |
256 | { | 248 | { |
257 | int ret = 0; | 249 | int ret = 0; |
258 | 250 | ||
@@ -266,8 +258,7 @@ int BN_X931_generate_prime(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, | |||
266 | goto error; | 258 | goto error; |
267 | if (!BN_rand(Xp2, 101, 0, 0)) | 259 | if (!BN_rand(Xp2, 101, 0, 0)) |
268 | goto error; | 260 | goto error; |
269 | if (!BN_X931_derive_prime(p, p1, p2, cb, cb_arg, | 261 | if (!BN_X931_derive_prime_ex(p, p1, p2, Xp, Xp1, Xp2, e, ctx, cb)) |
270 | Xp, Xp1, Xp2, e, ctx)) | ||
271 | goto error; | 262 | goto error; |
272 | 263 | ||
273 | ret = 1; | 264 | ret = 1; |
@@ -279,4 +270,3 @@ int BN_X931_generate_prime(BIGNUM *p, BIGNUM *p1, BIGNUM *p2, | |||
279 | 270 | ||
280 | } | 271 | } |
281 | 272 | ||
282 | #endif | ||