switching from length_B to length_W which is more precise
This commit is contained in:
parent
4702ee6467
commit
6130055cd5
264
bigint/bigint.c
264
bigint/bigint.c
|
@ -61,16 +61,16 @@
|
||||||
|
|
||||||
/******************************************************************************/
|
/******************************************************************************/
|
||||||
void bigint_adjust(bigint_t* a){
|
void bigint_adjust(bigint_t* a){
|
||||||
while(a->length_B!=0 && a->wordv[a->length_B-1]==0){
|
while(a->length_W!=0 && a->wordv[a->length_W-1]==0){
|
||||||
a->length_B--;
|
a->length_W--;
|
||||||
}
|
}
|
||||||
if(a->length_B==0){
|
if(a->length_W==0){
|
||||||
a->info=0;
|
a->info=0;
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
bigint_word_t t;
|
bigint_word_t t;
|
||||||
uint8_t i = BIGINT_WORD_SIZE-1;
|
uint8_t i = BIGINT_WORD_SIZE-1;
|
||||||
t = a->wordv[a->length_B-1];
|
t = a->wordv[a->length_W-1];
|
||||||
while((t&(1L<<(BIGINT_WORD_SIZE-1)))==0 && i){
|
while((t&(1L<<(BIGINT_WORD_SIZE-1)))==0 && i){
|
||||||
t<<=1;
|
t<<=1;
|
||||||
i--;
|
i--;
|
||||||
|
@ -81,25 +81,25 @@ void bigint_adjust(bigint_t* a){
|
||||||
/******************************************************************************/
|
/******************************************************************************/
|
||||||
|
|
||||||
uint16_t bigint_length_b(const bigint_t* a){
|
uint16_t bigint_length_b(const bigint_t* a){
|
||||||
if(!a->length_B || a->length_B==0){
|
if(!a->length_W || a->length_W==0){
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
return (a->length_B-1) * BIGINT_WORD_SIZE + GET_FBS(a);
|
return (a->length_W-1) * BIGINT_WORD_SIZE + GET_FBS(a);
|
||||||
}
|
}
|
||||||
|
|
||||||
/******************************************************************************/
|
/******************************************************************************/
|
||||||
|
|
||||||
uint16_t bigint_length_B(const bigint_t* a){
|
uint16_t bigint_length_B(const bigint_t* a){
|
||||||
return a->length_B * sizeof(bigint_word_t);
|
return a->length_W * sizeof(bigint_word_t);
|
||||||
}
|
}
|
||||||
|
|
||||||
/******************************************************************************/
|
/******************************************************************************/
|
||||||
|
|
||||||
uint32_t bigint_get_first_set_bit(const bigint_t* a){
|
uint32_t bigint_get_first_set_bit(const bigint_t* a){
|
||||||
if(a->length_B==0){
|
if(a->length_W==0){
|
||||||
return (uint32_t)(-1);
|
return (uint32_t)(-1);
|
||||||
}
|
}
|
||||||
return (a->length_B-1)*sizeof(bigint_word_t)*8+GET_FBS(a);
|
return (a->length_W-1)*sizeof(bigint_word_t)*8+GET_FBS(a);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
@ -109,10 +109,10 @@ uint32_t bigint_get_last_set_bit(const bigint_t* a){
|
||||||
uint32_t r=0;
|
uint32_t r=0;
|
||||||
uint8_t b=0;
|
uint8_t b=0;
|
||||||
bigint_word_t x=1;
|
bigint_word_t x=1;
|
||||||
if(a->length_B==0){
|
if(a->length_W==0){
|
||||||
return (uint32_t)(-1);
|
return (uint32_t)(-1);
|
||||||
}
|
}
|
||||||
while(a->wordv[r]==0 && r<a->length_B){
|
while(a->wordv[r]==0 && r<a->length_W){
|
||||||
++r;
|
++r;
|
||||||
}
|
}
|
||||||
if(a->wordv[r] == 0){
|
if(a->wordv[r] == 0){
|
||||||
|
@ -128,8 +128,8 @@ uint32_t bigint_get_last_set_bit(const bigint_t* a){
|
||||||
/******************************************************************************/
|
/******************************************************************************/
|
||||||
|
|
||||||
void bigint_copy(bigint_t* dest, const bigint_t* src){
|
void bigint_copy(bigint_t* dest, const bigint_t* src){
|
||||||
memcpy(dest->wordv, src->wordv, src->length_B*sizeof(bigint_word_t));
|
memcpy(dest->wordv, src->wordv, src->length_W*sizeof(bigint_word_t));
|
||||||
dest->length_B = src->length_B;
|
dest->length_W = src->length_W;
|
||||||
dest->info = src->info;
|
dest->info = src->info;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -139,17 +139,17 @@ void bigint_copy(bigint_t* dest, const bigint_t* src){
|
||||||
void bigint_add_u(bigint_t* dest, const bigint_t* a, const bigint_t* b){
|
void bigint_add_u(bigint_t* dest, const bigint_t* a, const bigint_t* b){
|
||||||
uint16_t i;
|
uint16_t i;
|
||||||
bigint_wordplus_t t=0LL;
|
bigint_wordplus_t t=0LL;
|
||||||
if(a->length_B < b->length_B){
|
if(a->length_W < b->length_W){
|
||||||
XCHG_PTR(a,b);
|
XCHG_PTR(a,b);
|
||||||
}
|
}
|
||||||
for(i=0; i<b->length_B; ++i){
|
for(i=0; i<b->length_W; ++i){
|
||||||
// t = (bigint_wordplus_t)(a->wordv[i]) + (bigint_wordplus_t)(b->wordv[i]) + t;
|
// t = (bigint_wordplus_t)(a->wordv[i]) + (bigint_wordplus_t)(b->wordv[i]) + t;
|
||||||
t += a->wordv[i];
|
t += a->wordv[i];
|
||||||
t += b->wordv[i];
|
t += b->wordv[i];
|
||||||
dest->wordv[i] = (bigint_word_t)t;
|
dest->wordv[i] = (bigint_word_t)t;
|
||||||
t>>=BIGINT_WORD_SIZE;
|
t>>=BIGINT_WORD_SIZE;
|
||||||
}
|
}
|
||||||
for(; i<a->length_B; ++i){
|
for(; i<a->length_W; ++i){
|
||||||
t += a->wordv[i];
|
t += a->wordv[i];
|
||||||
dest->wordv[i] = (bigint_word_t)t;
|
dest->wordv[i] = (bigint_word_t)t;
|
||||||
t>>=BIGINT_WORD_SIZE;
|
t>>=BIGINT_WORD_SIZE;
|
||||||
|
@ -157,7 +157,7 @@ void bigint_add_u(bigint_t* dest, const bigint_t* a, const bigint_t* b){
|
||||||
if(t){
|
if(t){
|
||||||
dest->wordv[i++] = (bigint_word_t)t;
|
dest->wordv[i++] = (bigint_word_t)t;
|
||||||
}
|
}
|
||||||
dest->length_B = i;
|
dest->length_W = i;
|
||||||
bigint_adjust(dest);
|
bigint_adjust(dest);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -165,7 +165,7 @@ void bigint_add_u(bigint_t* dest, const bigint_t* a, const bigint_t* b){
|
||||||
|
|
||||||
/* this should be implemented in assembly */
|
/* this should be implemented in assembly */
|
||||||
void bigint_add_scale_u(bigint_t* dest, const bigint_t* a, uint16_t scale){
|
void bigint_add_scale_u(bigint_t* dest, const bigint_t* a, uint16_t scale){
|
||||||
if(a->length_B == 0){
|
if(a->length_W == 0){
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if(scale == 0){
|
if(scale == 0){
|
||||||
|
@ -174,39 +174,39 @@ void bigint_add_scale_u(bigint_t* dest, const bigint_t* a, uint16_t scale){
|
||||||
}
|
}
|
||||||
bigint_t x;
|
bigint_t x;
|
||||||
#if BIGINT_WORD_SIZE == 8
|
#if BIGINT_WORD_SIZE == 8
|
||||||
memset(dest->wordv + dest->length_B, 0, MAX(dest->length_B, a->length_B + scale) - dest->length_B);
|
memset(dest->wordv + dest->length_W, 0, MAX(dest->length_W, a->length_W + scale) - dest->length_W);
|
||||||
x.wordv = dest->wordv + scale;
|
x.wordv = dest->wordv + scale;
|
||||||
x.length_B = dest->length_B - scale;
|
x.length_W = dest->length_W - scale;
|
||||||
if((int16_t)x.length_B < 0){
|
if((int16_t)x.length_W < 0){
|
||||||
x.length_B = 0;
|
x.length_W = 0;
|
||||||
x.info = 0;
|
x.info = 0;
|
||||||
} else {
|
} else {
|
||||||
x.info = dest->info;
|
x.info = dest->info;
|
||||||
}
|
}
|
||||||
bigint_add_u(&x, &x, a);
|
bigint_add_u(&x, &x, a);
|
||||||
dest->length_B = x.length_B + scale;
|
dest->length_W = x.length_W + scale;
|
||||||
dest->info = 0;
|
dest->info = 0;
|
||||||
bigint_adjust(dest);
|
bigint_adjust(dest);
|
||||||
#else
|
#else
|
||||||
bigint_t s;
|
bigint_t s;
|
||||||
uint16_t word_shift = scale / sizeof(bigint_word_t), byte_shift = scale % sizeof(bigint_word_t);
|
uint16_t word_shift = scale / sizeof(bigint_word_t), byte_shift = scale % sizeof(bigint_word_t);
|
||||||
bigint_word_t bv[a->length_B + 1];
|
bigint_word_t bv[a->length_W + 1];
|
||||||
s.wordv = bv;
|
s.wordv = bv;
|
||||||
bv[0] = bv[a->length_B] = 0;
|
bv[0] = bv[a->length_W] = 0;
|
||||||
memcpy((uint8_t*)bv + byte_shift, a->wordv, a->length_B * sizeof(bigint_word_t));
|
memcpy((uint8_t*)bv + byte_shift, a->wordv, a->length_W * sizeof(bigint_word_t));
|
||||||
s.length_B = a->length_B + 1;
|
s.length_W = a->length_W + 1;
|
||||||
bigint_adjust(&s);
|
bigint_adjust(&s);
|
||||||
memset(dest->wordv + dest->length_B, 0, (MAX(dest->length_B, s.length_B + word_shift) - dest->length_B) * sizeof(bigint_word_t));
|
memset(dest->wordv + dest->length_W, 0, (MAX(dest->length_W, s.length_W + word_shift) - dest->length_W) * sizeof(bigint_word_t));
|
||||||
x.wordv = dest->wordv + word_shift;
|
x.wordv = dest->wordv + word_shift;
|
||||||
x.length_B = dest->length_B - word_shift;
|
x.length_W = dest->length_W - word_shift;
|
||||||
if((int16_t)x.length_B < 0){
|
if((int16_t)x.length_W < 0){
|
||||||
x.length_B = 0;
|
x.length_W = 0;
|
||||||
x.info = 0;
|
x.info = 0;
|
||||||
}else{
|
}else{
|
||||||
x.info = dest->info;
|
x.info = dest->info;
|
||||||
}
|
}
|
||||||
bigint_add_u(&x, &x, &s);
|
bigint_add_u(&x, &x, &s);
|
||||||
dest->length_B = x.length_B + word_shift;
|
dest->length_W = x.length_W + word_shift;
|
||||||
dest->info = 0;
|
dest->info = 0;
|
||||||
bigint_adjust(dest);
|
bigint_adjust(dest);
|
||||||
#endif
|
#endif
|
||||||
|
@ -217,29 +217,29 @@ void bigint_add_scale_u(bigint_t* dest, const bigint_t* a, uint16_t scale){
|
||||||
bigint_word_t *dst;
|
bigint_word_t *dst;
|
||||||
bigint_wordplus_t t=0;
|
bigint_wordplus_t t=0;
|
||||||
scale_w = (scale+sizeof(bigint_word_t)-1)/sizeof(bigint_word_t);
|
scale_w = (scale+sizeof(bigint_word_t)-1)/sizeof(bigint_word_t);
|
||||||
if(scale>dest->length_B*sizeof(bigint_word_t)){
|
if(scale>dest->length_W*sizeof(bigint_word_t)){
|
||||||
memset(((uint8_t*)dest->wordv)+dest->length_B*sizeof(bigint_word_t), 0, scale-dest->length_B*sizeof(bigint_word_t));
|
memset(((uint8_t*)dest->wordv)+dest->length_W*sizeof(bigint_word_t), 0, scale-dest->length_W*sizeof(bigint_word_t));
|
||||||
}
|
}
|
||||||
// a->wordv = (const uint32_t*)(((uint8_t*)a->wordv)+(scale&3));
|
// a->wordv = (const uint32_t*)(((uint8_t*)a->wordv)+(scale&3));
|
||||||
dst = dest->wordv + (scale&(sizeof(bigint_word_t)-1));
|
dst = dest->wordv + (scale&(sizeof(bigint_word_t)-1));
|
||||||
for(i=scale/sizeof(bigint_word_t); i<a->length_B+scale_w; ++i,++j){
|
for(i=scale/sizeof(bigint_word_t); i<a->length_W+scale_w; ++i,++j){
|
||||||
t += a->wordv[j];
|
t += a->wordv[j];
|
||||||
if(dest->length_B>i){
|
if(dest->length_W>i){
|
||||||
t += dst[i];
|
t += dst[i];
|
||||||
}
|
}
|
||||||
dst[i] = (bigint_word_t)t;
|
dst[i] = (bigint_word_t)t;
|
||||||
t>>=BIGINT_WORD_SIZE;
|
t>>=BIGINT_WORD_SIZE;
|
||||||
}
|
}
|
||||||
while(t){
|
while(t){
|
||||||
if(dest->length_B>i){
|
if(dest->length_W>i){
|
||||||
t += dst[i];
|
t += dst[i];
|
||||||
}
|
}
|
||||||
dst[i] = (bigint_word_t)t;
|
dst[i] = (bigint_word_t)t;
|
||||||
t>>=BIGINT_WORD_SIZE;
|
t>>=BIGINT_WORD_SIZE;
|
||||||
++i;
|
++i;
|
||||||
}
|
}
|
||||||
if(dest->length_B < i){
|
if(dest->length_W < i){
|
||||||
dest->length_B = i;
|
dest->length_W = i;
|
||||||
}
|
}
|
||||||
bigint_adjust(dest);
|
bigint_adjust(dest);
|
||||||
*/
|
*/
|
||||||
|
@ -253,19 +253,19 @@ void bigint_sub_u(bigint_t* dest, const bigint_t* a, const bigint_t* b){
|
||||||
int8_t r;
|
int8_t r;
|
||||||
bigint_wordplus_signed_t t=0LL;
|
bigint_wordplus_signed_t t=0LL;
|
||||||
uint16_t i, min, max;
|
uint16_t i, min, max;
|
||||||
min = MIN(a->length_B, b->length_B);
|
min = MIN(a->length_W, b->length_W);
|
||||||
max = MAX(a->length_B, b->length_B);
|
max = MAX(a->length_W, b->length_W);
|
||||||
r = bigint_cmp_u(a,b);
|
r = bigint_cmp_u(a,b);
|
||||||
if(r==0){
|
if(r==0){
|
||||||
bigint_set_zero(dest);
|
bigint_set_zero(dest);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if(b->length_B==0){
|
if(b->length_W==0){
|
||||||
bigint_copy(dest, a);
|
bigint_copy(dest, a);
|
||||||
SET_POS(dest);
|
SET_POS(dest);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if(a->length_B==0){
|
if(a->length_W==0){
|
||||||
bigint_copy(dest, b);
|
bigint_copy(dest, b);
|
||||||
SET_NEG(dest);
|
SET_NEG(dest);
|
||||||
return;
|
return;
|
||||||
|
@ -289,24 +289,24 @@ void bigint_sub_u(bigint_t* dest, const bigint_t* a, const bigint_t* b){
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
SET_POS(dest);
|
SET_POS(dest);
|
||||||
dest->length_B = i;
|
dest->length_W = i;
|
||||||
bigint_adjust(dest);
|
bigint_adjust(dest);
|
||||||
}
|
}
|
||||||
|
|
||||||
/******************************************************************************/
|
/******************************************************************************/
|
||||||
|
|
||||||
int8_t bigint_cmp_u(const bigint_t* a, const bigint_t* b){
|
int8_t bigint_cmp_u(const bigint_t* a, const bigint_t* b){
|
||||||
if(a->length_B > b->length_B){
|
if(a->length_W > b->length_W){
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
if(a->length_B < b->length_B){
|
if(a->length_W < b->length_W){
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
if(a->length_B==0){
|
if(a->length_W==0){
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
uint16_t i;
|
uint16_t i;
|
||||||
i = a->length_B-1;
|
i = a->length_W-1;
|
||||||
do{
|
do{
|
||||||
if(a->wordv[i] != b->wordv[i]){
|
if(a->wordv[i] != b->wordv[i]){
|
||||||
if(a->wordv[i] > b->wordv[i]){
|
if(a->wordv[i] > b->wordv[i]){
|
||||||
|
@ -376,7 +376,7 @@ void bigint_sub_s(bigint_t* dest, const bigint_t* a, const bigint_t* b){
|
||||||
|
|
||||||
int8_t bigint_cmp_s(const bigint_t* a, const bigint_t* b){
|
int8_t bigint_cmp_s(const bigint_t* a, const bigint_t* b){
|
||||||
uint8_t s;
|
uint8_t s;
|
||||||
if(a->length_B==0 && b->length_B==0){
|
if(a->length_W==0 && b->length_W==0){
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
s = GET_SIGN(a)?2:0;
|
s = GET_SIGN(a)?2:0;
|
||||||
|
@ -414,15 +414,15 @@ void bigint_shiftleft(bigint_t* a, uint16_t shift){
|
||||||
byteshift = shift/8;
|
byteshift = shift/8;
|
||||||
bitshift = shift&7;
|
bitshift = shift&7;
|
||||||
for(i=0;i<=byteshift/sizeof(bigint_word_t); ++i){
|
for(i=0;i<=byteshift/sizeof(bigint_word_t); ++i){
|
||||||
a->wordv[a->length_B+i] = 0;
|
a->wordv[a->length_W+i] = 0;
|
||||||
}
|
}
|
||||||
if(byteshift){
|
if(byteshift){
|
||||||
memmove(((uint8_t*)a->wordv) + byteshift, a->wordv, a->length_B * sizeof(bigint_word_t));
|
memmove(((uint8_t*)a->wordv) + byteshift, a->wordv, a->length_W * sizeof(bigint_word_t));
|
||||||
memset(a->wordv, 0, byteshift);
|
memset(a->wordv, 0, byteshift);
|
||||||
}
|
}
|
||||||
p = a->wordv + byteshift / sizeof(bigint_word_t);
|
p = a->wordv + byteshift / sizeof(bigint_word_t);
|
||||||
words_to_shift = a->length_B + (byteshift % sizeof(bigint_word_t)?1:0);
|
words_to_shift = a->length_W + (byteshift % sizeof(bigint_word_t)?1:0);
|
||||||
word_alloc = a->length_B + (byteshift + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t) + 1;
|
word_alloc = a->length_W + (byteshift + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t) + 1;
|
||||||
a->wordv[word_alloc-1]=0;
|
a->wordv[word_alloc-1]=0;
|
||||||
if(bitshift!=0){
|
if(bitshift!=0){
|
||||||
for(i=0; i < words_to_shift; ++i){
|
for(i=0; i < words_to_shift; ++i){
|
||||||
|
@ -432,7 +432,7 @@ void bigint_shiftleft(bigint_t* a, uint16_t shift){
|
||||||
}
|
}
|
||||||
p[i] = (bigint_word_t)t;
|
p[i] = (bigint_word_t)t;
|
||||||
}
|
}
|
||||||
a->length_B = word_alloc;
|
a->length_W = word_alloc;
|
||||||
bigint_adjust(a);
|
bigint_adjust(a);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -445,23 +445,23 @@ void bigint_shiftright(bigint_t* a, uint16_t shift){
|
||||||
bigint_wordplus_t t=0;
|
bigint_wordplus_t t=0;
|
||||||
byteshift = shift/8;
|
byteshift = shift/8;
|
||||||
bitshift = shift&7;
|
bitshift = shift&7;
|
||||||
if(byteshift >= a->length_B * sizeof(bigint_word_t)){ /* we would shift out more than we have */
|
if(byteshift >= a->length_W * sizeof(bigint_word_t)){ /* we would shift out more than we have */
|
||||||
bigint_set_zero(a);
|
bigint_set_zero(a);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if(byteshift == a->length_B * sizeof(bigint_word_t) - 1 && bitshift > GET_FBS(a)){
|
if(byteshift == a->length_W * sizeof(bigint_word_t) - 1 && bitshift > GET_FBS(a)){
|
||||||
bigint_set_zero(a);
|
bigint_set_zero(a);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if(byteshift){
|
if(byteshift){
|
||||||
memmove(a->wordv, (uint8_t*)a->wordv + byteshift, a->length_B * sizeof(bigint_word_t) - byteshift);
|
memmove(a->wordv, (uint8_t*)a->wordv + byteshift, a->length_W * sizeof(bigint_word_t) - byteshift);
|
||||||
memset((uint8_t*)a->wordv + a->length_B * sizeof(bigint_word_t) - byteshift, 0, byteshift);
|
memset((uint8_t*)a->wordv + a->length_W * sizeof(bigint_word_t) - byteshift, 0, byteshift);
|
||||||
}
|
}
|
||||||
byteshift /= sizeof(bigint_word_t);
|
byteshift /= sizeof(bigint_word_t);
|
||||||
a->length_B -= (byteshift + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
|
a->length_W -= (byteshift + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
|
||||||
if(bitshift != 0 && a->length_B){
|
if(bitshift != 0 && a->length_W){
|
||||||
/* shift to the right */
|
/* shift to the right */
|
||||||
i = a->length_B - 1;
|
i = a->length_W - 1;
|
||||||
do{
|
do{
|
||||||
t |= ((bigint_wordplus_t)(a->wordv[i])) << (BIGINT_WORD_SIZE - bitshift);
|
t |= ((bigint_wordplus_t)(a->wordv[i])) << (BIGINT_WORD_SIZE - bitshift);
|
||||||
a->wordv[i] = (bigint_word_t)(t >> BIGINT_WORD_SIZE);
|
a->wordv[i] = (bigint_word_t)(t >> BIGINT_WORD_SIZE);
|
||||||
|
@ -475,7 +475,7 @@ void bigint_shiftright(bigint_t* a, uint16_t shift){
|
||||||
|
|
||||||
void bigint_xor(bigint_t* dest, const bigint_t* a){
|
void bigint_xor(bigint_t* dest, const bigint_t* a){
|
||||||
uint16_t i;
|
uint16_t i;
|
||||||
for(i=0; i<a->length_B; ++i){
|
for(i=0; i<a->length_W; ++i){
|
||||||
dest->wordv[i] ^= a->wordv[i];
|
dest->wordv[i] ^= a->wordv[i];
|
||||||
}
|
}
|
||||||
bigint_adjust(dest);
|
bigint_adjust(dest);
|
||||||
|
@ -484,7 +484,7 @@ void bigint_xor(bigint_t* dest, const bigint_t* a){
|
||||||
/******************************************************************************/
|
/******************************************************************************/
|
||||||
|
|
||||||
void bigint_set_zero(bigint_t* a){
|
void bigint_set_zero(bigint_t* a){
|
||||||
a->length_B=0;
|
a->length_W=0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/******************************************************************************/
|
/******************************************************************************/
|
||||||
|
@ -492,74 +492,74 @@ void bigint_set_zero(bigint_t* a){
|
||||||
/* using the Karatsuba-Algorithm */
|
/* using the Karatsuba-Algorithm */
|
||||||
/* x*y = (xh*yh)*b**2n + ((xh+xl)*(yh+yl) - xh*yh - xl*yl)*b**n + yh*yl */
|
/* x*y = (xh*yh)*b**2n + ((xh+xl)*(yh+yl) - xh*yh - xl*yl)*b**n + yh*yl */
|
||||||
void bigint_mul_u(bigint_t* dest, const bigint_t* a, const bigint_t* b){
|
void bigint_mul_u(bigint_t* dest, const bigint_t* a, const bigint_t* b){
|
||||||
if(a->length_B==0 || b->length_B==0){
|
if(a->length_W==0 || b->length_W==0){
|
||||||
bigint_set_zero(dest);
|
bigint_set_zero(dest);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if(dest==a || dest==b){
|
if(dest==a || dest==b){
|
||||||
bigint_t d;
|
bigint_t d;
|
||||||
bigint_word_t d_b[a->length_B+b->length_B];
|
bigint_word_t d_b[a->length_W+b->length_W];
|
||||||
d.wordv = d_b;
|
d.wordv = d_b;
|
||||||
bigint_mul_u(&d, a, b);
|
bigint_mul_u(&d, a, b);
|
||||||
bigint_copy(dest, &d);
|
bigint_copy(dest, &d);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if(a->length_B==1 || b->length_B==1){
|
if(a->length_W==1 || b->length_W==1){
|
||||||
if(a->length_B!=1){
|
if(a->length_W!=1){
|
||||||
XCHG_PTR(a,b);
|
XCHG_PTR(a,b);
|
||||||
}
|
}
|
||||||
bigint_wordplus_t t=0;
|
bigint_wordplus_t t=0;
|
||||||
uint16_t i;
|
uint16_t i;
|
||||||
bigint_word_t x = a->wordv[0];
|
bigint_word_t x = a->wordv[0];
|
||||||
for(i=0; i < b->length_B; ++i){
|
for(i=0; i < b->length_W; ++i){
|
||||||
t += ((bigint_wordplus_t)b->wordv[i])*((bigint_wordplus_t)x);
|
t += ((bigint_wordplus_t)b->wordv[i])*((bigint_wordplus_t)x);
|
||||||
dest->wordv[i] = (bigint_word_t)t;
|
dest->wordv[i] = (bigint_word_t)t;
|
||||||
t>>=BIGINT_WORD_SIZE;
|
t>>=BIGINT_WORD_SIZE;
|
||||||
}
|
}
|
||||||
dest->wordv[i] = (bigint_word_t)t;
|
dest->wordv[i] = (bigint_word_t)t;
|
||||||
dest->length_B = i+1;
|
dest->length_W = i+1;
|
||||||
dest->info = 0;
|
dest->info = 0;
|
||||||
bigint_adjust(dest);
|
bigint_adjust(dest);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if(a->length_B * sizeof(bigint_word_t) <= 4 && b->length_B * sizeof(bigint_word_t) <= 4){
|
if(a->length_W * sizeof(bigint_word_t) <= 4 && b->length_W * sizeof(bigint_word_t) <= 4){
|
||||||
uint32_t p=0, q=0;
|
uint32_t p=0, q=0;
|
||||||
uint64_t r;
|
uint64_t r;
|
||||||
memcpy(&p, a->wordv, a->length_B*sizeof(bigint_word_t));
|
memcpy(&p, a->wordv, a->length_W*sizeof(bigint_word_t));
|
||||||
memcpy(&q, b->wordv, b->length_B*sizeof(bigint_word_t));
|
memcpy(&q, b->wordv, b->length_W*sizeof(bigint_word_t));
|
||||||
r = (uint64_t)p * (uint64_t)q;
|
r = (uint64_t)p * (uint64_t)q;
|
||||||
memcpy(dest->wordv, &r, (dest->length_B = a->length_B + b->length_B)*sizeof(bigint_word_t));
|
memcpy(dest->wordv, &r, (dest->length_W = a->length_W + b->length_W)*sizeof(bigint_word_t));
|
||||||
bigint_adjust(dest);
|
bigint_adjust(dest);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
bigint_set_zero(dest);
|
bigint_set_zero(dest);
|
||||||
/* split a in xh & xl; split b in yh & yl */
|
/* split a in xh & xl; split b in yh & yl */
|
||||||
const uint16_t n = (MAX(a->length_B, b->length_B)+1)/2;
|
const uint16_t n = (MAX(a->length_W, b->length_W)+1)/2;
|
||||||
bigint_t xl, xh, yl, yh;
|
bigint_t xl, xh, yl, yh;
|
||||||
xl.wordv = a->wordv;
|
xl.wordv = a->wordv;
|
||||||
yl.wordv = b->wordv;
|
yl.wordv = b->wordv;
|
||||||
if(a->length_B<=n){
|
if(a->length_W<=n){
|
||||||
bigint_set_zero(&xh);
|
bigint_set_zero(&xh);
|
||||||
xl.length_B = a->length_B;
|
xl.length_W = a->length_W;
|
||||||
xl.info = a->info;
|
xl.info = a->info;
|
||||||
}else{
|
}else{
|
||||||
xl.length_B=n;
|
xl.length_W=n;
|
||||||
xl.info = 0;
|
xl.info = 0;
|
||||||
bigint_adjust(&xl);
|
bigint_adjust(&xl);
|
||||||
xh.wordv = &(a->wordv[n]);
|
xh.wordv = &(a->wordv[n]);
|
||||||
xh.length_B = a->length_B-n;
|
xh.length_W = a->length_W-n;
|
||||||
xh.info = a->info;
|
xh.info = a->info;
|
||||||
}
|
}
|
||||||
if(b->length_B<=n){
|
if(b->length_W<=n){
|
||||||
bigint_set_zero(&yh);
|
bigint_set_zero(&yh);
|
||||||
yl.length_B = b->length_B;
|
yl.length_W = b->length_W;
|
||||||
yl.info = b->info;
|
yl.info = b->info;
|
||||||
}else{
|
}else{
|
||||||
yl.length_B=n;
|
yl.length_W=n;
|
||||||
yl.info = 0;
|
yl.info = 0;
|
||||||
bigint_adjust(&yl);
|
bigint_adjust(&yl);
|
||||||
yh.wordv = &(b->wordv[n]);
|
yh.wordv = &(b->wordv[n]);
|
||||||
yh.length_B = b->length_B-n;
|
yh.length_W = b->length_W-n;
|
||||||
yh.info = b->info;
|
yh.info = b->info;
|
||||||
}
|
}
|
||||||
/* now we have split up a and b */
|
/* now we have split up a and b */
|
||||||
|
@ -617,33 +617,33 @@ void bigint_mul_s(bigint_t* dest, const bigint_t* a, const bigint_t* b){
|
||||||
/* square */
|
/* square */
|
||||||
/* (xh*b^n+xl)^2 = xh^2*b^2n + 2*xh*xl*b^n + xl^2 */
|
/* (xh*b^n+xl)^2 = xh^2*b^2n + 2*xh*xl*b^n + xl^2 */
|
||||||
void bigint_square(bigint_t* dest, const bigint_t* a){
|
void bigint_square(bigint_t* dest, const bigint_t* a){
|
||||||
if(a->length_B*sizeof(bigint_word_t)<=4){
|
if(a->length_W*sizeof(bigint_word_t)<=4){
|
||||||
uint64_t r=0;
|
uint64_t r=0;
|
||||||
memcpy(&r, a->wordv, a->length_B*sizeof(bigint_word_t));
|
memcpy(&r, a->wordv, a->length_W*sizeof(bigint_word_t));
|
||||||
r = r*r;
|
r = r*r;
|
||||||
memcpy(dest->wordv, &r, 2*a->length_B*sizeof(bigint_word_t));
|
memcpy(dest->wordv, &r, 2*a->length_W*sizeof(bigint_word_t));
|
||||||
SET_POS(dest);
|
SET_POS(dest);
|
||||||
dest->length_B=2*a->length_B;
|
dest->length_W=2*a->length_W;
|
||||||
bigint_adjust(dest);
|
bigint_adjust(dest);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if(dest==a){
|
if(dest==a){
|
||||||
bigint_t d;
|
bigint_t d;
|
||||||
bigint_word_t d_b[a->length_B*2];
|
bigint_word_t d_b[a->length_W*2];
|
||||||
d.wordv = d_b;
|
d.wordv = d_b;
|
||||||
bigint_square(&d, a);
|
bigint_square(&d, a);
|
||||||
bigint_copy(dest, &d);
|
bigint_copy(dest, &d);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
uint16_t n;
|
uint16_t n;
|
||||||
n=(a->length_B+1)/2;
|
n=(a->length_W+1)/2;
|
||||||
bigint_t xh, xl, tmp; /* x-high, x-low, temp */
|
bigint_t xh, xl, tmp; /* x-high, x-low, temp */
|
||||||
bigint_word_t buffer[2*n+1];
|
bigint_word_t buffer[2*n+1];
|
||||||
xl.wordv = a->wordv;
|
xl.wordv = a->wordv;
|
||||||
xl.length_B = n;
|
xl.length_W = n;
|
||||||
xl.info = 0;
|
xl.info = 0;
|
||||||
xh.wordv = &(a->wordv[n]);
|
xh.wordv = &(a->wordv[n]);
|
||||||
xh.length_B = a->length_B-n;
|
xh.length_W = a->length_W-n;
|
||||||
xh.info = 0;
|
xh.info = 0;
|
||||||
bigint_adjust(&xl);
|
bigint_adjust(&xl);
|
||||||
bigint_adjust(&xh);
|
bigint_adjust(&xh);
|
||||||
|
@ -670,10 +670,10 @@ void bigint_square(bigint_t* dest, const bigint_t* a){
|
||||||
/******************************************************************************/
|
/******************************************************************************/
|
||||||
void bigint_sub_u_bitscale(bigint_t* a, const bigint_t* b, uint16_t bitscale){
|
void bigint_sub_u_bitscale(bigint_t* a, const bigint_t* b, uint16_t bitscale){
|
||||||
bigint_t tmp, x;
|
bigint_t tmp, x;
|
||||||
bigint_word_t tmp_b[b->length_B + 1];
|
bigint_word_t tmp_b[b->length_W + 1];
|
||||||
const uint16_t word_shift = bitscale / BIGINT_WORD_SIZE;
|
const uint16_t word_shift = bitscale / BIGINT_WORD_SIZE;
|
||||||
|
|
||||||
if(a->length_B < b->length_B + word_shift){
|
if(a->length_W < b->length_W + word_shift){
|
||||||
#if DEBUG
|
#if DEBUG
|
||||||
cli_putstr("\r\nDBG: *bang*\r\n");
|
cli_putstr("\r\nDBG: *bang*\r\n");
|
||||||
#endif
|
#endif
|
||||||
|
@ -686,7 +686,7 @@ void bigint_sub_u_bitscale(bigint_t* a, const bigint_t* b, uint16_t bitscale){
|
||||||
|
|
||||||
x.info = a->info;
|
x.info = a->info;
|
||||||
x.wordv = &(a->wordv[word_shift]);
|
x.wordv = &(a->wordv[word_shift]);
|
||||||
x.length_B = a->length_B - word_shift;
|
x.length_W = a->length_W - word_shift;
|
||||||
|
|
||||||
bigint_sub_u(&x, &x, &tmp);
|
bigint_sub_u(&x, &x, &tmp);
|
||||||
bigint_adjust(a);
|
bigint_adjust(a);
|
||||||
|
@ -701,40 +701,40 @@ void bigint_reduce(bigint_t* a, const bigint_t* r){
|
||||||
#if DEBUG
|
#if DEBUG
|
||||||
cli_putstr("\r\nDBG: (a) = "); bigint_print_hex(a);
|
cli_putstr("\r\nDBG: (a) = "); bigint_print_hex(a);
|
||||||
#endif
|
#endif
|
||||||
if(r->length_B==0 || a->length_B==0){
|
if(r->length_W==0 || a->length_W==0){
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if((r->length_B*sizeof(bigint_word_t)<=4) && (a->length_B*sizeof(bigint_word_t)<=4)){
|
if((r->length_W*sizeof(bigint_word_t)<=4) && (a->length_W*sizeof(bigint_word_t)<=4)){
|
||||||
uint32_t p=0, q=0;
|
uint32_t p=0, q=0;
|
||||||
memcpy(&p, a->wordv, a->length_B*sizeof(bigint_word_t));
|
memcpy(&p, a->wordv, a->length_W*sizeof(bigint_word_t));
|
||||||
memcpy(&q, r->wordv, r->length_B*sizeof(bigint_word_t));
|
memcpy(&q, r->wordv, r->length_W*sizeof(bigint_word_t));
|
||||||
p %= q;
|
p %= q;
|
||||||
memcpy(a->wordv, &p, a->length_B*sizeof(bigint_word_t));
|
memcpy(a->wordv, &p, a->length_W*sizeof(bigint_word_t));
|
||||||
bigint_adjust(a);
|
bigint_adjust(a);
|
||||||
// cli_putstr("\r\nDBG: (0) = "); bigint_print_hex(a);
|
// cli_putstr("\r\nDBG: (0) = "); bigint_print_hex(a);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
uint16_t shift;
|
uint16_t shift;
|
||||||
while(a->length_B > r->length_B){
|
while(a->length_W > r->length_W){
|
||||||
shift = (a->length_B - r->length_B) * 8 * sizeof(bigint_word_t) + GET_FBS(a) - rfbs - 1;
|
shift = (a->length_W - r->length_W) * 8 * sizeof(bigint_word_t) + GET_FBS(a) - rfbs - 1;
|
||||||
/*
|
/*
|
||||||
if((a->wordv[a->length_B-1] & ((1LL<<GET_FBS(a)) - 1)) > r->wordv[r->length_B-1]){
|
if((a->wordv[a->length_W-1] & ((1LL<<GET_FBS(a)) - 1)) > r->wordv[r->length_W-1]){
|
||||||
// cli_putc('~');
|
// cli_putc('~');
|
||||||
cli_putstr("\r\n ~ [a] = ");
|
cli_putstr("\r\n ~ [a] = ");
|
||||||
cli_hexdump_rev(&a->wordv[a->length_B-1], 4);
|
cli_hexdump_rev(&a->wordv[a->length_W-1], 4);
|
||||||
cli_putstr(" [r] = ");
|
cli_putstr(" [r] = ");
|
||||||
cli_hexdump_rev(&r->wordv[r->length_B-1], 4);
|
cli_hexdump_rev(&r->wordv[r->length_W-1], 4);
|
||||||
shift += 1;
|
shift += 1;
|
||||||
}
|
}
|
||||||
*/
|
*/
|
||||||
// cli_putstr("\r\nDBG: (p) shift = "); cli_hexdump_rev(&shift, 2);
|
// cli_putstr("\r\nDBG: (p) shift = "); cli_hexdump_rev(&shift, 2);
|
||||||
// cli_putstr(" a_len = "); cli_hexdump_rev(&a->length_B, 2);
|
// cli_putstr(" a_len = "); cli_hexdump_rev(&a->length_W, 2);
|
||||||
// cli_putstr(" r_len = "); cli_hexdump_rev(&r->length_B, 2);
|
// cli_putstr(" r_len = "); cli_hexdump_rev(&r->length_W, 2);
|
||||||
// uart_flush(0);
|
// uart_flush(0);
|
||||||
bigint_sub_u_bitscale(a, r, shift);
|
bigint_sub_u_bitscale(a, r, shift);
|
||||||
// cli_putstr("\r\nDBG: (1) = "); bigint_print_hex(a);
|
// cli_putstr("\r\nDBG: (1) = "); bigint_print_hex(a);
|
||||||
}
|
}
|
||||||
while((GET_FBS(a) > rfbs) && (a->length_B == r->length_B)){
|
while((GET_FBS(a) > rfbs) && (a->length_W == r->length_W)){
|
||||||
shift = GET_FBS(a)-rfbs-1;
|
shift = GET_FBS(a)-rfbs-1;
|
||||||
// cli_putstr("\r\nDBG: (q) shift = "); cli_hexdump_rev(&shift, 2);
|
// cli_putstr("\r\nDBG: (q) shift = "); cli_hexdump_rev(&shift, 2);
|
||||||
bigint_sub_u_bitscale(a, r, shift);
|
bigint_sub_u_bitscale(a, r, shift);
|
||||||
|
@ -754,12 +754,12 @@ void bigint_reduce(bigint_t* a, const bigint_t* r){
|
||||||
/* calculate dest = a**exp % r */
|
/* calculate dest = a**exp % r */
|
||||||
/* using square&multiply */
|
/* using square&multiply */
|
||||||
void bigint_expmod_u(bigint_t* dest, const bigint_t* a, const bigint_t* exp, const bigint_t* r){
|
void bigint_expmod_u(bigint_t* dest, const bigint_t* a, const bigint_t* exp, const bigint_t* r){
|
||||||
if(a->length_B==0 || r->length_B==0){
|
if(a->length_W==0 || r->length_W==0){
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
bigint_t res, base;
|
bigint_t res, base;
|
||||||
bigint_word_t t, base_b[MAX(a->length_B,r->length_B)], res_b[r->length_B*2];
|
bigint_word_t t, base_b[MAX(a->length_W,r->length_W)], res_b[r->length_W*2];
|
||||||
uint16_t i;
|
uint16_t i;
|
||||||
uint8_t j;
|
uint8_t j;
|
||||||
// uint16_t *xaddr = &i;
|
// uint16_t *xaddr = &i;
|
||||||
|
@ -772,16 +772,16 @@ void bigint_expmod_u(bigint_t* dest, const bigint_t* a, const bigint_t* exp, con
|
||||||
// cli_putstr("\r\npost-copy");
|
// cli_putstr("\r\npost-copy");
|
||||||
bigint_reduce(&base, r);
|
bigint_reduce(&base, r);
|
||||||
res.wordv[0]=1;
|
res.wordv[0]=1;
|
||||||
res.length_B=1;
|
res.length_W=1;
|
||||||
res.info = 0;
|
res.info = 0;
|
||||||
bigint_adjust(&res);
|
bigint_adjust(&res);
|
||||||
if(exp->length_B == 0){
|
if(exp->length_W == 0){
|
||||||
bigint_copy(dest, &res);
|
bigint_copy(dest, &res);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
uint8_t flag = 0;
|
uint8_t flag = 0;
|
||||||
t=exp->wordv[exp->length_B - 1];
|
t=exp->wordv[exp->length_W - 1];
|
||||||
for(i=exp->length_B; i > 0; --i){
|
for(i=exp->length_W; i > 0; --i){
|
||||||
t = exp->wordv[i - 1];
|
t = exp->wordv[i - 1];
|
||||||
for(j=BIGINT_WORD_SIZE; j > 0; --j){
|
for(j=BIGINT_WORD_SIZE; j > 0; --j){
|
||||||
if(!flag){
|
if(!flag){
|
||||||
|
@ -817,14 +817,14 @@ void bigint_expmod_u(bigint_t* dest, const bigint_t* a, const bigint_t* exp, con
|
||||||
void bigint_gcdext(bigint_t* gcd, bigint_t* a, bigint_t* b, const bigint_t* x, const bigint_t* y){
|
void bigint_gcdext(bigint_t* gcd, bigint_t* a, bigint_t* b, const bigint_t* x, const bigint_t* y){
|
||||||
bigint_t g, x_, y_, u, v, a_, b_, c_, d_;
|
bigint_t g, x_, y_, u, v, a_, b_, c_, d_;
|
||||||
uint16_t i=0;
|
uint16_t i=0;
|
||||||
if(x->length_B==0 || y->length_B==0){
|
if(x->length_W==0 || y->length_W==0){
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if(x->length_B==1 && x->wordv[0]==1){
|
if(x->length_W==1 && x->wordv[0]==1){
|
||||||
gcd->length_B = 1;
|
gcd->length_W = 1;
|
||||||
gcd->wordv[0] = 1;
|
gcd->wordv[0] = 1;
|
||||||
if(a){
|
if(a){
|
||||||
a->length_B = 1;
|
a->length_W = 1;
|
||||||
a->wordv[0] = 1;
|
a->wordv[0] = 1;
|
||||||
SET_POS(a);
|
SET_POS(a);
|
||||||
bigint_adjust(a);
|
bigint_adjust(a);
|
||||||
|
@ -834,11 +834,11 @@ void bigint_gcdext(bigint_t* gcd, bigint_t* a, bigint_t* b, const bigint_t* x, c
|
||||||
}
|
}
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if(y->length_B==1 && y->wordv[0]==1){
|
if(y->length_W==1 && y->wordv[0]==1){
|
||||||
gcd->length_B = 1;
|
gcd->length_W = 1;
|
||||||
gcd->wordv[0] = 1;
|
gcd->wordv[0] = 1;
|
||||||
if(b){
|
if(b){
|
||||||
b->length_B = 1;
|
b->length_W = 1;
|
||||||
b->wordv[0] = 1;
|
b->wordv[0] = 1;
|
||||||
SET_POS(b);
|
SET_POS(b);
|
||||||
bigint_adjust(b);
|
bigint_adjust(b);
|
||||||
|
@ -852,23 +852,23 @@ void bigint_gcdext(bigint_t* gcd, bigint_t* a, bigint_t* b, const bigint_t* x, c
|
||||||
while(x->wordv[i]==0 && y->wordv[i]==0){
|
while(x->wordv[i]==0 && y->wordv[i]==0){
|
||||||
++i;
|
++i;
|
||||||
}
|
}
|
||||||
bigint_word_t g_b[i+2], x_b[x->length_B-i], y_b[y->length_B-i];
|
bigint_word_t g_b[i+2], x_b[x->length_W-i], y_b[y->length_W-i];
|
||||||
bigint_word_t u_b[x->length_B-i], v_b[y->length_B-i];
|
bigint_word_t u_b[x->length_W-i], v_b[y->length_W-i];
|
||||||
bigint_word_t a_b[y->length_B+2], c_b[y->length_B+2];
|
bigint_word_t a_b[y->length_W+2], c_b[y->length_W+2];
|
||||||
bigint_word_t b_b[x->length_B+2], d_b[x->length_B+2];
|
bigint_word_t b_b[x->length_W+2], d_b[x->length_W+2];
|
||||||
|
|
||||||
g.wordv = g_b;
|
g.wordv = g_b;
|
||||||
x_.wordv = x_b;
|
x_.wordv = x_b;
|
||||||
y_.wordv = y_b;
|
y_.wordv = y_b;
|
||||||
memset(g_b, 0, i*sizeof(bigint_word_t));
|
memset(g_b, 0, i*sizeof(bigint_word_t));
|
||||||
g_b[i]=1;
|
g_b[i]=1;
|
||||||
g.length_B = i+1;
|
g.length_W = i+1;
|
||||||
g.info=0;
|
g.info=0;
|
||||||
x_.info = y_.info = 0;
|
x_.info = y_.info = 0;
|
||||||
x_.length_B = x->length_B-i;
|
x_.length_W = x->length_W-i;
|
||||||
y_.length_B = y->length_B-i;
|
y_.length_W = y->length_W-i;
|
||||||
memcpy(x_.wordv, x->wordv+i, x_.length_B*sizeof(bigint_word_t));
|
memcpy(x_.wordv, x->wordv+i, x_.length_W*sizeof(bigint_word_t));
|
||||||
memcpy(y_.wordv, y->wordv+i, y_.length_B*sizeof(bigint_word_t));
|
memcpy(y_.wordv, y->wordv+i, y_.length_W*sizeof(bigint_word_t));
|
||||||
for(i=0; (x_.wordv[0]&(1<<i))==0 && (y_.wordv[0]&(1<<i))==0; ++i){
|
for(i=0; (x_.wordv[0]&(1<<i))==0 && (y_.wordv[0]&(1<<i))==0; ++i){
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -891,10 +891,10 @@ void bigint_gcdext(bigint_t* gcd, bigint_t* a, bigint_t* b, const bigint_t* x, c
|
||||||
bigint_copy(&u, &x_);
|
bigint_copy(&u, &x_);
|
||||||
bigint_copy(&v, &y_);
|
bigint_copy(&v, &y_);
|
||||||
a_.wordv[0] = 1;
|
a_.wordv[0] = 1;
|
||||||
a_.length_B = 1;
|
a_.length_W = 1;
|
||||||
a_.info = 0;
|
a_.info = 0;
|
||||||
d_.wordv[0] = 1;
|
d_.wordv[0] = 1;
|
||||||
d_.length_B = 1;
|
d_.length_W = 1;
|
||||||
d_.info = 0;
|
d_.info = 0;
|
||||||
bigint_set_zero(&b_);
|
bigint_set_zero(&b_);
|
||||||
bigint_set_zero(&c_);
|
bigint_set_zero(&c_);
|
||||||
|
@ -930,7 +930,7 @@ void bigint_gcdext(bigint_t* gcd, bigint_t* a, bigint_t* b, const bigint_t* x, c
|
||||||
bigint_sub_s(&c_, &c_, &a_);
|
bigint_sub_s(&c_, &c_, &a_);
|
||||||
bigint_sub_s(&d_, &d_, &b_);
|
bigint_sub_s(&d_, &d_, &b_);
|
||||||
}
|
}
|
||||||
}while(u.length_B);
|
}while(u.length_W);
|
||||||
if(gcd){
|
if(gcd){
|
||||||
bigint_mul_s(gcd, &v, &g);
|
bigint_mul_s(gcd, &v, &g);
|
||||||
}
|
}
|
||||||
|
@ -956,7 +956,7 @@ void bigint_inverse(bigint_t* dest, const bigint_t* a, const bigint_t* m){
|
||||||
void bigint_changeendianess(bigint_t* a){
|
void bigint_changeendianess(bigint_t* a){
|
||||||
uint8_t t, *p, *q;
|
uint8_t t, *p, *q;
|
||||||
p = (uint8_t*)(a->wordv);
|
p = (uint8_t*)(a->wordv);
|
||||||
q = p + a->length_B * sizeof(bigint_word_t) - 1;
|
q = p + a->length_W * sizeof(bigint_word_t) - 1;
|
||||||
while(p<q){
|
while(p<q){
|
||||||
t = *p;
|
t = *p;
|
||||||
*p = *q;
|
*p = *q;
|
||||||
|
|
|
@ -38,7 +38,7 @@ typedef int64_t bigint_wordplus_signed_t;
|
||||||
#define BIGINT_FBS_MASK (BIGINT_WORD_SIZE-1) /* the last five bits indicate which is the first bit set */
|
#define BIGINT_FBS_MASK (BIGINT_WORD_SIZE-1) /* the last five bits indicate which is the first bit set */
|
||||||
#define BIGINT_NEG_MASK 0x80 /* this bit indicates a negative value */
|
#define BIGINT_NEG_MASK 0x80 /* this bit indicates a negative value */
|
||||||
typedef struct{
|
typedef struct{
|
||||||
uint16_t length_B;
|
uint16_t length_W;
|
||||||
uint8_t info;
|
uint8_t info;
|
||||||
bigint_word_t *wordv; /* word vector, pointing to the LSB */
|
bigint_word_t *wordv; /* word vector, pointing to the LSB */
|
||||||
}bigint_t;
|
}bigint_t;
|
||||||
|
|
|
@ -24,7 +24,7 @@
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
|
|
||||||
void bigint_print_hex(const bigint_t* a){
|
void bigint_print_hex(const bigint_t* a){
|
||||||
if(a->length_B==0){
|
if(a->length_W==0){
|
||||||
cli_putc('0');
|
cli_putc('0');
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
@ -32,18 +32,18 @@ void bigint_print_hex(const bigint_t* a){
|
||||||
cli_putc('-');
|
cli_putc('-');
|
||||||
}
|
}
|
||||||
// cli_putc((a->info&BIGINT_NEG_MASK)?'-':'+'); /* print sign */
|
// cli_putc((a->info&BIGINT_NEG_MASK)?'-':'+'); /* print sign */
|
||||||
/* if(a->wordv[a->length_B-1]<0x10){
|
/* if(a->wordv[a->length_W-1]<0x10){
|
||||||
cli_putc(hexdigit_tab_uc[a->wordv[a->length_B-1]]);
|
cli_putc(hexdigit_tab_uc[a->wordv[a->length_W-1]]);
|
||||||
cli_hexdump_rev(a->wordv, a->length_B-1);
|
cli_hexdump_rev(a->wordv, a->length_W-1);
|
||||||
} else {
|
} else {
|
||||||
*/
|
*/
|
||||||
// cli_hexdump_rev(a->wordv, a->length_B*sizeof(bigint_word_t));
|
// cli_hexdump_rev(a->wordv, a->length_W*sizeof(bigint_word_t));
|
||||||
// }
|
// }
|
||||||
uint32_t idx;
|
uint32_t idx;
|
||||||
uint8_t print_zero=0;
|
uint8_t print_zero=0;
|
||||||
uint8_t *p,x,y;
|
uint8_t *p,x,y;
|
||||||
p = (uint8_t*)&(a->wordv[a->length_B-1])+sizeof(bigint_word_t)-1;
|
p = (uint8_t*)&(a->wordv[a->length_W-1])+sizeof(bigint_word_t)-1;
|
||||||
for(idx = a->length_B * sizeof(bigint_word_t); idx > 0; --idx){
|
for(idx = a->length_W * sizeof(bigint_word_t); idx > 0; --idx){
|
||||||
x = *p >> 4;
|
x = *p >> 4;
|
||||||
y = *p & 0xf;
|
y = *p & 0xf;
|
||||||
if(x!=0 || print_zero!=0){
|
if(x!=0 || print_zero!=0){
|
||||||
|
@ -98,7 +98,7 @@ uint8_t bigint_read_hex_echo(bigint_t* a){
|
||||||
uint16_t allocated=0;
|
uint16_t allocated=0;
|
||||||
uint8_t shift4=0;
|
uint8_t shift4=0;
|
||||||
uint16_t t, idx = 0;
|
uint16_t t, idx = 0;
|
||||||
a->length_B = 0;
|
a->length_W = 0;
|
||||||
a->wordv = NULL;
|
a->wordv = NULL;
|
||||||
a->info = 0;
|
a->info = 0;
|
||||||
for(;;){
|
for(;;){
|
||||||
|
@ -140,7 +140,7 @@ uint8_t bigint_read_hex_echo(bigint_t* a){
|
||||||
/* we have to reverse the byte array */
|
/* we have to reverse the byte array */
|
||||||
uint8_t tmp;
|
uint8_t tmp;
|
||||||
uint8_t *p, *q;
|
uint8_t *p, *q;
|
||||||
a->length_B = (idx + sizeof(bigint_word_t)-1)/sizeof(bigint_word_t);
|
a->length_W = (idx + sizeof(bigint_word_t)-1)/sizeof(bigint_word_t);
|
||||||
p = (uint8_t*)(a->wordv);
|
p = (uint8_t*)(a->wordv);
|
||||||
q = (uint8_t*)a->wordv + idx - 1;
|
q = (uint8_t*)a->wordv + idx - 1;
|
||||||
while(q>p){
|
while(q>p){
|
||||||
|
|
Loading…
Reference in New Issue