/* bigint.c */
/*
- This file is part of the AVR-Crypto-Lib.
+ This file is part of the ARM-Crypto-Lib.
Copyright (C) 2008 Daniel Otte (daniel.otte@rub.de)
This program is free software: you can redistribute it and/or modify
/******************************************************************************/
+uint32_t bigint_get_first_set_bit(bigint_t* a){
+ if(a->length_B==0){
+ return (uint32_t)(-1);
+ }
+ return (a->length_B-1)*sizeof(bigint_word_t)*8+GET_FBS(a);
+}
+
+
+/******************************************************************************/
+
+uint32_t bigint_get_last_set_bit(bigint_t* a){
+ uint32_t r=0;
+ uint8_t b=0;
+ bigint_word_t x=1;
+ if(a->length_B==0){
+ return (uint32_t)(-1);
+ }
+ while(a->wordv[r]==0 && r<a->length_B){
+ ++r;
+ }
+ if(a->wordv[r] == 0){
+ return (uint32_t)(-1);
+ }
+ while((x&a->wordv[r])==0){
+ ++b;
+ x <<= 1;
+ }
+ return r*BIGINT_WORD_SIZE+b;
+}
+
+/******************************************************************************/
+
void bigint_copy(bigint_t* dest, const bigint_t* src){
memcpy(dest->wordv, src->wordv, src->length_B*sizeof(bigint_word_t));
dest->length_B = src->length_B;
t |= ((bigint_wordplus_t)(a->wordv[0]))<<(BIGINT_WORD_SIZE-bitshift);
a->wordv[0] = (bigint_word_t)(t>>BIGINT_WORD_SIZE);
}
- a->length_B -= ((shift/8)+sizeof(bigint_word_t)-1)/sizeof(bigint_word_t);
+ a->length_B -= ((shift/8)+sizeof(bigint_word_t)-1)/sizeof(bigint_word_t);
bigint_adjust(a);
}
}
/******************************************************************************/
-
-#define cli_putstr(a)
-#define bigint_print_hex(a)
-#define cli_hexdump_rev(a,b)
-#define uart_flush(a)
-
void bigint_sub_u_bitscale(bigint_t* a, const bigint_t* b, uint16_t bitscale){
bigint_t tmp;
bigint_word_t tmp_b[b->length_B+4];
tmp.wordv = tmp_b;
bigint_copy(&tmp, b);
bigint_shiftleft(&tmp, bitscale&(BIGINT_WORD_SIZE-1));
- cli_putstr("\r\nDBG(sub_ub.0) tmp_shift = "); bigint_print_hex(&tmp);
+// cli_putstr("\r\nDBG(sub_ub.0) tmp_shift = "); bigint_print_hex(&tmp);
for(j=0,i=word_shift; i<tmp.length_B+word_shift; ++i, ++j){
t = a->wordv[i];
t -= tmp.wordv[j];
/******************************************************************************/
void bigint_reduce(bigint_t* a, const bigint_t* r){
-// bigint_adjust(r);
+// bigint_adjust((bigint_t*)r);
uint8_t rfbs = GET_FBS(r);
- cli_putstr("\r\nDBG: (a) = "); bigint_print_hex(a);
+// cli_putstr("\r\nDBG: (a) = "); bigint_print_hex(a);
if(r->length_B==0 || a->length_B==0){
return;
}
p %= q;
memcpy(a->wordv, &p, a->length_B*sizeof(bigint_word_t));
bigint_adjust(a);
- cli_putstr("\r\nDBG: (0) = "); bigint_print_hex(a);
+// cli_putstr("\r\nDBG: (0) = "); bigint_print_hex(a);
return;
}
uint16_t shift;
while(a->length_B > r->length_B){
- shift = (a->length_B-r->length_B)*8*sizeof(bigint_word_t)+GET_FBS(a)-rfbs-1;
- cli_putstr("\r\nDBG: (p) shift = "); cli_hexdump_rev(&shift, 2);
- uart_flush(0);
+ shift = (a->length_B - r->length_B) * 8 * sizeof(bigint_word_t) + GET_FBS(a) - rfbs - 1;
+// cli_putstr("\r\nDBG: (p) shift = "); cli_hexdump_rev(&shift, 2);
+// cli_putstr(" a_len = "); cli_hexdump_rev(&a->length_B, 2);
+// cli_putstr(" r_len = "); cli_hexdump_rev(&r->length_B, 2);
+// uart_flush(0);
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+1) && (a->length_B == r->length_B)){
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, GET_FBS(a)-rfbs-1);
- cli_putstr("\r\nDBG: (2) = "); bigint_print_hex(a);
+// cli_putstr("\r\nDBG: (2) = "); bigint_print_hex(a);
}
while(bigint_cmp_u(a,r)>=0){
bigint_sub_u(a,a,r);
- cli_putstr("\r\nDBG: (3) = "); bigint_print_hex(a);
+// cli_putstr("\r\nDBG: (3) = "); bigint_print_hex(a);
}
bigint_adjust(a);
- cli_putstr("\r\nDBG: (a) = "); bigint_print_hex(a);
- cli_putstr("\r\n");
+// cli_putstr("\r\nDBG: (a) = "); bigint_print_hex(a);
+// cli_putstr("\r\n");
}
/******************************************************************************/
}
bigint_t res, base;
- bigint_word_t base_b[MAX(a->length_B,r->length_B*2)], res_b[r->length_B*2];
+ bigint_word_t t, base_b[MAX(a->length_B,r->length_B*2)], res_b[r->length_B*2];
uint16_t i;
- uint8_t j, t;
+ uint8_t j;
+// uint16_t *xaddr = &i;
+// cli_putstr("\r\npre-alloc (");
+// cli_hexdump_rev(&xaddr, 4);
+// cli_putstr(") ...");
res.wordv = res_b;
base.wordv = base_b;
bigint_copy(&base, a);
+// cli_putstr("\r\npost-copy");
bigint_reduce(&base, r);
res.wordv[0]=1;
res.length_B=1;
res.info = 0;
+// cli_putstr("\r\nadjust ");
bigint_adjust(&res);
+// cli_putstr("\r\nexpmod ");
for(i=0; i+1<exp->length_B; ++i){
t=exp->wordv[i];
- for(j=0; j<8; ++j){
+ for(j=0; j<BIGINT_WORD_SIZE; ++j){
if(t&1){
bigint_mul_u(&res, &res, &base);
bigint_reduce(&res, r);
}
}
t=exp->wordv[i];
+
+// cli_putc('+');
while(t){
if(t&1){
bigint_mul_u(&res, &res, &base);
}
/******************************************************************************/
+
+#define cli_putstr(a)
+#define bigint_print_hex(a)
+#define cli_hexdump_rev(a,b)
+#define uart_flush(a)
+
/* gcd <-- gcd(x,y) a*x+b*y=gcd */
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_;
- volatile uint16_t i=0;
+ uint16_t i=0;
if(x->length_B==0 || y->length_B==0){
return;
}
+ if(x->length_B==1 && x->wordv[0]==1){
+ gcd->length_B = 1;
+ gcd->wordv[0] = 1;
+ if(a){
+ a->length_B = 1;
+ a->wordv[0] = 1;
+ SET_POS(a);
+ bigint_adjust(a);
+ }
+ if(b){
+ bigint_set_zero(b);
+ }
+ return;
+ }
+ if(y->length_B==1 && y->wordv[0]==1){
+ gcd->length_B = 1;
+ gcd->wordv[0] = 1;
+ if(b){
+ b->length_B = 1;
+ b->wordv[0] = 1;
+ SET_POS(b);
+ bigint_adjust(b);
+ }
+ if(a){
+ bigint_set_zero(a);
+ }
+ return;
+ }
+
while(x->wordv[i]==0 && y->wordv[i]==0){
++i;
}
g.wordv = g_b;
x_.wordv = x_b;
y_.wordv = y_b;
- memset(g_b, 0, i);
+ memset(g_b, 0, i*sizeof(bigint_word_t));
g_b[i]=1;
g.length_B = i+1;
g.info=0;
x_.info = y_.info = 0;
x_.length_B = x->length_B-i;
y_.length_B = y->length_B-i;
- memcpy(x_.wordv, x->wordv+i, x_.length_B);
- memcpy(y_.wordv, y->wordv+i, y_.length_B);
+ memcpy(x_.wordv, x->wordv+i, x_.length_B*sizeof(bigint_word_t));
+ memcpy(y_.wordv, y->wordv+i, y_.length_B*sizeof(bigint_word_t));
for(i=0; (x_.wordv[0]&(1<<i))==0 && (y_.wordv[0]&(1<<i))==0; ++i){
}
bigint_shiftright(&x_, i);
bigint_shiftright(&y_, i);
}
+
u.wordv = u_b;
v.wordv = v_b;
a_.wordv = a_b;
bigint_set_zero(&b_);
bigint_set_zero(&c_);
do{
+ cli_putstr("\r\nDBG (gcdext) 0");
while((u.wordv[0]&1)==0){
+ cli_putstr("\r\nDBG (gcdext) 0.1");
bigint_shiftright(&u, 1);
if((a_.wordv[0]&1) || (b_.wordv[0]&1)){
bigint_add_s(&a_, &a_, &y_);
bigint_shiftright(&b_, 1);
}
while((v.wordv[0]&1)==0){
+ cli_putstr("\r\nDBG (gcdext) 0.2");
bigint_shiftright(&v, 1);
if((c_.wordv[0]&1) || (d_.wordv[0]&1)){
bigint_add_s(&c_, &c_, &y_);