8 #include <botan/curve_nistp.h>
9 #include <botan/internal/mp_core.h>
10 #include <botan/internal/mp_asmi.h>
16 void normalize(
const BigInt& p, BigInt& x, secure_vector<word>& ws,
size_t bound)
18 const word* prime = p.data();
19 const size_t p_words = p.sig_words();
21 while(x.is_negative())
25 x.grow_to(p_words + 1);
27 if(ws.size() < p_words + 1)
28 ws.resize(p_words + 1);
30 for(
size_t i = 0; bound == 0 || i < bound; ++i)
32 const word* xd = x.data();
35 for(
size_t j = 0; j != p_words; ++j)
37 ws[j] =
word_sub(xd[j], prime[j], &borrow);
40 ws[p_words] =
word_sub(xd[p_words], 0, &borrow);
53 static const BigInt p521(
"0x1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
54 "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
63 const size_t p_words = p_full_words + 1;
70 if(ws.size() < p_words + 1)
71 ws.resize(p_words + 1);
84 #if defined(BOTAN_HAS_NIST_PRIME_REDUCERS_W32)
92 inline uint32_t get_uint32_t(
const BigInt& x,
size_t i)
94 #if (BOTAN_MP_WORD_BITS == 32)
96 #elif (BOTAN_MP_WORD_BITS == 64)
97 return static_cast<uint32_t
>(x.word_at(i/2) >> ((i % 2)*32));
99 #error "Not implemented"
108 inline void set_uint32_t(BigInt& x,
size_t i, T v_in)
110 const uint32_t v =
static_cast<uint32_t
>(v_in);
111 #if (BOTAN_MP_WORD_BITS == 32)
113 #elif (BOTAN_MP_WORD_BITS == 64)
114 const word shift_32 = (i % 2) * 32;
115 const word w = (x.word_at(i/2) & (
static_cast<word
>(0xFFFFFFFF) << (32-shift_32))) | (
static_cast<word
>(v) << shift_32);
116 x.set_word_at(i/2, w);
118 #error "Not implemented"
124 const BigInt& prime_p192()
126 static const BigInt p192(
"0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF");
130 void redc_p192(BigInt& x, secure_vector<word>& ws)
132 const uint32_t X6 = get_uint32_t(x, 6);
133 const uint32_t X7 = get_uint32_t(x, 7);
134 const uint32_t X8 = get_uint32_t(x, 8);
135 const uint32_t X9 = get_uint32_t(x, 9);
136 const uint32_t X10 = get_uint32_t(x, 10);
137 const uint32_t X11 = get_uint32_t(x, 11);
143 S += get_uint32_t(x, 0);
146 set_uint32_t(x, 0, S);
149 S += get_uint32_t(x, 1);
152 set_uint32_t(x, 1, S);
155 S += get_uint32_t(x, 2);
159 set_uint32_t(x, 2, S);
162 S += get_uint32_t(x, 3);
166 set_uint32_t(x, 3, S);
169 S += get_uint32_t(x, 4);
172 set_uint32_t(x, 4, S);
175 S += get_uint32_t(x, 5);
178 set_uint32_t(x, 5, S);
181 set_uint32_t(x, 6, S);
185 normalize(prime_p192(), x, ws, 3);
188 const BigInt& prime_p224()
190 static const BigInt p224(
"0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001");
194 void redc_p224(BigInt& x, secure_vector<word>& ws)
196 const uint32_t X7 = get_uint32_t(x, 7);
197 const uint32_t X8 = get_uint32_t(x, 8);
198 const uint32_t X9 = get_uint32_t(x, 9);
199 const uint32_t X10 = get_uint32_t(x, 10);
200 const uint32_t X11 = get_uint32_t(x, 11);
201 const uint32_t X12 = get_uint32_t(x, 12);
202 const uint32_t X13 = get_uint32_t(x, 13);
210 S += get_uint32_t(x, 0);
214 set_uint32_t(x, 0, S);
217 S += get_uint32_t(x, 1);
220 set_uint32_t(x, 1, S);
223 S += get_uint32_t(x, 2);
226 set_uint32_t(x, 2, S);
229 S += get_uint32_t(x, 3);
234 set_uint32_t(x, 3, S);
237 S += get_uint32_t(x, 4);
242 set_uint32_t(x, 4, S);
245 S += get_uint32_t(x, 5);
250 set_uint32_t(x, 5, S);
253 S += get_uint32_t(x, 6);
257 set_uint32_t(x, 6, S);
259 set_uint32_t(x, 7, S);
263 normalize(prime_p224(), x, ws, 3);
266 const BigInt& prime_p256()
268 static const BigInt p256(
"0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF");
272 void redc_p256(BigInt& x, secure_vector<word>& ws)
274 const uint32_t X8 = get_uint32_t(x, 8);
275 const uint32_t X9 = get_uint32_t(x, 9);
276 const uint32_t X10 = get_uint32_t(x, 10);
277 const uint32_t X11 = get_uint32_t(x, 11);
278 const uint32_t X12 = get_uint32_t(x, 12);
279 const uint32_t X13 = get_uint32_t(x, 13);
280 const uint32_t X14 = get_uint32_t(x, 14);
281 const uint32_t X15 = get_uint32_t(x, 15);
289 S = get_uint32_t(x, 0);
297 set_uint32_t(x, 0, S);
300 S += get_uint32_t(x, 1);
308 set_uint32_t(x, 1, S);
311 S += get_uint32_t(x, 2);
318 set_uint32_t(x, 2, S);
321 S += get_uint32_t(x, 3);
331 set_uint32_t(x, 3, S);
334 S += get_uint32_t(x, 4);
342 set_uint32_t(x, 4, S);
345 S += get_uint32_t(x, 5);
353 set_uint32_t(x, 5, S);
356 S += get_uint32_t(x, 6);
366 set_uint32_t(x, 6, S);
369 S += get_uint32_t(x, 7);
379 set_uint32_t(x, 7, S);
383 set_uint32_t(x, 8, S);
391 static const BigInt P256_mults[9] = {
392 2*CurveGFp_P256::prime(),
393 3*CurveGFp_P256::prime(),
394 4*CurveGFp_P256::prime(),
395 5*CurveGFp_P256::prime(),
396 6*CurveGFp_P256::prime(),
397 7*CurveGFp_P256::prime(),
398 8*CurveGFp_P256::prime(),
399 9*CurveGFp_P256::prime(),
400 10*CurveGFp_P256::prime()
402 x -= P256_mults[S - 2];
406 normalize(prime_p256(), x, ws, 10);
409 const BigInt& prime_p384()
411 static const BigInt p384(
"0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF");
415 void redc_p384(BigInt& x, secure_vector<word>& ws)
417 const uint32_t X12 = get_uint32_t(x, 12);
418 const uint32_t X13 = get_uint32_t(x, 13);
419 const uint32_t X14 = get_uint32_t(x, 14);
420 const uint32_t X15 = get_uint32_t(x, 15);
421 const uint32_t X16 = get_uint32_t(x, 16);
422 const uint32_t X17 = get_uint32_t(x, 17);
423 const uint32_t X18 = get_uint32_t(x, 18);
424 const uint32_t X19 = get_uint32_t(x, 19);
425 const uint32_t X20 = get_uint32_t(x, 20);
426 const uint32_t X21 = get_uint32_t(x, 21);
427 const uint32_t X22 = get_uint32_t(x, 22);
428 const uint32_t X23 = get_uint32_t(x, 23);
435 S = get_uint32_t(x, 0);
441 set_uint32_t(x, 0, S);
444 S += get_uint32_t(x, 1);
450 set_uint32_t(x, 1, S);
453 S += get_uint32_t(x, 2);
458 set_uint32_t(x, 2, S);
461 S += get_uint32_t(x, 3);
470 set_uint32_t(x, 3, S);
473 S += get_uint32_t(x, 4);
485 set_uint32_t(x, 4, S);
488 S += get_uint32_t(x, 5);
498 set_uint32_t(x, 5, S);
501 S += get_uint32_t(x, 6);
510 set_uint32_t(x, 6, S);
513 S += get_uint32_t(x, 7);
520 set_uint32_t(x, 7, S);
523 S += get_uint32_t(x, 8);
529 set_uint32_t(x, 8, S);
532 S += get_uint32_t(x, 9);
538 set_uint32_t(x, 9, S);
541 S += get_uint32_t(x, 10);
547 set_uint32_t(x, 10, S);
550 S += get_uint32_t(x, 11);
556 set_uint32_t(x, 11, S);
559 set_uint32_t(x, 12, S);
566 static const BigInt P384_mults[3] = {
567 2*CurveGFp_P384::prime(),
568 3*CurveGFp_P384::prime(),
569 4*CurveGFp_P384::prime()
572 x -= P384_mults[S - 2];
576 normalize(prime_p384(), x, ws, 4);
void bigint_shr2(word y[], const word x[], size_t x_size, size_t word_shift, size_t bit_shift)
void clear_mem(T *ptr, size_t n)
word bigint_add3_nc(word z[], const word x[], size_t x_size, const word y[], size_t y_size)
#define BOTAN_ASSERT(expr, assertion_made)
std::vector< T, secure_allocator< T >> secure_vector
#define BOTAN_ASSERT_EQUAL(expr1, expr2, assertion_made)
void redc_p521(BigInt &x, secure_vector< word > &ws)
const word * data() const
const BigInt & prime_p521()
word word_sub(word x, word y, word *carry)
const size_t MP_WORD_BITS