TeaSpeak/tommath
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

format with astyle (step 5)

Browse Source
This commit is contained in:
Francois Perrad 2017-08-30 19:15:27 +02:00
parent a20d9b102c
commit f89cda034b
18 changed files with 838 additions and 838 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
bn_mp_to_signed_bin.c
View File

@ -18,13 +18,13 @@
/* store in signed [big endian] format */ /* store in signed [big endian] format */
int mp_to_signed_bin(mp_int *a, unsigned char *b) int mp_to_signed_bin(mp_int *a, unsigned char *b)
{ {
int res; int res;
if ((res = mp_to_unsigned_bin(a, b + 1)) != MP_OKAY) { if ((res = mp_to_unsigned_bin(a, b + 1)) != MP_OKAY) {
return res; return res;
} }
b[0] = (a->sign == MP_ZPOS) ? (unsigned char)0 : (unsigned char)1; b[0] = (a->sign == MP_ZPOS) ? (unsigned char)0 : (unsigned char)1;
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

30
bn_mp_to_unsigned_bin.c
View File

@ -18,28 +18,28 @@
/* store in unsigned [big endian] format */ /* store in unsigned [big endian] format */
int mp_to_unsigned_bin(mp_int *a, unsigned char *b) int mp_to_unsigned_bin(mp_int *a, unsigned char *b)
{ {
int x, res; int x, res;
mp_int t; mp_int t;
if ((res = mp_init_copy(&t, a)) != MP_OKAY) { if ((res = mp_init_copy(&t, a)) != MP_OKAY) {
return res; return res;
} }
x = 0; x = 0;
while (mp_iszero(&t) == MP_NO) { while (mp_iszero(&t) == MP_NO) {
#ifndef MP_8BIT #ifndef MP_8BIT
b[x++] = (unsigned char)(t.dp[0] & 255); b[x++] = (unsigned char)(t.dp[0] & 255);
#else #else
b[x++] = (unsigned char)(t.dp[0] | ((t.dp[1] & 0x01) << 7)); b[x++] = (unsigned char)(t.dp[0] | ((t.dp[1] & 0x01) << 7));
#endif #endif
if ((res = mp_div_2d(&t, 8, &t, NULL)) != MP_OKAY) { if ((res = mp_div_2d(&t, 8, &t, NULL)) != MP_OKAY) {
mp_clear(&t); mp_clear(&t);
return res; return res;
} }
} }
bn_reverse(b, x); bn_reverse(b, x);
mp_clear(&t); mp_clear(&t);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

454
bn_mp_toom_mul.c
View File

@ -24,259 +24,259 @@
*/ */
int mp_toom_mul(mp_int *a, mp_int *b, mp_int *c) int mp_toom_mul(mp_int *a, mp_int *b, mp_int *c)
{ {
mp_int w0, w1, w2, w3, w4, tmp1, tmp2, a0, a1, a2, b0, b1, b2; mp_int w0, w1, w2, w3, w4, tmp1, tmp2, a0, a1, a2, b0, b1, b2;
int res, B; int res, B;
/* init temps */ /* init temps */
if ((res = mp_init_multi(&w0, &w1, &w2, &w3, &w4, if ((res = mp_init_multi(&w0, &w1, &w2, &w3, &w4,
&a0, &a1, &a2, &b0, &b1, &a0, &a1, &a2, &b0, &b1,
&b2, &tmp1, &tmp2, NULL)) != MP_OKAY) { &b2, &tmp1, &tmp2, NULL)) != MP_OKAY) {
return res; return res;
} }
/* B */ /* B */
B = MIN(a->used, b->used) / 3; B = MIN(a->used, b->used) / 3;
/* a = a2 * B**2 + a1 * B + a0 */ /* a = a2 * B**2 + a1 * B + a0 */
if ((res = mp_mod_2d(a, DIGIT_BIT * B, &a0)) != MP_OKAY) { if ((res = mp_mod_2d(a, DIGIT_BIT * B, &a0)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_copy(a, &a1)) != MP_OKAY) { if ((res = mp_copy(a, &a1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
mp_rshd(&a1, B); mp_rshd(&a1, B);
if ((res = mp_mod_2d(&a1, DIGIT_BIT * B, &a1)) != MP_OKAY) { if ((res = mp_mod_2d(&a1, DIGIT_BIT * B, &a1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_copy(a, &a2)) != MP_OKAY) { if ((res = mp_copy(a, &a2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
mp_rshd(&a2, B*2); mp_rshd(&a2, B*2);
/* b = b2 * B**2 + b1 * B + b0 */ /* b = b2 * B**2 + b1 * B + b0 */
if ((res = mp_mod_2d(b, DIGIT_BIT * B, &b0)) != MP_OKAY) { if ((res = mp_mod_2d(b, DIGIT_BIT * B, &b0)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_copy(b, &b1)) != MP_OKAY) { if ((res = mp_copy(b, &b1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
mp_rshd(&b1, B); mp_rshd(&b1, B);
(void)mp_mod_2d(&b1, DIGIT_BIT * B, &b1); (void)mp_mod_2d(&b1, DIGIT_BIT * B, &b1);
if ((res = mp_copy(b, &b2)) != MP_OKAY) { if ((res = mp_copy(b, &b2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
mp_rshd(&b2, B*2); mp_rshd(&b2, B*2);
/* w0 = a0*b0 */ /* w0 = a0*b0 */
if ((res = mp_mul(&a0, &b0, &w0)) != MP_OKAY) { if ((res = mp_mul(&a0, &b0, &w0)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* w4 = a2 * b2 */ /* w4 = a2 * b2 */
if ((res = mp_mul(&a2, &b2, &w4)) != MP_OKAY) { if ((res = mp_mul(&a2, &b2, &w4)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* w1 = (a2 + 2(a1 + 2a0))(b2 + 2(b1 + 2b0)) */ /* w1 = (a2 + 2(a1 + 2a0))(b2 + 2(b1 + 2b0)) */
if ((res = mp_mul_2(&a0, &tmp1)) != MP_OKAY) { if ((res = mp_mul_2(&a0, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) { if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) { if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp1, &a2, &tmp1)) != MP_OKAY) { if ((res = mp_add(&tmp1, &a2, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_mul_2(&b0, &tmp2)) != MP_OKAY) { if ((res = mp_mul_2(&b0, &tmp2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp2, &b1, &tmp2)) != MP_OKAY) { if ((res = mp_add(&tmp2, &b1, &tmp2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_mul_2(&tmp2, &tmp2)) != MP_OKAY) { if ((res = mp_mul_2(&tmp2, &tmp2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp2, &b2, &tmp2)) != MP_OKAY) { if ((res = mp_add(&tmp2, &b2, &tmp2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_mul(&tmp1, &tmp2, &w1)) != MP_OKAY) { if ((res = mp_mul(&tmp1, &tmp2, &w1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* w3 = (a0 + 2(a1 + 2a2))(b0 + 2(b1 + 2b2)) */ /* w3 = (a0 + 2(a1 + 2a2))(b0 + 2(b1 + 2b2)) */
if ((res = mp_mul_2(&a2, &tmp1)) != MP_OKAY) { if ((res = mp_mul_2(&a2, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) { if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) { if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) { if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_mul_2(&b2, &tmp2)) != MP_OKAY) { if ((res = mp_mul_2(&b2, &tmp2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp2, &b1, &tmp2)) != MP_OKAY) { if ((res = mp_add(&tmp2, &b1, &tmp2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_mul_2(&tmp2, &tmp2)) != MP_OKAY) { if ((res = mp_mul_2(&tmp2, &tmp2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp2, &b0, &tmp2)) != MP_OKAY) { if ((res = mp_add(&tmp2, &b0, &tmp2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_mul(&tmp1, &tmp2, &w3)) != MP_OKAY) { if ((res = mp_mul(&tmp1, &tmp2, &w3)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* w2 = (a2 + a1 + a0)(b2 + b1 + b0) */ /* w2 = (a2 + a1 + a0)(b2 + b1 + b0) */
if ((res = mp_add(&a2, &a1, &tmp1)) != MP_OKAY) { if ((res = mp_add(&a2, &a1, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) { if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&b2, &b1, &tmp2)) != MP_OKAY) { if ((res = mp_add(&b2, &b1, &tmp2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp2, &b0, &tmp2)) != MP_OKAY) { if ((res = mp_add(&tmp2, &b0, &tmp2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_mul(&tmp1, &tmp2, &w2)) != MP_OKAY) { if ((res = mp_mul(&tmp1, &tmp2, &w2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* now solve the matrix /* now solve the matrix
0 0 0 0 1 0 0 0 0 1
1 2 4 8 16 1 2 4 8 16
1 1 1 1 1 1 1 1 1 1
16 8 4 2 1 16 8 4 2 1
1 0 0 0 0 1 0 0 0 0
using 12 subtractions, 4 shifts, using 12 subtractions, 4 shifts,
2 small divisions and 1 small multiplication 2 small divisions and 1 small multiplication
*/ */
/* r1 - r4 */ /* r1 - r4 */
if ((res = mp_sub(&w1, &w4, &w1)) != MP_OKAY) { if ((res = mp_sub(&w1, &w4, &w1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r3 - r0 */ /* r3 - r0 */
if ((res = mp_sub(&w3, &w0, &w3)) != MP_OKAY) { if ((res = mp_sub(&w3, &w0, &w3)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r1/2 */ /* r1/2 */
if ((res = mp_div_2(&w1, &w1)) != MP_OKAY) { if ((res = mp_div_2(&w1, &w1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r3/2 */ /* r3/2 */
if ((res = mp_div_2(&w3, &w3)) != MP_OKAY) { if ((res = mp_div_2(&w3, &w3)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r2 - r0 - r4 */ /* r2 - r0 - r4 */
if ((res = mp_sub(&w2, &w0, &w2)) != MP_OKAY) { if ((res = mp_sub(&w2, &w0, &w2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_sub(&w2, &w4, &w2)) != MP_OKAY) { if ((res = mp_sub(&w2, &w4, &w2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r1 - r2 */ /* r1 - r2 */
if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) { if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r3 - r2 */ /* r3 - r2 */
if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) { if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r1 - 8r0 */ /* r1 - 8r0 */
if ((res = mp_mul_2d(&w0, 3, &tmp1)) != MP_OKAY) { if ((res = mp_mul_2d(&w0, 3, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_sub(&w1, &tmp1, &w1)) != MP_OKAY) { if ((res = mp_sub(&w1, &tmp1, &w1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r3 - 8r4 */ /* r3 - 8r4 */
if ((res = mp_mul_2d(&w4, 3, &tmp1)) != MP_OKAY) { if ((res = mp_mul_2d(&w4, 3, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_sub(&w3, &tmp1, &w3)) != MP_OKAY) { if ((res = mp_sub(&w3, &tmp1, &w3)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* 3r2 - r1 - r3 */ /* 3r2 - r1 - r3 */
if ((res = mp_mul_d(&w2, 3, &w2)) != MP_OKAY) { if ((res = mp_mul_d(&w2, 3, &w2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_sub(&w2, &w1, &w2)) != MP_OKAY) { if ((res = mp_sub(&w2, &w1, &w2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_sub(&w2, &w3, &w2)) != MP_OKAY) { if ((res = mp_sub(&w2, &w3, &w2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r1 - r2 */ /* r1 - r2 */
if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) { if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r3 - r2 */ /* r3 - r2 */
if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) { if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r1/3 */ /* r1/3 */
if ((res = mp_div_3(&w1, &w1, NULL)) != MP_OKAY) { if ((res = mp_div_3(&w1, &w1, NULL)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r3/3 */ /* r3/3 */
if ((res = mp_div_3(&w3, &w3, NULL)) != MP_OKAY) { if ((res = mp_div_3(&w3, &w3, NULL)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* at this point shift W[n] by B*n */ /* at this point shift W[n] by B*n */
if ((res = mp_lshd(&w1, 1*B)) != MP_OKAY) { if ((res = mp_lshd(&w1, 1*B)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_lshd(&w2, 2*B)) != MP_OKAY) { if ((res = mp_lshd(&w2, 2*B)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_lshd(&w3, 3*B)) != MP_OKAY) { if ((res = mp_lshd(&w3, 3*B)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_lshd(&w4, 4*B)) != MP_OKAY) { if ((res = mp_lshd(&w4, 4*B)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&w0, &w1, c)) != MP_OKAY) { if ((res = mp_add(&w0, &w1, c)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&w2, &w3, &tmp1)) != MP_OKAY) { if ((res = mp_add(&w2, &w3, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&w4, &tmp1, &tmp1)) != MP_OKAY) { if ((res = mp_add(&w4, &tmp1, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp1, c, c)) != MP_OKAY) { if ((res = mp_add(&tmp1, c, c)) != MP_OKAY) {
goto ERR; goto ERR;
} }
ERR: ERR:
mp_clear_multi(&w0, &w1, &w2, &w3, &w4, mp_clear_multi(&w0, &w1, &w2, &w3, &w4,
&a0, &a1, &a2, &b0, &b1, &a0, &a1, &a2, &b0, &b1,
&b2, &tmp1, &tmp2, NULL); &b2, &tmp1, &tmp2, NULL);
return res; return res;
} }
#endif #endif

358
bn_mp_toom_sqr.c
View File

@ -18,206 +18,206 @@
/* squaring using Toom-Cook 3-way algorithm */ /* squaring using Toom-Cook 3-way algorithm */
int mp_toom_sqr(mp_int *a, mp_int *b) int mp_toom_sqr(mp_int *a, mp_int *b)
{ {
mp_int w0, w1, w2, w3, w4, tmp1, a0, a1, a2; mp_int w0, w1, w2, w3, w4, tmp1, a0, a1, a2;
int res, B; int res, B;
/* init temps */ /* init temps */
if ((res = mp_init_multi(&w0, &w1, &w2, &w3, &w4, &a0, &a1, &a2, &tmp1, NULL)) != MP_OKAY) { if ((res = mp_init_multi(&w0, &w1, &w2, &w3, &w4, &a0, &a1, &a2, &tmp1, NULL)) != MP_OKAY) {
return res; return res;
} }
/* B */ /* B */
B = a->used / 3; B = a->used / 3;
/* a = a2 * B**2 + a1 * B + a0 */ /* a = a2 * B**2 + a1 * B + a0 */
if ((res = mp_mod_2d(a, DIGIT_BIT * B, &a0)) != MP_OKAY) { if ((res = mp_mod_2d(a, DIGIT_BIT * B, &a0)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_copy(a, &a1)) != MP_OKAY) { if ((res = mp_copy(a, &a1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
mp_rshd(&a1, B); mp_rshd(&a1, B);
if ((res = mp_mod_2d(&a1, DIGIT_BIT * B, &a1)) != MP_OKAY) { if ((res = mp_mod_2d(&a1, DIGIT_BIT * B, &a1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_copy(a, &a2)) != MP_OKAY) { if ((res = mp_copy(a, &a2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
mp_rshd(&a2, B*2); mp_rshd(&a2, B*2);
/* w0 = a0*a0 */ /* w0 = a0*a0 */
if ((res = mp_sqr(&a0, &w0)) != MP_OKAY) { if ((res = mp_sqr(&a0, &w0)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* w4 = a2 * a2 */ /* w4 = a2 * a2 */
if ((res = mp_sqr(&a2, &w4)) != MP_OKAY) { if ((res = mp_sqr(&a2, &w4)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* w1 = (a2 + 2(a1 + 2a0))**2 */ /* w1 = (a2 + 2(a1 + 2a0))**2 */
if ((res = mp_mul_2(&a0, &tmp1)) != MP_OKAY) { if ((res = mp_mul_2(&a0, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) { if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) { if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp1, &a2, &tmp1)) != MP_OKAY) { if ((res = mp_add(&tmp1, &a2, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_sqr(&tmp1, &w1)) != MP_OKAY) { if ((res = mp_sqr(&tmp1, &w1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* w3 = (a0 + 2(a1 + 2a2))**2 */ /* w3 = (a0 + 2(a1 + 2a2))**2 */
if ((res = mp_mul_2(&a2, &tmp1)) != MP_OKAY) { if ((res = mp_mul_2(&a2, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) { if ((res = mp_add(&tmp1, &a1, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) { if ((res = mp_mul_2(&tmp1, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) { if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_sqr(&tmp1, &w3)) != MP_OKAY) { if ((res = mp_sqr(&tmp1, &w3)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* w2 = (a2 + a1 + a0)**2 */ /* w2 = (a2 + a1 + a0)**2 */
if ((res = mp_add(&a2, &a1, &tmp1)) != MP_OKAY) { if ((res = mp_add(&a2, &a1, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) { if ((res = mp_add(&tmp1, &a0, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_sqr(&tmp1, &w2)) != MP_OKAY) { if ((res = mp_sqr(&tmp1, &w2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* now solve the matrix /* now solve the matrix
0 0 0 0 1 0 0 0 0 1
1 2 4 8 16 1 2 4 8 16
1 1 1 1 1 1 1 1 1 1
16 8 4 2 1 16 8 4 2 1
1 0 0 0 0 1 0 0 0 0
using 12 subtractions, 4 shifts, 2 small divisions and 1 small multiplication. using 12 subtractions, 4 shifts, 2 small divisions and 1 small multiplication.
*/ */
/* r1 - r4 */ /* r1 - r4 */
if ((res = mp_sub(&w1, &w4, &w1)) != MP_OKAY) { if ((res = mp_sub(&w1, &w4, &w1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r3 - r0 */ /* r3 - r0 */
if ((res = mp_sub(&w3, &w0, &w3)) != MP_OKAY) { if ((res = mp_sub(&w3, &w0, &w3)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r1/2 */ /* r1/2 */
if ((res = mp_div_2(&w1, &w1)) != MP_OKAY) { if ((res = mp_div_2(&w1, &w1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r3/2 */ /* r3/2 */
if ((res = mp_div_2(&w3, &w3)) != MP_OKAY) { if ((res = mp_div_2(&w3, &w3)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r2 - r0 - r4 */ /* r2 - r0 - r4 */
if ((res = mp_sub(&w2, &w0, &w2)) != MP_OKAY) { if ((res = mp_sub(&w2, &w0, &w2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_sub(&w2, &w4, &w2)) != MP_OKAY) { if ((res = mp_sub(&w2, &w4, &w2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r1 - r2 */ /* r1 - r2 */
if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) { if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r3 - r2 */ /* r3 - r2 */
if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) { if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r1 - 8r0 */ /* r1 - 8r0 */
if ((res = mp_mul_2d(&w0, 3, &tmp1)) != MP_OKAY) { if ((res = mp_mul_2d(&w0, 3, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_sub(&w1, &tmp1, &w1)) != MP_OKAY) { if ((res = mp_sub(&w1, &tmp1, &w1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r3 - 8r4 */ /* r3 - 8r4 */
if ((res = mp_mul_2d(&w4, 3, &tmp1)) != MP_OKAY) { if ((res = mp_mul_2d(&w4, 3, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_sub(&w3, &tmp1, &w3)) != MP_OKAY) { if ((res = mp_sub(&w3, &tmp1, &w3)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* 3r2 - r1 - r3 */ /* 3r2 - r1 - r3 */
if ((res = mp_mul_d(&w2, 3, &w2)) != MP_OKAY) { if ((res = mp_mul_d(&w2, 3, &w2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_sub(&w2, &w1, &w2)) != MP_OKAY) { if ((res = mp_sub(&w2, &w1, &w2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_sub(&w2, &w3, &w2)) != MP_OKAY) { if ((res = mp_sub(&w2, &w3, &w2)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r1 - r2 */ /* r1 - r2 */
if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) { if ((res = mp_sub(&w1, &w2, &w1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r3 - r2 */ /* r3 - r2 */
if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) { if ((res = mp_sub(&w3, &w2, &w3)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r1/3 */ /* r1/3 */
if ((res = mp_div_3(&w1, &w1, NULL)) != MP_OKAY) { if ((res = mp_div_3(&w1, &w1, NULL)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* r3/3 */ /* r3/3 */
if ((res = mp_div_3(&w3, &w3, NULL)) != MP_OKAY) { if ((res = mp_div_3(&w3, &w3, NULL)) != MP_OKAY) {
goto ERR; goto ERR;
} }
/* at this point shift W[n] by B*n */ /* at this point shift W[n] by B*n */
if ((res = mp_lshd(&w1, 1*B)) != MP_OKAY) { if ((res = mp_lshd(&w1, 1*B)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_lshd(&w2, 2*B)) != MP_OKAY) { if ((res = mp_lshd(&w2, 2*B)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_lshd(&w3, 3*B)) != MP_OKAY) { if ((res = mp_lshd(&w3, 3*B)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_lshd(&w4, 4*B)) != MP_OKAY) { if ((res = mp_lshd(&w4, 4*B)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&w0, &w1, b)) != MP_OKAY) { if ((res = mp_add(&w0, &w1, b)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&w2, &w3, &tmp1)) != MP_OKAY) { if ((res = mp_add(&w2, &w3, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&w4, &tmp1, &tmp1)) != MP_OKAY) { if ((res = mp_add(&w4, &tmp1, &tmp1)) != MP_OKAY) {
goto ERR; goto ERR;
} }
if ((res = mp_add(&tmp1, b, b)) != MP_OKAY) { if ((res = mp_add(&tmp1, b, b)) != MP_OKAY) {
goto ERR; goto ERR;
} }
ERR: ERR:
mp_clear_multi(&w0, &w1, &w2, &w3, &w4, &a0, &a1, &a2, &tmp1, NULL); mp_clear_multi(&w0, &w1, &w2, &w3, &w4, &a0, &a1, &a2, &tmp1, NULL);
return res; return res;
} }
#endif #endif

82
bn_mp_toradix.c
View File

@ -18,54 +18,54 @@
/* stores a bignum as a ASCII string in a given radix (2..64) */ /* stores a bignum as a ASCII string in a given radix (2..64) */
int mp_toradix(mp_int *a, char *str, int radix) int mp_toradix(mp_int *a, char *str, int radix)
{ {
int res, digs; int res, digs;
mp_int t; mp_int t;
mp_digit d; mp_digit d;
char *_s = str; char *_s = str;
/* check range of the radix */ /* check range of the radix */
if ((radix < 2) || (radix > 64)) { if ((radix < 2) || (radix > 64)) {
return MP_VAL; return MP_VAL;
} }
/* quick out if its zero */ /* quick out if its zero */
if (mp_iszero(a) == MP_YES) { if (mp_iszero(a) == MP_YES) {
*str++ = '0'; *str++ = '0';
*str = '\0'; *str = '\0';
return MP_OKAY; return MP_OKAY;
} }
if ((res = mp_init_copy(&t, a)) != MP_OKAY) { if ((res = mp_init_copy(&t, a)) != MP_OKAY) {
return res;
}
/* if it is negative output a - */
if (t.sign == MP_NEG) {
++_s;
*str++ = '-';
t.sign = MP_ZPOS;
}
digs = 0;
while (mp_iszero(&t) == MP_NO) {
if ((res = mp_div_d(&t, (mp_digit)radix, &t, &d)) != MP_OKAY) {
mp_clear(&t);
return res; return res;
} }
*str++ = mp_s_rmap[d];
++digs;
}
/* reverse the digits of the string. In this case _s points /* if it is negative output a - */
* to the first digit [exluding the sign] of the number] if (t.sign == MP_NEG) {
*/ ++_s;
bn_reverse((unsigned char *)_s, digs); *str++ = '-';
t.sign = MP_ZPOS;
}
/* append a NULL so the string is properly terminated */ digs = 0;
*str = '\0'; while (mp_iszero(&t) == MP_NO) {
if ((res = mp_div_d(&t, (mp_digit)radix, &t, &d)) != MP_OKAY) {
mp_clear(&t);
return res;
}
*str++ = mp_s_rmap[d];
++digs;
}
mp_clear(&t); /* reverse the digits of the string. In this case _s points
return MP_OKAY; * to the first digit [exluding the sign] of the number]
*/
bn_reverse((unsigned char *)_s, digs);
/* append a NULL so the string is properly terminated */
*str = '\0';
mp_clear(&t);
return MP_OKAY;
} }
#endif #endif

102
bn_mp_toradix_n.c
View File

@ -21,64 +21,64 @@
*/ */
int mp_toradix_n(mp_int *a, char *str, int radix, int maxlen) int mp_toradix_n(mp_int *a, char *str, int radix, int maxlen)
{ {
int res, digs; int res, digs;
mp_int t; mp_int t;
mp_digit d; mp_digit d;
char *_s = str; char *_s = str;
/* check range of the maxlen, radix */ /* check range of the maxlen, radix */
if ((maxlen < 2) || (radix < 2) || (radix > 64)) { if ((maxlen < 2) || (radix < 2) || (radix > 64)) {
return MP_VAL; return MP_VAL;
} }
/* quick out if its zero */ /* quick out if its zero */
if (mp_iszero(a) == MP_YES) { if (mp_iszero(a) == MP_YES) {
*str++ = '0'; *str++ = '0';
*str = '\0'; *str = '\0';
return MP_OKAY; return MP_OKAY;
} }
if ((res = mp_init_copy(&t, a)) != MP_OKAY) { if ((res = mp_init_copy(&t, a)) != MP_OKAY) {
return res;
}
/* if it is negative output a - */
if (t.sign == MP_NEG) {
/* we have to reverse our digits later... but not the - sign!! */
++_s;
/* store the flag and mark the number as positive */
*str++ = '-';
t.sign = MP_ZPOS;
/* subtract a char */
--maxlen;
}
digs = 0;
while (mp_iszero(&t) == MP_NO) {
if (--maxlen < 1) {
/* no more room */
break;
}
if ((res = mp_div_d(&t, (mp_digit)radix, &t, &d)) != MP_OKAY) {
mp_clear(&t);
return res; return res;
} }
*str++ = mp_s_rmap[d];
++digs;
}
/* reverse the digits of the string. In this case _s points /* if it is negative output a - */
* to the first digit [exluding the sign] of the number if (t.sign == MP_NEG) {
*/ /* we have to reverse our digits later... but not the - sign!! */
bn_reverse((unsigned char *)_s, digs); ++_s;
/* append a NULL so the string is properly terminated */ /* store the flag and mark the number as positive */
*str = '\0'; *str++ = '-';
t.sign = MP_ZPOS;
mp_clear(&t); /* subtract a char */
return MP_OKAY; --maxlen;
}
digs = 0;
while (mp_iszero(&t) == MP_NO) {
if (--maxlen < 1) {
/* no more room */
break;
}
if ((res = mp_div_d(&t, (mp_digit)radix, &t, &d)) != MP_OKAY) {
mp_clear(&t);
return res;
}
*str++ = mp_s_rmap[d];
++digs;
}
/* reverse the digits of the string. In this case _s points
* to the first digit [exluding the sign] of the number
*/
bn_reverse((unsigned char *)_s, digs);
/* append a NULL so the string is properly terminated */
*str = '\0';
mp_clear(&t);
return MP_OKAY;
} }
#endif #endif

4
bn_mp_unsigned_bin_size.c
View File

@ -18,8 +18,8 @@
/* get the size for an unsigned equivalent */ /* get the size for an unsigned equivalent */
int mp_unsigned_bin_size(mp_int *a) int mp_unsigned_bin_size(mp_int *a)
{ {
int size = mp_count_bits(a); int size = mp_count_bits(a);
return (size / 8) + (((size & 7) != 0) ? 1 : 0); return (size / 8) + (((size & 7) != 0) ? 1 : 0);
} }
#endif #endif

44
bn_mp_xor.c
View File

@ -18,30 +18,30 @@
/* XOR two ints together */ /* XOR two ints together */
int mp_xor(mp_int *a, mp_int *b, mp_int *c) int mp_xor(mp_int *a, mp_int *b, mp_int *c)
{ {
int res, ix, px; int res, ix, px;
mp_int t, *x; mp_int t, *x;
if (a->used > b->used) { if (a->used > b->used) {
if ((res = mp_init_copy(&t, a)) != MP_OKAY) { if ((res = mp_init_copy(&t, a)) != MP_OKAY) {
return res; return res;
} }
px = b->used; px = b->used;
x = b; x = b;
} else { } else {
if ((res = mp_init_copy(&t, b)) != MP_OKAY) { if ((res = mp_init_copy(&t, b)) != MP_OKAY) {
return res; return res;
} }
px = a->used; px = a->used;
x = a; x = a;
} }
for (ix = 0; ix < px; ix++) { for (ix = 0; ix < px; ix++) {
t.dp[ix] ^= x->dp[ix]; t.dp[ix] ^= x->dp[ix];
} }
mp_clamp(&t); mp_clamp(&t);
mp_exch(c, &t); mp_exch(c, &t);
mp_clear(&t); mp_clear(&t);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

16
bn_mp_zero.c
View File

@ -18,16 +18,16 @@
/* set to zero */ /* set to zero */
void mp_zero(mp_int *a) void mp_zero(mp_int *a)
{ {
int n; int n;
mp_digit *tmp; mp_digit *tmp;
a->sign = MP_ZPOS; a->sign = MP_ZPOS;
a->used = 0; a->used = 0;
tmp = a->dp; tmp = a->dp;
for (n = 0; n < a->alloc; n++) { for (n = 0; n < a->alloc; n++) {
*tmp++ = 0; *tmp++ = 0;
} }
} }
#endif #endif

66
bn_prime_tab.c
View File

@ -15,43 +15,43 @@
* Tom St Denis, tstdenis82@gmail.com, http://libtom.org * Tom St Denis, tstdenis82@gmail.com, http://libtom.org
*/ */
const mp_digit ltm_prime_tab[] = { const mp_digit ltm_prime_tab[] = {
0x0002, 0x0003, 0x0005, 0x0007, 0x000B, 0x000D, 0x0011, 0x0013, 0x0002, 0x0003, 0x0005, 0x0007, 0x000B, 0x000D, 0x0011, 0x0013,
0x0017, 0x001D, 0x001F, 0x0025, 0x0029, 0x002B, 0x002F, 0x0035, 0x0017, 0x001D, 0x001F, 0x0025, 0x0029, 0x002B, 0x002F, 0x0035,
0x003B, 0x003D, 0x0043, 0x0047, 0x0049, 0x004F, 0x0053, 0x0059, 0x003B, 0x003D, 0x0043, 0x0047, 0x0049, 0x004F, 0x0053, 0x0059,
0x0061, 0x0065, 0x0067, 0x006B, 0x006D, 0x0071, 0x007F, 0x0061, 0x0065, 0x0067, 0x006B, 0x006D, 0x0071, 0x007F,
#ifndef MP_8BIT #ifndef MP_8BIT
0x0083, 0x0083,
0x0089, 0x008B, 0x0095, 0x0097, 0x009D, 0x00A3, 0x00A7, 0x00AD, 0x0089, 0x008B, 0x0095, 0x0097, 0x009D, 0x00A3, 0x00A7, 0x00AD,
0x00B3, 0x00B5, 0x00BF, 0x00C1, 0x00C5, 0x00C7, 0x00D3, 0x00DF, 0x00B3, 0x00B5, 0x00BF, 0x00C1, 0x00C5, 0x00C7, 0x00D3, 0x00DF,
0x00E3, 0x00E5, 0x00E9, 0x00EF, 0x00F1, 0x00FB, 0x0101, 0x0107, 0x00E3, 0x00E5, 0x00E9, 0x00EF, 0x00F1, 0x00FB, 0x0101, 0x0107,
0x010D, 0x010F, 0x0115, 0x0119, 0x011B, 0x0125, 0x0133, 0x0137, 0x010D, 0x010F, 0x0115, 0x0119, 0x011B, 0x0125, 0x0133, 0x0137,
0x0139, 0x013D, 0x014B, 0x0151, 0x015B, 0x015D, 0x0161, 0x0167, 0x0139, 0x013D, 0x014B, 0x0151, 0x015B, 0x015D, 0x0161, 0x0167,
0x016F, 0x0175, 0x017B, 0x017F, 0x0185, 0x018D, 0x0191, 0x0199, 0x016F, 0x0175, 0x017B, 0x017F, 0x0185, 0x018D, 0x0191, 0x0199,
0x01A3, 0x01A5, 0x01AF, 0x01B1, 0x01B7, 0x01BB, 0x01C1, 0x01C9, 0x01A3, 0x01A5, 0x01AF, 0x01B1, 0x01B7, 0x01BB, 0x01C1, 0x01C9,
0x01CD, 0x01CF, 0x01D3, 0x01DF, 0x01E7, 0x01EB, 0x01F3, 0x01F7, 0x01CD, 0x01CF, 0x01D3, 0x01DF, 0x01E7, 0x01EB, 0x01F3, 0x01F7,
0x01FD, 0x0209, 0x020B, 0x021D, 0x0223, 0x022D, 0x0233, 0x0239, 0x01FD, 0x0209, 0x020B, 0x021D, 0x0223, 0x022D, 0x0233, 0x0239,
0x023B, 0x0241, 0x024B, 0x0251, 0x0257, 0x0259, 0x025F, 0x0265, 0x023B, 0x0241, 0x024B, 0x0251, 0x0257, 0x0259, 0x025F, 0x0265,
0x0269, 0x026B, 0x0277, 0x0281, 0x0283, 0x0287, 0x028D, 0x0293, 0x0269, 0x026B, 0x0277, 0x0281, 0x0283, 0x0287, 0x028D, 0x0293,
0x0295, 0x02A1, 0x02A5, 0x02AB, 0x02B3, 0x02BD, 0x02C5, 0x02CF, 0x0295, 0x02A1, 0x02A5, 0x02AB, 0x02B3, 0x02BD, 0x02C5, 0x02CF,
0x02D7, 0x02DD, 0x02E3, 0x02E7, 0x02EF, 0x02F5, 0x02F9, 0x0301, 0x02D7, 0x02DD, 0x02E3, 0x02E7, 0x02EF, 0x02F5, 0x02F9, 0x0301,
0x0305, 0x0313, 0x031D, 0x0329, 0x032B, 0x0335, 0x0337, 0x033B, 0x0305, 0x0313, 0x031D, 0x0329, 0x032B, 0x0335, 0x0337, 0x033B,
0x033D, 0x0347, 0x0355, 0x0359, 0x035B, 0x035F, 0x036D, 0x0371, 0x033D, 0x0347, 0x0355, 0x0359, 0x035B, 0x035F, 0x036D, 0x0371,
0x0373, 0x0377, 0x038B, 0x038F, 0x0397, 0x03A1, 0x03A9, 0x03AD, 0x0373, 0x0377, 0x038B, 0x038F, 0x0397, 0x03A1, 0x03A9, 0x03AD,
0x03B3, 0x03B9, 0x03C7, 0x03CB, 0x03D1, 0x03D7, 0x03DF, 0x03E5, 0x03B3, 0x03B9, 0x03C7, 0x03CB, 0x03D1, 0x03D7, 0x03DF, 0x03E5,
0x03F1, 0x03F5, 0x03FB, 0x03FD, 0x0407, 0x0409, 0x040F, 0x0419, 0x03F1, 0x03F5, 0x03FB, 0x03FD, 0x0407, 0x0409, 0x040F, 0x0419,
0x041B, 0x0425, 0x0427, 0x042D, 0x043F, 0x0443, 0x0445, 0x0449, 0x041B, 0x0425, 0x0427, 0x042D, 0x043F, 0x0443, 0x0445, 0x0449,
0x044F, 0x0455, 0x045D, 0x0463, 0x0469, 0x047F, 0x0481, 0x048B, 0x044F, 0x0455, 0x045D, 0x0463, 0x0469, 0x047F, 0x0481, 0x048B,
0x0493, 0x049D, 0x04A3, 0x04A9, 0x04B1, 0x04BD, 0x04C1, 0x04C7, 0x0493, 0x049D, 0x04A3, 0x04A9, 0x04B1, 0x04BD, 0x04C1, 0x04C7,
0x04CD, 0x04CF, 0x04D5, 0x04E1, 0x04EB, 0x04FD, 0x04FF, 0x0503, 0x04CD, 0x04CF, 0x04D5, 0x04E1, 0x04EB, 0x04FD, 0x04FF, 0x0503,
0x0509, 0x050B, 0x0511, 0x0515, 0x0517, 0x051B, 0x0527, 0x0529, 0x0509, 0x050B, 0x0511, 0x0515, 0x0517, 0x051B, 0x0527, 0x0529,
0x052F, 0x0551, 0x0557, 0x055D, 0x0565, 0x0577, 0x0581, 0x058F, 0x052F, 0x0551, 0x0557, 0x055D, 0x0565, 0x0577, 0x0581, 0x058F,
0x0593, 0x0595, 0x0599, 0x059F, 0x05A7, 0x05AB, 0x05AD, 0x05B3, 0x0593, 0x0595, 0x0599, 0x059F, 0x05A7, 0x05AB, 0x05AD, 0x05B3,
0x05BF, 0x05C9, 0x05CB, 0x05CF, 0x05D1, 0x05D5, 0x05DB, 0x05E7, 0x05BF, 0x05C9, 0x05CB, 0x05CF, 0x05D1, 0x05D5, 0x05DB, 0x05E7,
0x05F3, 0x05FB, 0x0607, 0x060D, 0x0611, 0x0617, 0x061F, 0x0623, 0x05F3, 0x05FB, 0x0607, 0x060D, 0x0611, 0x0617, 0x061F, 0x0623,
0x062B, 0x062F, 0x063D, 0x0641, 0x0647, 0x0649, 0x064D, 0x0653 0x062B, 0x062F, 0x063D, 0x0641, 0x0647, 0x0649, 0x064D, 0x0653
#endif #endif
}; };
#endif #endif

22
bn_reverse.c
View File

@ -18,18 +18,18 @@
/* reverse an array, used for radix code */ /* reverse an array, used for radix code */
void bn_reverse(unsigned char *s, int len) void bn_reverse(unsigned char *s, int len)
{ {
int ix, iy; int ix, iy;
unsigned char t; unsigned char t;
ix = 0; ix = 0;
iy = len - 1; iy = len - 1;
while (ix < iy) { while (ix < iy) {
t = s[ix]; t = s[ix];
s[ix] = s[iy]; s[ix] = s[iy];
s[iy] = t; s[iy] = t;
++ix; ++ix;
--iy; --iy;
} }
} }
#endif #endif

98
bn_s_mp_mul_digs.c
View File

@ -21,67 +21,67 @@
*/ */
int s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs) int s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs)
{ {
mp_int t; mp_int t;
int res, pa, pb, ix, iy; int res, pa, pb, ix, iy;
mp_digit u; mp_digit u;
mp_word r; mp_word r;
mp_digit tmpx, *tmpt, *tmpy; mp_digit tmpx, *tmpt, *tmpy;
/* can we use the fast multiplier? */ /* can we use the fast multiplier? */
if (((digs) < MP_WARRAY) && if (((digs) < MP_WARRAY) &&
(MIN (a->used, b->used) < (MIN(a->used, b->used) <
(1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) { (1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) {
return fast_s_mp_mul_digs(a, b, c, digs); return fast_s_mp_mul_digs(a, b, c, digs);
} }
if ((res = mp_init_size(&t, digs)) != MP_OKAY) { if ((res = mp_init_size(&t, digs)) != MP_OKAY) {
return res; return res;
} }
t.used = digs; t.used = digs;
/* compute the digits of the product directly */ /* compute the digits of the product directly */
pa = a->used; pa = a->used;
for (ix = 0; ix < pa; ix++) { for (ix = 0; ix < pa; ix++) {
/* set the carry to zero */ /* set the carry to zero */
u = 0; u = 0;
/* limit ourselves to making digs digits of output */ /* limit ourselves to making digs digits of output */
pb = MIN(b->used, digs - ix); pb = MIN(b->used, digs - ix);
/* setup some aliases */ /* setup some aliases */
/* copy of the digit from a used within the nested loop */ /* copy of the digit from a used within the nested loop */
tmpx = a->dp[ix]; tmpx = a->dp[ix];
/* an alias for the destination shifted ix places */ /* an alias for the destination shifted ix places */
tmpt = t.dp + ix; tmpt = t.dp + ix;
/* an alias for the digits of b */ /* an alias for the digits of b */
tmpy = b->dp; tmpy = b->dp;
/* compute the columns of the output and propagate the carry */ /* compute the columns of the output and propagate the carry */
for (iy = 0; iy < pb; iy++) { for (iy = 0; iy < pb; iy++) {
/* compute the column as a mp_word */ /* compute the column as a mp_word */
r = (mp_word)*tmpt + r = (mp_word)*tmpt +
((mp_word)tmpx * (mp_word)*tmpy++) + ((mp_word)tmpx * (mp_word)*tmpy++) +
(mp_word)u; (mp_word)u;
/* the new column is the lower part of the result */ /* the new column is the lower part of the result */
*tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK)); *tmpt++ = (mp_digit)(r & ((mp_word) MP_MASK));
/* get the carry word from the result */ /* get the carry word from the result */
u = (mp_digit) (r >> ((mp_word) DIGIT_BIT)); u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
} }
/* set carry if it is placed below digs */ /* set carry if it is placed below digs */
if ((ix + iy) < digs) { if ((ix + iy) < digs) {
*tmpt = u; *tmpt = u;
} }
} }
mp_clamp(&t); mp_clamp(&t);
mp_exch(&t, c); mp_exch(&t, c);
mp_clear(&t); mp_clear(&t);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

82
bn_s_mp_mul_high_digs.c
View File

@ -20,58 +20,58 @@
*/ */
int s_mp_mul_high_digs(mp_int *a, mp_int *b, mp_int *c, int digs) int s_mp_mul_high_digs(mp_int *a, mp_int *b, mp_int *c, int digs)
{ {
mp_int t; mp_int t;
int res, pa, pb, ix, iy; int res, pa, pb, ix, iy;
mp_digit u; mp_digit u;
mp_word r; mp_word r;
mp_digit tmpx, *tmpt, *tmpy; mp_digit tmpx, *tmpt, *tmpy;
/* can we use the fast multiplier? */ /* can we use the fast multiplier? */
#ifdef BN_FAST_S_MP_MUL_HIGH_DIGS_C #ifdef BN_FAST_S_MP_MUL_HIGH_DIGS_C
if (((a->used + b->used + 1) < MP_WARRAY) if (((a->used + b->used + 1) < MP_WARRAY)
&& (MIN(a->used, b->used) < (1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) { && (MIN(a->used, b->used) < (1 << ((CHAR_BIT * sizeof(mp_word)) - (2 * DIGIT_BIT))))) {
return fast_s_mp_mul_high_digs(a, b, c, digs); return fast_s_mp_mul_high_digs(a, b, c, digs);
} }
#endif #endif
if ((res = mp_init_size(&t, a->used + b->used + 1)) != MP_OKAY) { if ((res = mp_init_size(&t, a->used + b->used + 1)) != MP_OKAY) {
return res; return res;
} }
t.used = a->used + b->used + 1; t.used = a->used + b->used + 1;
pa = a->used; pa = a->used;
pb = b->used; pb = b->used;
for (ix = 0; ix < pa; ix++) { for (ix = 0; ix < pa; ix++) {
/* clear the carry */ /* clear the carry */
u = 0; u = 0;
/* left hand side of A[ix] * B[iy] */ /* left hand side of A[ix] * B[iy] */
tmpx = a->dp[ix]; tmpx = a->dp[ix];
/* alias to the address of where the digits will be stored */ /* alias to the address of where the digits will be stored */
tmpt = &(t.dp[digs]); tmpt = &(t.dp[digs]);
/* alias for where to read the right hand side from */ /* alias for where to read the right hand side from */
tmpy = b->dp + (digs - ix); tmpy = b->dp + (digs - ix);
for (iy = digs - ix; iy < pb; iy++) { for (iy = digs - ix; iy < pb; iy++) {
/* calculate the double precision result */ /* calculate the double precision result */
r = (mp_word)*tmpt + r = (mp_word)*tmpt +
((mp_word)tmpx * (mp_word)*tmpy++) + ((mp_word)tmpx * (mp_word)*tmpy++) +
(mp_word)u; (mp_word)u;
/* get the lower part */ /* get the lower part */
*tmpt++ = (mp_digit)(r & ((mp_word) MP_MASK)); *tmpt++ = (mp_digit)(r & ((mp_word) MP_MASK));
/* carry the carry */ /* carry the carry */
u = (mp_digit)(r >> ((mp_word) DIGIT_BIT)); u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
} }
*tmpt = u; *tmpt = u;
} }
mp_clamp(&t); mp_clamp(&t);
mp_exch(&t, c); mp_exch(&t, c);
mp_clear(&t); mp_clear(&t);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

92
bn_s_mp_sqr.c
View File

@ -18,64 +18,64 @@
/* low level squaring, b = a*a, HAC pp.596-597, Algorithm 14.16 */ /* low level squaring, b = a*a, HAC pp.596-597, Algorithm 14.16 */
int s_mp_sqr(mp_int *a, mp_int *b) int s_mp_sqr(mp_int *a, mp_int *b)
{ {
mp_int t; mp_int t;
int res, ix, iy, pa; int res, ix, iy, pa;
mp_word r; mp_word r;
mp_digit u, tmpx, *tmpt; mp_digit u, tmpx, *tmpt;
pa = a->used; pa = a->used;
if ((res = mp_init_size(&t, (2 * pa) + 1)) != MP_OKAY) { if ((res = mp_init_size(&t, (2 * pa) + 1)) != MP_OKAY) {
return res; return res;
} }
/* default used is maximum possible size */ /* default used is maximum possible size */
t.used = (2 * pa) + 1; t.used = (2 * pa) + 1;
for (ix = 0; ix < pa; ix++) { for (ix = 0; ix < pa; ix++) {
/* first calculate the digit at 2*ix */ /* first calculate the digit at 2*ix */
/* calculate double precision result */ /* calculate double precision result */
r = (mp_word)t.dp[2*ix] + r = (mp_word)t.dp[2*ix] +
((mp_word)a->dp[ix] * (mp_word)a->dp[ix]); ((mp_word)a->dp[ix] * (mp_word)a->dp[ix]);
/* store lower part in result */ /* store lower part in result */
t.dp[ix+ix] = (mp_digit) (r & ((mp_word)MP_MASK)); t.dp[ix+ix] = (mp_digit)(r & ((mp_word)MP_MASK));
/* get the carry */ /* get the carry */
u = (mp_digit)(r >> ((mp_word)DIGIT_BIT)); u = (mp_digit)(r >> ((mp_word)DIGIT_BIT));
/* left hand side of A[ix] * A[iy] */ /* left hand side of A[ix] * A[iy] */
tmpx = a->dp[ix]; tmpx = a->dp[ix];
/* alias for where to store the results */ /* alias for where to store the results */
tmpt = t.dp + ((2 * ix) + 1); tmpt = t.dp + ((2 * ix) + 1);
for (iy = ix + 1; iy < pa; iy++) { for (iy = ix + 1; iy < pa; iy++) {
/* first calculate the product */ /* first calculate the product */
r = ((mp_word)tmpx) * ((mp_word)a->dp[iy]); r = ((mp_word)tmpx) * ((mp_word)a->dp[iy]);
/* now calculate the double precision result, note we use /* now calculate the double precision result, note we use
* addition instead of *2 since it's easier to optimize * addition instead of *2 since it's easier to optimize
*/ */
r = ((mp_word) *tmpt) + r + r + ((mp_word) u); r = ((mp_word) *tmpt) + r + r + ((mp_word) u);
/* store lower part */ /* store lower part */
*tmpt++ = (mp_digit)(r & ((mp_word) MP_MASK)); *tmpt++ = (mp_digit)(r & ((mp_word) MP_MASK));
/* get carry */ /* get carry */
u = (mp_digit)(r >> ((mp_word) DIGIT_BIT)); u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
} }
/* propagate upwards */ /* propagate upwards */
while (u != ((mp_digit) 0)) { while (u != ((mp_digit) 0)) {
r = ((mp_word) *tmpt) + ((mp_word) u); r = ((mp_word) *tmpt) + ((mp_word) u);
*tmpt++ = (mp_digit)(r & ((mp_word) MP_MASK)); *tmpt++ = (mp_digit)(r & ((mp_word) MP_MASK));
u = (mp_digit)(r >> ((mp_word) DIGIT_BIT)); u = (mp_digit)(r >> ((mp_word) DIGIT_BIT));
} }
} }
mp_clamp(&t); mp_clamp(&t);
mp_exch(&t, b); mp_exch(&t, b);
mp_clear(&t); mp_clear(&t);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

98
bn_s_mp_sub.c
View File

@ -18,67 +18,67 @@
/* low level subtraction (assumes |a| > |b|), HAC pp.595 Algorithm 14.9 */ /* low level subtraction (assumes |a| > |b|), HAC pp.595 Algorithm 14.9 */
int s_mp_sub(mp_int *a, mp_int *b, mp_int *c) int s_mp_sub(mp_int *a, mp_int *b, mp_int *c)
{ {
int olduse, res, min, max; int olduse, res, min, max;
/* find sizes */ /* find sizes */
min = b->used; min = b->used;
max = a->used; max = a->used;
/* init result */ /* init result */
if (c->alloc < max) { if (c->alloc < max) {
if ((res = mp_grow(c, max)) != MP_OKAY) { if ((res = mp_grow(c, max)) != MP_OKAY) {
return res; return res;
} }
} }
olduse = c->used; olduse = c->used;
c->used = max; c->used = max;
{ {
mp_digit u, *tmpa, *tmpb, *tmpc; mp_digit u, *tmpa, *tmpb, *tmpc;
int i; int i;
/* alias for digit pointers */ /* alias for digit pointers */
tmpa = a->dp; tmpa = a->dp;
tmpb = b->dp; tmpb = b->dp;
tmpc = c->dp; tmpc = c->dp;
/* set carry to zero */ /* set carry to zero */
u = 0; u = 0;
for (i = 0; i < min; i++) { for (i = 0; i < min; i++) {
/* T[i] = A[i] - B[i] - U */ /* T[i] = A[i] - B[i] - U */
*tmpc = (*tmpa++ - *tmpb++) - u; *tmpc = (*tmpa++ - *tmpb++) - u;
/* U = carry bit of T[i] /* U = carry bit of T[i]
* Note this saves performing an AND operation since * Note this saves performing an AND operation since
* if a carry does occur it will propagate all the way to the * if a carry does occur it will propagate all the way to the
* MSB. As a result a single shift is enough to get the carry * MSB. As a result a single shift is enough to get the carry
*/ */
u = *tmpc >> ((mp_digit)((CHAR_BIT * sizeof(mp_digit)) - 1)); u = *tmpc >> ((mp_digit)((CHAR_BIT * sizeof(mp_digit)) - 1));
/* Clear carry from T[i] */ /* Clear carry from T[i] */
*tmpc++ &= MP_MASK; *tmpc++ &= MP_MASK;
} }
/* now copy higher words if any, e.g. if A has more digits than B */ /* now copy higher words if any, e.g. if A has more digits than B */
for (; i < max; i++) { for (; i < max; i++) {
/* T[i] = A[i] - U */ /* T[i] = A[i] - U */
*tmpc = *tmpa++ - u; *tmpc = *tmpa++ - u;
/* U = carry bit of T[i] */ /* U = carry bit of T[i] */
u = *tmpc >> ((mp_digit)((CHAR_BIT * sizeof(mp_digit)) - 1)); u = *tmpc >> ((mp_digit)((CHAR_BIT * sizeof(mp_digit)) - 1));
/* Clear carry from T[i] */ /* Clear carry from T[i] */
*tmpc++ &= MP_MASK; *tmpc++ &= MP_MASK;
} }
/* clear digits above used (since we may not have grown result above) */ /* clear digits above used (since we may not have grown result above) */
for (i = c->used; i < olduse; i++) { for (i = c->used; i < olduse; i++) {
*tmpc++ = 0; *tmpc++ = 0;
} }
} }
mp_clamp(c); mp_clamp(c);
return MP_OKAY; return MP_OKAY;
} }
#endif #endif

74
tommath.h
View File

@ -47,45 +47,45 @@ extern "C" {
* [any size beyond that is ok provided it doesn't overflow the data type] * [any size beyond that is ok provided it doesn't overflow the data type]
*/ */
#ifdef MP_8BIT #ifdef MP_8BIT
typedef uint8_t mp_digit; typedef uint8_t mp_digit;
typedef uint16_t mp_word; typedef uint16_t mp_word;
# define MP_SIZEOF_MP_DIGIT 1 # define MP_SIZEOF_MP_DIGIT 1
# ifdef DIGIT_BIT # ifdef DIGIT_BIT
# error You must not define DIGIT_BIT when using MP_8BIT # error You must not define DIGIT_BIT when using MP_8BIT
# endif # endif
#elif defined(MP_16BIT) #elif defined(MP_16BIT)
typedef uint16_t mp_digit; typedef uint16_t mp_digit;
typedef uint32_t mp_word; typedef uint32_t mp_word;
# define MP_SIZEOF_MP_DIGIT 2 # define MP_SIZEOF_MP_DIGIT 2
# ifdef DIGIT_BIT # ifdef DIGIT_BIT
# error You must not define DIGIT_BIT when using MP_16BIT # error You must not define DIGIT_BIT when using MP_16BIT
# endif # endif
#elif defined(MP_64BIT) #elif defined(MP_64BIT)
/* for GCC only on supported platforms */ /* for GCC only on supported platforms */
typedef uint64_t mp_digit; typedef uint64_t mp_digit;
# if defined(_WIN32) # if defined(_WIN32)
typedef unsigned __int128 mp_word; typedef unsigned __int128 mp_word;
# elif defined(__GNUC__) # elif defined(__GNUC__)
typedef unsigned long mp_word __attribute__ ((mode(TI))); typedef unsigned long mp_word __attribute__((mode(TI)));
# else # else
/* it seems you have a problem /* it seems you have a problem
* but we assume you can somewhere define your own uint128_t */ * but we assume you can somewhere define your own uint128_t */
typedef uint128_t mp_word; typedef uint128_t mp_word;
# endif # endif
# define DIGIT_BIT 60 # define DIGIT_BIT 60
#else #else
/* this is the default case, 28-bit digits */ /* this is the default case, 28-bit digits */
/* this is to make porting into LibTomCrypt easier :-) */ /* this is to make porting into LibTomCrypt easier :-) */
typedef uint32_t mp_digit; typedef uint32_t mp_digit;
typedef uint64_t mp_word; typedef uint64_t mp_word;
# ifdef MP_31BIT # ifdef MP_31BIT
/* this is an extension that uses 31-bit digits */ /* this is an extension that uses 31-bit digits */
# define DIGIT_BIT 31 # define DIGIT_BIT 31
# else # else
/* default case is 28-bit digits, defines MP_28BIT as a handy macro to test */ /* default case is 28-bit digits, defines MP_28BIT as a handy macro to test */
# define DIGIT_BIT 28 # define DIGIT_BIT 28
# define MP_28BIT # define MP_28BIT
# endif # endif
@ -94,9 +94,9 @@ extern "C" {
/* otherwise the bits per digit is calculated automatically from the size of a mp_digit */ /* otherwise the bits per digit is calculated automatically from the size of a mp_digit */
#ifndef DIGIT_BIT #ifndef DIGIT_BIT
# define DIGIT_BIT (((CHAR_BIT * MP_SIZEOF_MP_DIGIT) - 1)) /* bits per digit */ # define DIGIT_BIT (((CHAR_BIT * MP_SIZEOF_MP_DIGIT) - 1)) /* bits per digit */
typedef uint_least32_t mp_min_u32; typedef uint_least32_t mp_min_u32;
#else #else
typedef mp_digit mp_min_u32; typedef mp_digit mp_min_u32;
#endif #endif
/* use arc4random on platforms that support it */ /* use arc4random on platforms that support it */
@ -140,9 +140,9 @@ typedef int mp_err;
/* you'll have to tune these... */ /* you'll have to tune these... */
extern int KARATSUBA_MUL_CUTOFF, extern int KARATSUBA_MUL_CUTOFF,
KARATSUBA_SQR_CUTOFF, KARATSUBA_SQR_CUTOFF,
TOOM_MUL_CUTOFF, TOOM_MUL_CUTOFF,
TOOM_SQR_CUTOFF; TOOM_SQR_CUTOFF;
/* define this to use lower memory usage routines (exptmods mostly) */ /* define this to use lower memory usage routines (exptmods mostly) */
/* #define MP_LOW_MEM */ /* #define MP_LOW_MEM */
@ -161,8 +161,8 @@ extern int KARATSUBA_MUL_CUTOFF,
/* the infamous mp_int structure */ /* the infamous mp_int structure */
typedef struct { typedef struct {
int used, alloc, sign; int used, alloc, sign;
mp_digit *dp; mp_digit *dp;
} mp_int; } mp_int;
/* callback for mp_prime_random, should fill dst with random bytes and return how many read [upto len] */ /* callback for mp_prime_random, should fill dst with random bytes and return how many read [upto len] */
@ -223,19 +223,19 @@ int mp_set_long(mp_int *a, unsigned long b);
int mp_set_long_long(mp_int *a, unsigned long long b); int mp_set_long_long(mp_int *a, unsigned long long b);
/* get a 32-bit value */ /* get a 32-bit value */
unsigned long mp_get_int(mp_int * a); unsigned long mp_get_int(mp_int *a);
/* get a platform dependent unsigned long value */ /* get a platform dependent unsigned long value */
unsigned long mp_get_long(mp_int * a); unsigned long mp_get_long(mp_int *a);
/* get a platform dependent unsigned long long value */ /* get a platform dependent unsigned long long value */
unsigned long long mp_get_long_long(mp_int * a); unsigned long long mp_get_long_long(mp_int *a);
/* initialize and set a digit */ /* initialize and set a digit */
int mp_init_set (mp_int * a, mp_digit b); int mp_init_set(mp_int *a, mp_digit b);
/* initialize and set 32-bit value */ /* initialize and set 32-bit value */
int mp_init_set_int (mp_int * a, unsigned long b); int mp_init_set_int(mp_int *a, unsigned long b);
/* copy, b = a */ /* copy, b = a */
int mp_copy(mp_int *a, mp_int *b); int mp_copy(mp_int *a, mp_int *b);
@ -247,10 +247,10 @@ int mp_init_copy(mp_int *a, mp_int *b);
void mp_clamp(mp_int *a); void mp_clamp(mp_int *a);
/* import binary data */ /* import binary data */
int mp_import(mp_int* rop, size_t count, int order, size_t size, int endian, size_t nails, const void* op); int mp_import(mp_int *rop, size_t count, int order, size_t size, int endian, size_t nails, const void *op);
/* export binary data */ /* export binary data */
int mp_export(void* rop, size_t* countp, int order, size_t size, int endian, size_t nails, mp_int* op); int mp_export(void *rop, size_t *countp, int order, size_t size, int endian, size_t nails, mp_int *op);
/* ---> digit manipulation <--- */ /* ---> digit manipulation <--- */
@ -350,7 +350,7 @@ int mp_div_3(mp_int *a, mp_int *c, mp_digit *d);
/* c = a**b */ /* c = a**b */
int mp_expt_d(mp_int *a, mp_digit b, mp_int *c); int mp_expt_d(mp_int *a, mp_digit b, mp_int *c);
int mp_expt_d_ex (mp_int * a, mp_digit b, mp_int * c, int fast); int mp_expt_d_ex(mp_int *a, mp_digit b, mp_int *c, int fast);
/* c = a mod b, 0 <= c < b */ /* c = a mod b, 0 <= c < b */
int mp_mod_d(mp_int *a, mp_digit b, mp_digit *c); int mp_mod_d(mp_int *a, mp_digit b, mp_digit *c);
@ -386,7 +386,7 @@ int mp_lcm(mp_int *a, mp_int *b, mp_int *c);
* returns error if a < 0 and b is even * returns error if a < 0 and b is even
*/ */
int mp_n_root(mp_int *a, mp_digit b, mp_int *c); int mp_n_root(mp_int *a, mp_digit b, mp_int *c);
int mp_n_root_ex (mp_int * a, mp_digit b, mp_int * c, int fast); int mp_n_root_ex(mp_int *a, mp_digit b, mp_int *c, int fast);
/* special sqrt algo */ /* special sqrt algo */
int mp_sqrt(mp_int *arg, mp_int *ret); int mp_sqrt(mp_int *arg, mp_int *ret);
@ -529,16 +529,16 @@ int mp_count_bits(mp_int *a);
int mp_unsigned_bin_size(mp_int *a); int mp_unsigned_bin_size(mp_int *a);
int mp_read_unsigned_bin(mp_int *a, const unsigned char *b, int c); int mp_read_unsigned_bin(mp_int *a, const unsigned char *b, int c);
int mp_to_unsigned_bin(mp_int *a, unsigned char *b); int mp_to_unsigned_bin(mp_int *a, unsigned char *b);
int mp_to_unsigned_bin_n (mp_int * a, unsigned char *b, unsigned long *outlen); int mp_to_unsigned_bin_n(mp_int *a, unsigned char *b, unsigned long *outlen);
int mp_signed_bin_size(mp_int *a); int mp_signed_bin_size(mp_int *a);
int mp_read_signed_bin(mp_int *a, const unsigned char *b, int c); int mp_read_signed_bin(mp_int *a, const unsigned char *b, int c);
int mp_to_signed_bin(mp_int *a, unsigned char *b); int mp_to_signed_bin(mp_int *a, unsigned char *b);
int mp_to_signed_bin_n (mp_int * a, unsigned char *b, unsigned long *outlen); int mp_to_signed_bin_n(mp_int *a, unsigned char *b, unsigned long *outlen);
int mp_read_radix(mp_int *a, const char *str, int radix); int mp_read_radix(mp_int *a, const char *str, int radix);
int mp_toradix(mp_int *a, char *str, int radix); int mp_toradix(mp_int *a, char *str, int radix);
int mp_toradix_n(mp_int * a, char *str, int radix, int maxlen); int mp_toradix_n(mp_int *a, char *str, int radix, int maxlen);
int mp_radix_size(mp_int *a, int radix, int *size); int mp_radix_size(mp_int *a, int radix, int *size);
#ifndef LTM_NO_FILE #ifndef LTM_NO_FILE
@ -559,7 +559,7 @@ int mp_fwrite(mp_int *a, int radix, FILE *stream);
#define mp_tohex(M, S) mp_toradix((M), (S), 16) #define mp_tohex(M, S) mp_toradix((M), (S), 16)
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif

22
tommath_private.h
View File

@ -19,11 +19,11 @@
#include <ctype.h> #include <ctype.h>
#ifndef MIN #ifndef MIN
#define MIN(x, y) (((x) < (y)) ? (x) : (y)) #define MIN(x, y) (((x) < (y)) ? (x) : (y))
#endif #endif
#ifndef MAX #ifndef MAX
#define MAX(x, y) (((x) > (y)) ? (x) : (y)) #define MAX(x, y) (((x) > (y)) ? (x) : (y))
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
@ -41,17 +41,17 @@ extern "C" {
/* define heap macros */ /* define heap macros */
#ifndef XMALLOC #ifndef XMALLOC
/* default to libc stuff */ /* default to libc stuff */
# define XMALLOC malloc # define XMALLOC malloc
# define XFREE free # define XFREE free
# define XREALLOC realloc # define XREALLOC realloc
# define XCALLOC calloc # define XCALLOC calloc
#else #else
/* prototypes for our heap functions */ /* prototypes for our heap functions */
extern void *XMALLOC(size_t n); extern void *XMALLOC(size_t n);
extern void *XREALLOC(void *p, size_t n); extern void *XREALLOC(void *p, size_t n);
extern void *XCALLOC(size_t n, size_t s); extern void *XCALLOC(size_t n, size_t s);
extern void XFREE(void *p); extern void XFREE(void *p);
#endif #endif
/* lowlevel functions, do not call! */ /* lowlevel functions, do not call! */
@ -69,10 +69,10 @@ int mp_toom_mul(mp_int *a, mp_int *b, mp_int *c);
int mp_karatsuba_sqr(mp_int *a, mp_int *b); int mp_karatsuba_sqr(mp_int *a, mp_int *b);
int mp_toom_sqr(mp_int *a, mp_int *b); int mp_toom_sqr(mp_int *a, mp_int *b);
int fast_mp_invmod(mp_int *a, mp_int *b, mp_int *c); int fast_mp_invmod(mp_int *a, mp_int *b, mp_int *c);
int mp_invmod_slow (mp_int * a, mp_int * b, mp_int * c); int mp_invmod_slow(mp_int *a, mp_int *b, mp_int *c);
int fast_mp_montgomery_reduce(mp_int *x, mp_int *n, mp_digit rho); int fast_mp_montgomery_reduce(mp_int *x, mp_int *n, mp_digit rho);
int mp_exptmod_fast(mp_int *G, mp_int *X, mp_int *P, mp_int *Y, int redmode); int mp_exptmod_fast(mp_int *G, mp_int *X, mp_int *P, mp_int *Y, int redmode);
int s_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y, int redmode); int s_mp_exptmod(mp_int *G, mp_int *X, mp_int *P, mp_int *Y, int redmode);
void bn_reverse(unsigned char *s, int len); void bn_reverse(unsigned char *s, int len);
extern const char *mp_s_rmap; extern const char *mp_s_rmap;
@ -112,7 +112,7 @@ int func_name (mp_int * a, type b) \
} }
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif

20
tommath_superclass.h
View File

@ -33,13 +33,13 @@
# define BN_REVERSE_C # define BN_REVERSE_C
# define BN_PRIME_TAB_C # define BN_PRIME_TAB_C
/* other modifiers */ /* other modifiers */
# define BN_MP_DIV_SMALL /* Slower division, not critical */ # define BN_MP_DIV_SMALL /* Slower division, not critical */
/* here we are on the last pass so we turn things off. The functions classes are still there /* here we are on the last pass so we turn things off. The functions classes are still there
* but we remove them specifically from the build. This also invokes tweaks in functions * but we remove them specifically from the build. This also invokes tweaks in functions
* like removing support for even moduli, etc... * like removing support for even moduli, etc...
*/ */
# ifdef LTM_LAST # ifdef LTM_LAST
# undef BN_MP_TOOM_MUL_C # undef BN_MP_TOOM_MUL_C
# undef BN_MP_TOOM_SQR_C # undef BN_MP_TOOM_SQR_C
@ -59,11 +59,11 @@
# undef BN_FAST_S_MP_MUL_HIGH_DIGS_C # undef BN_FAST_S_MP_MUL_HIGH_DIGS_C
# undef BN_FAST_MP_INVMOD_C # undef BN_FAST_MP_INVMOD_C
/* To safely undefine these you have to make sure your RSA key won't exceed the Comba threshold /* To safely undefine these you have to make sure your RSA key won't exceed the Comba threshold
* which is roughly 255 digits [7140 bits for 32-bit machines, 15300 bits for 64-bit machines] * which is roughly 255 digits [7140 bits for 32-bit machines, 15300 bits for 64-bit machines]
* which means roughly speaking you can handle upto 2536-bit RSA keys with these defined without * which means roughly speaking you can handle upto 2536-bit RSA keys with these defined without
* trouble. * trouble.
*/ */
# undef BN_S_MP_MUL_DIGS_C # undef BN_S_MP_MUL_DIGS_C
# undef BN_S_MP_SQR_C # undef BN_S_MP_SQR_C
# undef BN_MP_MONTGOMERY_REDUCE_C # undef BN_MP_MONTGOMERY_REDUCE_C