updated bigint & rsa
This commit is contained in:
parent
6095187b08
commit
73f474e8fe
|
@ -1,7 +1,7 @@
|
||||||
TOOLCHAIN = arm-none-eabi-#
|
TOOLCHAIN = arm-elf-#
|
||||||
MCU_TARGET = cortex-m3
|
MCU_TARGET = cortex-m3
|
||||||
MCU_OPTS = -mthumb
|
MCU_OPTS = -mthumb
|
||||||
OPTIMIZE = -O0 -fomit-frame-pointer
|
OPTIMIZE = -Os -fomit-frame-pointer
|
||||||
DEBUG = -gdwarf-2
|
DEBUG = -gdwarf-2
|
||||||
WARNING = -pedantic -Wall -Wstrict-prototypes -Werror
|
WARNING = -pedantic -Wall -Wstrict-prototypes -Werror
|
||||||
DEFS = -D$(call uc, $(subst -,_,$(MCU_TARGET)))
|
DEFS = -D$(call uc, $(subst -,_,$(MCU_TARGET)))
|
||||||
|
@ -16,7 +16,7 @@ TEST_DIR = test/#
|
||||||
BIN_DIR = bin/#
|
BIN_DIR = bin/#
|
||||||
TESTSRC_DIR = test_src/#
|
TESTSRC_DIR = test_src/#
|
||||||
ERASECMD =
|
ERASECMD =
|
||||||
TESTPORT = /dev/ttyUSB0
|
TESTPORT = /dev/ttyUSB1
|
||||||
TESTPORTBAUDR = 115200
|
TESTPORTBAUDR = 115200
|
||||||
TESTLOG_DIR = testlog/#
|
TESTLOG_DIR = testlog/#
|
||||||
TESTPREFIX = nessie-#
|
TESTPREFIX = nessie-#
|
||||||
|
|
284
bigint/bigint.c
284
bigint/bigint.c
|
@ -33,11 +33,10 @@
|
||||||
#include "bigint.h"
|
#include "bigint.h"
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
|
|
||||||
#define DEBUG 1
|
#define DEBUG 0
|
||||||
|
|
||||||
#if DEBUG
|
#if DEBUG
|
||||||
#include "cli.h"
|
#include "cli.h"
|
||||||
#include "uart_lowlevel.h"
|
|
||||||
#include "bigint_io.h"
|
#include "bigint_io.h"
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
@ -54,9 +53,9 @@
|
||||||
#define SET_NEG(a) (a)->info |= BIGINT_NEG_MASK
|
#define SET_NEG(a) (a)->info |= BIGINT_NEG_MASK
|
||||||
#define SET_POS(a) (a)->info &= ~BIGINT_NEG_MASK
|
#define SET_POS(a) (a)->info &= ~BIGINT_NEG_MASK
|
||||||
#define XCHG(a,b) do{(a)^=(b); (b)^=(a); (a)^=(b);}while(0)
|
#define XCHG(a,b) do{(a)^=(b); (b)^=(a); (a)^=(b);}while(0)
|
||||||
#define XCHG_PTR(a,b) do{ a = (void*)(((uint32_t)(a)) ^ ((uint32_t)(b))); \
|
#define XCHG_PTR(a,b) do{ a = (void*)(((bigint_ptr_int_t)(a)) ^ ((bigint_ptr_int_t)(b))); \
|
||||||
b = (void*)(((uint32_t)(a)) ^ ((uint32_t)(b))); \
|
b = (void*)(((bigint_ptr_int_t)(a)) ^ ((bigint_ptr_int_t)(b))); \
|
||||||
a = (void*)(((uint32_t)(a)) ^ ((uint32_t)(b)));}while(0)
|
a = (void*)(((bigint_ptr_int_t)(a)) ^ ((bigint_ptr_int_t)(b)));}while(0)
|
||||||
|
|
||||||
#define GET_SIGN(a) ((a)->info&BIGINT_NEG_MASK)
|
#define GET_SIGN(a) ((a)->info&BIGINT_NEG_MASK)
|
||||||
|
|
||||||
|
@ -72,7 +71,7 @@ void bigint_adjust(bigint_t* a){
|
||||||
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_B-1];
|
||||||
while((t&(1<<(BIGINT_WORD_SIZE-1)))==0 && i){
|
while((t&(1L<<(BIGINT_WORD_SIZE-1)))==0 && i){
|
||||||
t<<=1;
|
t<<=1;
|
||||||
i--;
|
i--;
|
||||||
}
|
}
|
||||||
|
@ -155,7 +154,9 @@ void bigint_add_u(bigint_t* dest, const bigint_t* a, const bigint_t* b){
|
||||||
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;
|
if(t){
|
||||||
|
dest->wordv[i++] = (bigint_word_t)t;
|
||||||
|
}
|
||||||
dest->length_B = i;
|
dest->length_B = i;
|
||||||
bigint_adjust(dest);
|
bigint_adjust(dest);
|
||||||
}
|
}
|
||||||
|
@ -164,9 +165,56 @@ 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){
|
||||||
uint16_t i,j=0;
|
if(a->length_B == 0){
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if(scale == 0){
|
||||||
|
bigint_add_u(dest, dest, a);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
bigint_t x;
|
||||||
|
#if BIGINT_WORD_SIZE == 8
|
||||||
|
memset(dest->wordv + dest->length_B, 0, MAX(dest->length_B, a->length_B + scale) - dest->length_B);
|
||||||
|
x.wordv = dest->wordv + scale;
|
||||||
|
x.length_B = dest->length_B - scale;
|
||||||
|
if((int16_t)x.length_B < 0){
|
||||||
|
x.length_B = 0;
|
||||||
|
x.info = 0;
|
||||||
|
} else {
|
||||||
|
x.info = dest->info;
|
||||||
|
}
|
||||||
|
bigint_add_u(&x, &x, a);
|
||||||
|
dest->length_B = x.length_B + scale;
|
||||||
|
dest->info = 0;
|
||||||
|
bigint_adjust(dest);
|
||||||
|
#else
|
||||||
|
bigint_t s;
|
||||||
|
uint16_t word_shift = scale / sizeof(bigint_word_t), byte_shift = scale % sizeof(bigint_word_t);
|
||||||
|
bigint_word_t bv[a->length_B + 1];
|
||||||
|
s.wordv = bv;
|
||||||
|
bv[0] = bv[a->length_B] = 0;
|
||||||
|
memcpy((uint8_t*)bv + byte_shift, a->wordv, a->length_B * sizeof(bigint_word_t));
|
||||||
|
s.length_B = a->length_B + 1;
|
||||||
|
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));
|
||||||
|
x.wordv = dest->wordv + word_shift;
|
||||||
|
x.length_B = dest->length_B - word_shift;
|
||||||
|
if((int16_t)x.length_B < 0){
|
||||||
|
x.length_B = 0;
|
||||||
|
x.info = 0;
|
||||||
|
}else{
|
||||||
|
x.info = dest->info;
|
||||||
|
}
|
||||||
|
bigint_add_u(&x, &x, &s);
|
||||||
|
dest->length_B = x.length_B + word_shift;
|
||||||
|
dest->info = 0;
|
||||||
|
bigint_adjust(dest);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
||||||
|
/* uint16_t i,j=0;
|
||||||
uint16_t scale_w;
|
uint16_t scale_w;
|
||||||
uint32_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_B*sizeof(bigint_word_t)){
|
||||||
|
@ -194,6 +242,7 @@ void bigint_add_scale_u(bigint_t* dest, const bigint_t* a, uint16_t scale){
|
||||||
dest->length_B = i;
|
dest->length_B = i;
|
||||||
}
|
}
|
||||||
bigint_adjust(dest);
|
bigint_adjust(dest);
|
||||||
|
*/
|
||||||
}
|
}
|
||||||
|
|
||||||
/******************************************************************************/
|
/******************************************************************************/
|
||||||
|
@ -224,34 +273,24 @@ void bigint_sub_u(bigint_t* dest, const bigint_t* a, const bigint_t* b){
|
||||||
if(r<0){
|
if(r<0){
|
||||||
bigint_sub_u(dest, b, a);
|
bigint_sub_u(dest, b, a);
|
||||||
SET_NEG(dest);
|
SET_NEG(dest);
|
||||||
}else{
|
return;
|
||||||
for(i=0; i<min; ++i){
|
|
||||||
t = a->wordv[i];
|
|
||||||
t -= b->wordv[i];
|
|
||||||
t -= borrow;
|
|
||||||
if(t<0){
|
|
||||||
borrow = 1;
|
|
||||||
dest->wordv[i]=(bigint_word_t)t;
|
|
||||||
}else{
|
|
||||||
borrow = 0;
|
|
||||||
dest->wordv[i]=(bigint_word_t)t;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for(;i<max; ++i){
|
|
||||||
t = a->wordv[i] - borrow;
|
|
||||||
if(t<0){
|
|
||||||
borrow = 1;
|
|
||||||
dest->wordv[i]=(bigint_word_t)t;
|
|
||||||
}else{
|
|
||||||
borrow = 0;
|
|
||||||
dest->wordv[i]=(bigint_word_t)t;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
SET_POS(dest);
|
|
||||||
dest->length_B = i;
|
|
||||||
bigint_adjust(dest);
|
|
||||||
}
|
}
|
||||||
|
for(i=0; i<max; ++i){
|
||||||
|
t = a->wordv[i];
|
||||||
|
if(i<min){
|
||||||
|
t -= b->wordv[i];
|
||||||
|
}
|
||||||
|
t -= borrow;
|
||||||
|
dest->wordv[i]=(bigint_word_t)t;
|
||||||
|
if(t<0){
|
||||||
|
borrow = 1;
|
||||||
|
}else{
|
||||||
|
borrow = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
SET_POS(dest);
|
||||||
|
dest->length_B = i;
|
||||||
|
bigint_adjust(dest);
|
||||||
}
|
}
|
||||||
|
|
||||||
/******************************************************************************/
|
/******************************************************************************/
|
||||||
|
@ -269,8 +308,8 @@ int8_t bigint_cmp_u(const bigint_t* a, const bigint_t* b){
|
||||||
uint16_t i;
|
uint16_t i;
|
||||||
i = a->length_B-1;
|
i = a->length_B-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]){
|
||||||
return 1;
|
return 1;
|
||||||
}else{
|
}else{
|
||||||
return -1;
|
return -1;
|
||||||
|
@ -469,78 +508,80 @@ void bigint_mul_u(bigint_t* dest, const bigint_t* a, const bigint_t* b){
|
||||||
if(a->length_B!=1){
|
if(a->length_B!=1){
|
||||||
XCHG_PTR(a,b);
|
XCHG_PTR(a,b);
|
||||||
}
|
}
|
||||||
bigint_wordplus_t i, t=0;
|
bigint_wordplus_t t=0;
|
||||||
|
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_B; ++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_B = i+1;
|
||||||
|
dest->info = 0;
|
||||||
bigint_adjust(dest);
|
bigint_adjust(dest);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if(a->length_B<=4/sizeof(bigint_word_t) && b->length_B<=4/sizeof(bigint_word_t)){
|
if(a->length_B * sizeof(bigint_word_t) <= 4 && b->length_B * 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_B*sizeof(bigint_word_t));
|
||||||
memcpy(&q, b->wordv, b->length_B*sizeof(bigint_word_t));
|
memcpy(&q, b->wordv, b->length_B*sizeof(bigint_word_t));
|
||||||
r = (uint64_t)p*(uint64_t)q;
|
r = (uint64_t)p * (uint64_t)q;
|
||||||
memcpy(dest->wordv, &r, (a->length_B+b->length_B)*sizeof(bigint_word_t));
|
memcpy(dest->wordv, &r, (dest->length_B = a->length_B + b->length_B)*sizeof(bigint_word_t));
|
||||||
dest->length_B = a->length_B+b->length_B;
|
|
||||||
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 */
|
||||||
uint16_t n;
|
const uint16_t n = (MAX(a->length_B, b->length_B)+1)/2;
|
||||||
n=(MAX(a->length_B, b->length_B)+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_B<=n){
|
||||||
xh.info=0;
|
bigint_set_zero(&xh);
|
||||||
xh.length_B = 0;
|
|
||||||
xl.length_B = a->length_B;
|
xl.length_B = a->length_B;
|
||||||
xl.info = 0;
|
xl.info = a->info;
|
||||||
}else{
|
}else{
|
||||||
xl.length_B=n;
|
xl.length_B=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_B = a->length_B-n;
|
||||||
xh.info = 0;
|
xh.info = a->info;
|
||||||
}
|
}
|
||||||
if(b->length_B<=n){
|
if(b->length_B<=n){
|
||||||
yh.info=0;
|
bigint_set_zero(&yh);
|
||||||
yh.length_B = 0;
|
|
||||||
yl.length_B = b->length_B;
|
yl.length_B = b->length_B;
|
||||||
yl.info = b->info;
|
yl.info = b->info;
|
||||||
}else{
|
}else{
|
||||||
yl.length_B=n;
|
yl.length_B=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_B = b->length_B-n;
|
||||||
yh.info = 0;
|
yh.info = b->info;
|
||||||
}
|
}
|
||||||
/* now we have split up a and b */
|
/* now we have split up a and b */
|
||||||
|
/* remember we want to do:
|
||||||
|
* x*y = (xh*yh)*b**2n + ((xh+xl)*(yh+yl) - xh*yh - xl*yl)*b**n + yh*yl
|
||||||
|
* 5 9 2 4 3 7 5 6 1 8 1
|
||||||
|
*/
|
||||||
bigint_word_t tmp_b[2*n+2], m_b[2*(n+1)];
|
bigint_word_t tmp_b[2*n+2], m_b[2*(n+1)];
|
||||||
bigint_t tmp, tmp2, m;
|
bigint_t tmp, tmp2, m;
|
||||||
tmp.wordv = tmp_b;
|
tmp.wordv = tmp_b;
|
||||||
tmp2.wordv = tmp_b+n+1;
|
tmp2.wordv = &(tmp_b[n+1]);
|
||||||
m.wordv = m_b;
|
m.wordv = m_b;
|
||||||
|
|
||||||
bigint_mul_u(dest, &xl, &yl); /* dest <= xl*yl */
|
bigint_mul_u(dest, &xl, &yl); /* 1: dest <= xl*yl */
|
||||||
bigint_add_u(&tmp2, &xh, &xl); /* tmp2 <= xh+xl */
|
bigint_add_u(&tmp2, &xh, &xl); /* 2: tmp2 <= xh+xl */
|
||||||
bigint_add_u(&tmp, &yh, &yl); /* tmp <= yh+yl */
|
bigint_add_u(&tmp, &yh, &yl); /* 3: tmp <= yh+yl */
|
||||||
bigint_mul_u(&m, &tmp2, &tmp); /* m <= tmp2*tmp */
|
bigint_mul_u(&m, &tmp2, &tmp); /* 4: m <= tmp2*tmp */
|
||||||
bigint_mul_u(&tmp, &xh, &yh); /* h <= xh*yh */
|
bigint_mul_u(&tmp, &xh, &yh); /* 5: h <= xh*yh */
|
||||||
bigint_sub_u(&m, &m, dest); /* m <= m-dest */
|
bigint_sub_u(&m, &m, dest); /* 6: m <= m-dest */
|
||||||
bigint_sub_u(&m, &m, &tmp); /* m <= m-h */
|
bigint_sub_u(&m, &m, &tmp); /* 7: m <= m-h */
|
||||||
bigint_add_scale_u(dest, &m, n*sizeof(bigint_word_t));
|
bigint_add_scale_u(dest, &m, n*sizeof(bigint_word_t)); /* 8: dest <= dest+m**n*/
|
||||||
bigint_add_scale_u(dest, &tmp, 2*n*sizeof(bigint_word_t));
|
bigint_add_scale_u(dest, &tmp, 2*n*sizeof(bigint_word_t)); /* 9: dest <= dest+tmp**(2*n) */
|
||||||
}
|
}
|
||||||
|
|
||||||
/******************************************************************************/
|
/******************************************************************************/
|
||||||
|
@ -600,9 +641,15 @@ void bigint_square(bigint_t* dest, const bigint_t* a){
|
||||||
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_B = n;
|
||||||
|
xl.info = 0;
|
||||||
xh.wordv = &(a->wordv[n]);
|
xh.wordv = &(a->wordv[n]);
|
||||||
xh.length_B = a->length_B-n;
|
xh.length_B = a->length_B-n;
|
||||||
|
xh.info = 0;
|
||||||
|
bigint_adjust(&xl);
|
||||||
|
bigint_adjust(&xh);
|
||||||
tmp.wordv = buffer;
|
tmp.wordv = buffer;
|
||||||
|
/* (xh * b**n + xl)**2 = xh**2 * b**2n + 2 * xh * xl * b**n + xl**2 */
|
||||||
|
|
||||||
// cli_putstr("\r\nDBG (a): xl: "); bigint_print_hex(&xl);
|
// cli_putstr("\r\nDBG (a): xl: "); bigint_print_hex(&xl);
|
||||||
// cli_putstr("\r\nDBG (b): xh: "); bigint_print_hex(&xh);
|
// cli_putstr("\r\nDBG (b): xh: "); bigint_print_hex(&xh);
|
||||||
bigint_square(dest, &xl);
|
bigint_square(dest, &xl);
|
||||||
|
@ -622,51 +669,28 @@ 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;
|
bigint_t tmp, x;
|
||||||
bigint_word_t tmp_b[b->length_B+4];
|
bigint_word_t tmp_b[b->length_B + 1];
|
||||||
uint16_t i,j,word_shift=bitscale/(8*sizeof(bigint_word_t));
|
const uint16_t word_shift = bitscale / BIGINT_WORD_SIZE;
|
||||||
uint8_t borrow=0;
|
|
||||||
bigint_wordplus_signed_t t;
|
|
||||||
|
|
||||||
if(a->length_B < b->length_B+word_shift){
|
if(a->length_B < b->length_B + word_shift){
|
||||||
|
#if DEBUG
|
||||||
cli_putstr("\r\nDBG: *bang*\r\n");
|
cli_putstr("\r\nDBG: *bang*\r\n");
|
||||||
|
#endif
|
||||||
bigint_set_zero(a);
|
bigint_set_zero(a);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
tmp.wordv = tmp_b;
|
tmp.wordv = tmp_b;
|
||||||
bigint_copy(&tmp, b);
|
bigint_copy(&tmp, b);
|
||||||
bigint_shiftleft(&tmp, bitscale&(BIGINT_WORD_SIZE-1));
|
bigint_shiftleft(&tmp, bitscale % BIGINT_WORD_SIZE);
|
||||||
// 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){
|
x.info = a->info;
|
||||||
t = a->wordv[i];
|
x.wordv = &(a->wordv[word_shift]);
|
||||||
t -= tmp.wordv[j];
|
x.length_B = a->length_B - word_shift;
|
||||||
t -= borrow;
|
|
||||||
a->wordv[i] = (bigint_word_t)t;
|
bigint_sub_u(&x, &x, &tmp);
|
||||||
if(t<0){
|
|
||||||
borrow = 1;
|
|
||||||
}else{
|
|
||||||
borrow = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
while(borrow){
|
|
||||||
if(i+1 > a->length_B){
|
|
||||||
// char str[16];
|
|
||||||
cli_putstr("\r\nDBG: *boom* a->length_B = ");
|
|
||||||
cli_hexdump_rev(&a->length_B, 2);
|
|
||||||
cli_putstr(" b->length_B = ");
|
|
||||||
cli_hexdump_rev(&b->length_B, 2);
|
|
||||||
cli_putstr(" bitscale = ");
|
|
||||||
cli_hexdump_rev(&bitscale, 2);
|
|
||||||
bigint_set_zero(a);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
a->wordv[i] -= borrow;
|
|
||||||
if(a->wordv[i] != (1LL<<BIGINT_WORD_SIZE) - 1){
|
|
||||||
borrow=0;
|
|
||||||
}
|
|
||||||
++i;
|
|
||||||
}
|
|
||||||
bigint_adjust(a);
|
bigint_adjust(a);
|
||||||
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
/******************************************************************************/
|
/******************************************************************************/
|
||||||
|
@ -674,8 +698,9 @@ void bigint_sub_u_bitscale(bigint_t* a, const bigint_t* b, uint16_t bitscale){
|
||||||
void bigint_reduce(bigint_t* a, const bigint_t* r){
|
void bigint_reduce(bigint_t* a, const bigint_t* r){
|
||||||
// bigint_adjust((bigint_t*)r);
|
// bigint_adjust((bigint_t*)r);
|
||||||
uint8_t rfbs = GET_FBS(r);
|
uint8_t rfbs = GET_FBS(r);
|
||||||
|
#if DEBUG
|
||||||
// cli_putstr("\r\nDBG: (a) = "); bigint_print_hex(a);
|
cli_putstr("\r\nDBG: (a) = "); bigint_print_hex(a);
|
||||||
|
#endif
|
||||||
if(r->length_B==0 || a->length_B==0){
|
if(r->length_B==0 || a->length_B==0){
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
@ -709,10 +734,10 @@ void bigint_reduce(bigint_t* a, const bigint_t* r){
|
||||||
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+1) && (a->length_B == r->length_B)){
|
while((GET_FBS(a) > rfbs) && (a->length_B == r->length_B)){
|
||||||
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, GET_FBS(a)-rfbs-1);
|
bigint_sub_u_bitscale(a, r, shift);
|
||||||
// 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){
|
while(bigint_cmp_u(a,r)>=0){
|
||||||
|
@ -734,7 +759,7 @@ void bigint_expmod_u(bigint_t* dest, const bigint_t* a, const bigint_t* exp, con
|
||||||
}
|
}
|
||||||
|
|
||||||
bigint_t res, base;
|
bigint_t res, base;
|
||||||
bigint_word_t 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)], res_b[r->length_B*2];
|
||||||
uint16_t i;
|
uint16_t i;
|
||||||
uint8_t j;
|
uint8_t j;
|
||||||
// uint16_t *xaddr = &i;
|
// uint16_t *xaddr = &i;
|
||||||
|
@ -749,33 +774,34 @@ void bigint_expmod_u(bigint_t* dest, const bigint_t* a, const bigint_t* exp, con
|
||||||
res.wordv[0]=1;
|
res.wordv[0]=1;
|
||||||
res.length_B=1;
|
res.length_B=1;
|
||||||
res.info = 0;
|
res.info = 0;
|
||||||
// cli_putstr("\r\nadjust ");
|
|
||||||
bigint_adjust(&res);
|
bigint_adjust(&res);
|
||||||
// cli_putstr("\r\nexpmod ");
|
if(exp->length_B == 0){
|
||||||
for(i=0; i+1<exp->length_B; ++i){
|
bigint_copy(dest, &res);
|
||||||
t=exp->wordv[i];
|
return;
|
||||||
for(j=0; j<BIGINT_WORD_SIZE; ++j){
|
}
|
||||||
if(t&1){
|
uint8_t flag = 0;
|
||||||
bigint_mul_u(&res, &res, &base);
|
t=exp->wordv[exp->length_B - 1];
|
||||||
bigint_reduce(&res, r);
|
for(i=exp->length_B; i > 0; --i){
|
||||||
|
t = exp->wordv[i - 1];
|
||||||
|
for(j=BIGINT_WORD_SIZE; j > 0; --j){
|
||||||
|
if(!flag){
|
||||||
|
if(t & (1<<(BIGINT_WORD_SIZE-1))){
|
||||||
|
flag = 1;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
bigint_square(&base, &base);
|
if(flag){
|
||||||
bigint_reduce(&base, r);
|
bigint_square(&res, &res);
|
||||||
t>>=1;
|
bigint_reduce(&res, r);
|
||||||
|
if(t & (1<<(BIGINT_WORD_SIZE-1))){
|
||||||
|
bigint_mul_u(&res, &res, &base);
|
||||||
|
bigint_reduce(&res, r);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
t<<=1;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
t=exp->wordv[i];
|
|
||||||
|
|
||||||
// cli_putc('+');
|
// cli_putc('+');
|
||||||
while(t){
|
|
||||||
if(t&1){
|
|
||||||
bigint_mul_u(&res, &res, &base);
|
|
||||||
bigint_reduce(&res, r);
|
|
||||||
}
|
|
||||||
bigint_square(&base, &base);
|
|
||||||
bigint_reduce(&base, r);
|
|
||||||
t>>=1;
|
|
||||||
}
|
|
||||||
SET_POS(&res);
|
SET_POS(&res);
|
||||||
bigint_copy(dest, &res);
|
bigint_copy(dest, &res);
|
||||||
}
|
}
|
||||||
|
|
|
@ -43,7 +43,7 @@ typedef struct{
|
||||||
bigint_word_t *wordv; /* word vector, pointing to the LSB */
|
bigint_word_t *wordv; /* word vector, pointing to the LSB */
|
||||||
}bigint_t;
|
}bigint_t;
|
||||||
|
|
||||||
|
typedef uint32_t bigint_ptr_int_t;
|
||||||
|
|
||||||
/******************************************************************************/
|
/******************************************************************************/
|
||||||
|
|
||||||
|
|
|
@ -43,7 +43,7 @@ void bigint_print_hex(const bigint_t* a){
|
||||||
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_B-1])+sizeof(bigint_word_t)-1;
|
||||||
for(idx=a->length_B*sizeof(bigint_word_t); idx>0; --idx){
|
for(idx = a->length_B * 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){
|
||||||
|
@ -97,24 +97,24 @@ static uint16_t read_byte(void){
|
||||||
uint8_t bigint_read_hex_echo(bigint_t* a){
|
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;
|
uint16_t t, idx = 0;
|
||||||
a->length_B = 0;
|
a->length_B = 0;
|
||||||
a->wordv = NULL;
|
a->wordv = NULL;
|
||||||
a->info = 0;
|
a->info = 0;
|
||||||
for(;;){
|
for(;;){
|
||||||
if(allocated-a->length_B < 1){
|
if(allocated - idx < 1){
|
||||||
bigint_word_t *p;
|
bigint_word_t *p;
|
||||||
p = realloc(a->wordv, allocated+=BLOCKSIZE);
|
p = realloc(a->wordv, allocated += BLOCKSIZE);
|
||||||
if(p==NULL){
|
if(p==NULL){
|
||||||
cli_putstr("\r\nERROR: Out of memory!");
|
cli_putstr("\r\nERROR: Out of memory!");
|
||||||
free(a->wordv);
|
free(a->wordv);
|
||||||
return 0xff;
|
return 0xff;
|
||||||
}
|
}
|
||||||
memset((uint8_t*)p+allocated-BLOCKSIZE, 0, BLOCKSIZE);
|
memset((uint8_t*)p + allocated - BLOCKSIZE, 0, BLOCKSIZE);
|
||||||
a->wordv=p;
|
a->wordv=p;
|
||||||
}
|
}
|
||||||
t = read_byte();
|
t = read_byte();
|
||||||
if(a->length_B==0){
|
if(idx==0){
|
||||||
if(t&0x0400){
|
if(t&0x0400){
|
||||||
/* got minus */
|
/* got minus */
|
||||||
a->info |= BIGINT_NEG_MASK;
|
a->info |= BIGINT_NEG_MASK;
|
||||||
|
@ -128,11 +128,11 @@ uint8_t bigint_read_hex_echo(bigint_t* a){
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if(t<=0x00ff){
|
if(t<=0x00ff){
|
||||||
((uint8_t*)(a->wordv))[a->length_B++] = (uint8_t)t;
|
((uint8_t*)(a->wordv))[idx++] = (uint8_t)t;
|
||||||
}else{
|
}else{
|
||||||
if(t&0x0200){
|
if(t&0x0200){
|
||||||
shift4 = 1;
|
shift4 = 1;
|
||||||
((uint8_t*)(a->wordv))[a->length_B++] = (uint8_t)((t&0x0f)<<4);
|
((uint8_t*)(a->wordv))[idx++] = (uint8_t)((t&0x0f)<<4);
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
@ -140,20 +140,18 @@ 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);
|
||||||
p = (uint8_t*)(a->wordv);
|
p = (uint8_t*)(a->wordv);
|
||||||
q = (uint8_t*)a->wordv+a->length_B-1;
|
q = (uint8_t*)a->wordv + idx - 1;
|
||||||
while(q>p){
|
while(q>p){
|
||||||
tmp = *p;
|
tmp = *p;
|
||||||
*p = *q;
|
*p = *q;
|
||||||
*q = tmp;
|
*q = tmp;
|
||||||
p++; q--;
|
p++; q--;
|
||||||
}
|
}
|
||||||
a->length_B = (a->length_B+sizeof(bigint_word_t)-1)/sizeof(bigint_word_t);
|
bigint_adjust(a);
|
||||||
if(shift4){
|
if(shift4){
|
||||||
bigint_adjust(a);
|
|
||||||
bigint_shiftright(a, 4);
|
bigint_shiftright(a, 4);
|
||||||
}else{
|
|
||||||
bigint_adjust(a);
|
|
||||||
}
|
}
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
|
@ -23,7 +23,7 @@ $debug = false
|
||||||
require 'rubygems'
|
require 'rubygems'
|
||||||
require 'serialport'
|
require 'serialport'
|
||||||
require 'getopt/std'
|
require 'getopt/std'
|
||||||
require 'ftools'
|
require 'fileutils'
|
||||||
require 'date'
|
require 'date'
|
||||||
$buffer_size = 0
|
$buffer_size = 0
|
||||||
$conffile_check = Hash.new
|
$conffile_check = Hash.new
|
||||||
|
@ -37,7 +37,7 @@ def readconfigfile(fname, conf)
|
||||||
return conf if $conffile_check[fname]==1
|
return conf if $conffile_check[fname]==1
|
||||||
$conffile_check[fname]=1
|
$conffile_check[fname]=1
|
||||||
section = "default"
|
section = "default"
|
||||||
if not File.exists?(fname)
|
if ! File.exists?(fname)
|
||||||
return conf
|
return conf
|
||||||
end
|
end
|
||||||
file = File.open(fname, "r")
|
file = File.open(fname, "r")
|
||||||
|
@ -49,7 +49,7 @@ def readconfigfile(fname, conf)
|
||||||
conf[m[1]] = Hash.new
|
conf[m[1]] = Hash.new
|
||||||
next
|
next
|
||||||
end
|
end
|
||||||
next if not /=/.match(line)
|
next if ! /=/.match(line)
|
||||||
m=/[\s]*([^\s]*)[\s]*=[\s]*([^\s]*)/.match(line)
|
m=/[\s]*([^\s]*)[\s]*=[\s]*([^\s]*)/.match(line)
|
||||||
if m[1]=="include"
|
if m[1]=="include"
|
||||||
Dir.glob(m[2]){ |fn| conf = readconfigfile(fn, conf) }
|
Dir.glob(m[2]){ |fn| conf = readconfigfile(fn, conf) }
|
||||||
|
@ -127,6 +127,9 @@ end
|
||||||
################################################################################
|
################################################################################
|
||||||
|
|
||||||
def init_system(test_prog)
|
def init_system(test_prog)
|
||||||
|
begin
|
||||||
|
line = $sp.gets()
|
||||||
|
end while line!=nil
|
||||||
$sp.print("echo off \r")
|
$sp.print("echo off \r")
|
||||||
print("DBG i: " + "echo off \r"+"\n") if $debug
|
print("DBG i: " + "echo off \r"+"\n") if $debug
|
||||||
sleep 0.1
|
sleep 0.1
|
||||||
|
@ -135,6 +138,29 @@ def init_system(test_prog)
|
||||||
sleep 1
|
sleep 1
|
||||||
end
|
end
|
||||||
|
|
||||||
|
################################################################################
|
||||||
|
# wait_for_prompt #
|
||||||
|
################################################################################
|
||||||
|
|
||||||
|
def wait_for_prompt(prompt)
|
||||||
|
prompt = /[\s]*#{prompt}[\s]*/ if(prompt.class == String)
|
||||||
|
start_time = Time.now.to_i
|
||||||
|
acc = ''
|
||||||
|
begin
|
||||||
|
line = $sp.gets()
|
||||||
|
puts("DBG got (#{__LINE__}): "+line) if $debug && line
|
||||||
|
line = "" if line==nil
|
||||||
|
if /^(Error:|Crypto-VS).*/.match(line)
|
||||||
|
puts line
|
||||||
|
return false
|
||||||
|
end
|
||||||
|
if (Time.now.to_i- start_time) > $max_timeout
|
||||||
|
return false
|
||||||
|
end
|
||||||
|
acc += line
|
||||||
|
end while ! m=prompt.match(acc)
|
||||||
|
return m
|
||||||
|
end
|
||||||
|
|
||||||
################################################################################
|
################################################################################
|
||||||
# screen_progress #
|
# screen_progress #
|
||||||
|
@ -161,7 +187,7 @@ def add_test(a,b)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not /[\s]*enter a:[\s]*/.match(line)
|
end while ! /[\s]*enter a:[\s]*/.match(line)
|
||||||
$sp.print(a.to_s(16)+" ")
|
$sp.print(a.to_s(16)+" ")
|
||||||
begin
|
begin
|
||||||
line = $sp.gets()
|
line = $sp.gets()
|
||||||
|
@ -171,7 +197,7 @@ def add_test(a,b)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not /[\s]*enter b:[\s]*/.match(line)
|
end while ! /[\s]*enter b:[\s]*/.match(line)
|
||||||
$sp.print(b.to_s(16)+" ")
|
$sp.print(b.to_s(16)+" ")
|
||||||
begin
|
begin
|
||||||
line = $sp.gets()
|
line = $sp.gets()
|
||||||
|
@ -181,7 +207,7 @@ def add_test(a,b)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not m=/[\s]*([-]?[0-9a-fA-F]*)[\s]+\+[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]*)/.match(line)
|
end while ! m=/[\s]*([-]?[0-9a-fA-F]*)[\s]+\+[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]*)/.match(line)
|
||||||
a_ = m[1].to_i(16)
|
a_ = m[1].to_i(16)
|
||||||
b_ = m[2].to_i(16)
|
b_ = m[2].to_i(16)
|
||||||
c_ = m[3].to_i(16)
|
c_ = m[3].to_i(16)
|
||||||
|
@ -210,7 +236,7 @@ def mul_test(a,b)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not /[\s]*enter a:[\s]*/.match(line)
|
end while ! /[\s]*enter a:[\s]*/.match(line)
|
||||||
$sp.print(a.to_s(16)+" ")
|
$sp.print(a.to_s(16)+" ")
|
||||||
begin
|
begin
|
||||||
line = $sp.gets()
|
line = $sp.gets()
|
||||||
|
@ -220,7 +246,7 @@ def mul_test(a,b)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not /[\s]*enter b:[\s]*/.match(line)
|
end while ! /[\s]*enter b:[\s]*/.match(line)
|
||||||
$sp.print(b.to_s(16)+" ")
|
$sp.print(b.to_s(16)+" ")
|
||||||
begin
|
begin
|
||||||
line = $sp.gets()
|
line = $sp.gets()
|
||||||
|
@ -230,7 +256,7 @@ def mul_test(a,b)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not m=/[\s]*([+-]?[0-9a-fA-F]*)[\s]+\*[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]*)/.match(line)
|
end while ! m=/[\s]*([+-]?[0-9a-fA-F]*)[\s]+\*[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]*)/.match(line)
|
||||||
a_ = m[1].to_i(16)
|
a_ = m[1].to_i(16)
|
||||||
b_ = m[2].to_i(16)
|
b_ = m[2].to_i(16)
|
||||||
c_ = m[3].to_i(16)
|
c_ = m[3].to_i(16)
|
||||||
|
@ -249,58 +275,43 @@ end
|
||||||
################################################################################
|
################################################################################
|
||||||
# add_scale_test #
|
# add_scale_test #
|
||||||
################################################################################
|
################################################################################
|
||||||
|
def add_scale_test_dummy(a, b, scale)
|
||||||
|
should = a + (b<<(8*scale))
|
||||||
|
printf("[dummy] %s + %s <<8*%04x = %s\n",a.to_s(16), b.to_s(16), scale, should.to_s(16))
|
||||||
|
end
|
||||||
|
|
||||||
def add_scale_test(a, b, scale)
|
def add_scale_test(a, b, scale)
|
||||||
begin
|
m = wait_for_prompt("enter a:")
|
||||||
line = $sp.gets()
|
return false if !m
|
||||||
line = "" if line==nil
|
puts("DBG put (#{__LINE__}): "+a.to_s(16)+" ") if $debug
|
||||||
puts("DBG got: "+line) if $debug
|
|
||||||
if /^Error:.*/.match(line)
|
|
||||||
puts line
|
|
||||||
return false
|
|
||||||
end
|
|
||||||
end while not /[\s]*enter a:[\s]*/.match(line)
|
|
||||||
$sp.print(a.to_s(16)+" ")
|
$sp.print(a.to_s(16)+" ")
|
||||||
begin
|
m = wait_for_prompt("enter b:")
|
||||||
line = $sp.gets()
|
return false if !m
|
||||||
line = "" if line==nil
|
puts("DBG put (#{__LINE__}): "+b.to_s(16)+" ") if $debug
|
||||||
puts("DBG got: "+line) if $debug
|
|
||||||
if /^Error:.*/.match(line)
|
|
||||||
puts line
|
|
||||||
return false
|
|
||||||
end
|
|
||||||
end while not /[\s]*enter b:[\s]*/.match(line)
|
|
||||||
$sp.print(b.to_s(16)+" ")
|
$sp.print(b.to_s(16)+" ")
|
||||||
begin
|
m = wait_for_prompt("enter scale:")
|
||||||
line = $sp.gets()
|
return false if !m
|
||||||
line = "" if line==nil
|
puts("DBG put (#{__LINE__}): "+scale.to_s(10)+" ") if $debug
|
||||||
puts("DBG got: "+line) if $debug
|
$sp.print(scale.to_s(10)+"\r")
|
||||||
if /^Error:.*/.match(line)
|
should = a + (b<<(8*scale))
|
||||||
puts line
|
m = wait_for_prompt(/[\s]*([-]?[0-9a-fA-F]+)[\s]+\+[\s]+([+-]?[0-9a-fA-F]+)[\s]*<<8\*[\s]*([+-]?[0-9a-fA-F]+)[\s]*=[\s]*([+-]?[0-9a-fA-F]+)/)
|
||||||
return false
|
if !m
|
||||||
end
|
$logfile.printf("[fail (CRASH)]:")
|
||||||
end while not /[\s]*enter scale:[\s]*/.match(line)
|
$logfile.printf(" ; should %s + %s << 8*%s = %s\n", a.to_s(16), b.to_s(16), scale.to_s(16), should.to_s(16))
|
||||||
$sp.print(scale.to_s(16)+"\n")
|
return false
|
||||||
begin
|
end
|
||||||
line = $sp.gets()
|
line = m[0]
|
||||||
line = "" if line==nil
|
|
||||||
puts("DBG got: "+line) if $debug
|
|
||||||
if /^Error:.*/.match(line)
|
|
||||||
puts line
|
|
||||||
return false
|
|
||||||
end
|
|
||||||
end while not m=/[\s]*([-]?[0-9a-fA-F]*)[\s]+\+[\s]+([+-]?[0-9a-fA-F]*)[\s]*<<8\*[\s]*([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]*)/.match(line)
|
|
||||||
a_ = m[1].to_i(16)
|
a_ = m[1].to_i(16)
|
||||||
b_ = m[2].to_i(16)
|
b_ = m[2].to_i(16)
|
||||||
s_ = m[3].to_i(16)
|
s_ = m[3].to_i(16)
|
||||||
c_ = m[4].to_i(16)
|
c_ = m[4].to_i(16)
|
||||||
line.chomp!
|
line.chomp!
|
||||||
if(a_== a && b_ == b && c_ == (a+b))
|
if(a_== a && b_ == b && s_ == scale && c_ == should )
|
||||||
$logfile.printf("[pass]: %s\n", line)
|
$logfile.printf("[pass]: %s\n", line)
|
||||||
return true
|
return true
|
||||||
else
|
else
|
||||||
$logfile.printf("[fail (%s%s%s)]: %s", (a==a_)?"":"a", (b==b_)?"":"b", (c_==a+b)?"":"c",line)
|
$logfile.printf("[fail (%s%s%s%s)]: %s", (a==a_)?"":"a", (b==b_)?"":"b", (scale==s_)?"":"s",(c_==should)?"":"c",line)
|
||||||
$logfile.printf(" ; should %s + %s = %s\n", a.to_s(16), b.to_s(16), (a+b).to_s(16))
|
$logfile.printf(" ; should %s + %s << 8*%s = %s\n", a.to_s(16), b.to_s(16), scale.to_s(16), should.to_s(16))
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
return false
|
return false
|
||||||
|
@ -319,7 +330,7 @@ def square_test(a)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not /[\s]*enter a:[\s]*/.match(line)
|
end while ! /[\s]*enter a:[\s]*/.match(line)
|
||||||
$sp.print(a.to_s(16)+" ")
|
$sp.print(a.to_s(16)+" ")
|
||||||
begin
|
begin
|
||||||
line = $sp.gets()
|
line = $sp.gets()
|
||||||
|
@ -329,7 +340,7 @@ def square_test(a)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not m=/[\s]*([+-]?[0-9a-fA-F]*)[\s]*\*\*2[\s]*=[\s]*([+-]?[0-9a-fA-F]*)/.match(line)
|
end while ! m=/[\s]*([+-]?[0-9a-fA-F]*)[\s]*\*\*2[\s]*=[\s]*([+-]?[0-9a-fA-F]*)/.match(line)
|
||||||
a_ = m[1].to_i(16)
|
a_ = m[1].to_i(16)
|
||||||
c_ = m[2].to_i(16)
|
c_ = m[2].to_i(16)
|
||||||
line.chomp!
|
line.chomp!
|
||||||
|
@ -357,7 +368,7 @@ def reduce_test(a,b)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not /[\s]*enter a:[\s]*/.match(line)
|
end while ! /[\s]*enter a:[\s]*/.match(line)
|
||||||
$sp.print(a.to_s(16)+" ")
|
$sp.print(a.to_s(16)+" ")
|
||||||
begin
|
begin
|
||||||
line = $sp.gets()
|
line = $sp.gets()
|
||||||
|
@ -367,18 +378,19 @@ def reduce_test(a,b)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not /[\s]*enter b:[\s]*/.match(line)
|
end while ! /[\s]*enter b:[\s]*/.match(line)
|
||||||
$sp.print(b.to_s(16)+" ")
|
$sp.print(b.to_s(16)+" ")
|
||||||
line=''
|
line=''
|
||||||
begin
|
begin
|
||||||
line = $sp.gets()
|
line_tmp = $sp.gets()
|
||||||
line = '' if line==nil
|
line_tmp = '' if line_tmp==nil
|
||||||
|
line += line_tmp
|
||||||
puts("DBG got: "+line) if $debug
|
puts("DBG got: "+line) if $debug
|
||||||
if /^Error:.*/.match(line)
|
if /^Error:.*/.match(line)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not m=/[\s]*([+-]?[0-9a-fA-F]*)[\s]+%[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]+)/.match(line)
|
end while ! m=/[\s]*([+-]?[0-9a-fA-F]*)[\s]+%[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]+)/.match(line)
|
||||||
a_ = m[1].to_i(16)
|
a_ = m[1].to_i(16)
|
||||||
b_ = m[2].to_i(16)
|
b_ = m[2].to_i(16)
|
||||||
c_ = m[3].to_i(16)
|
c_ = m[3].to_i(16)
|
||||||
|
@ -407,7 +419,7 @@ def expmod_test(a,b,c)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not /[\s]*enter a:[\s]*/.match(line)
|
end while ! /[\s]*enter a:[\s]*/.match(line)
|
||||||
$sp.print(a.to_s(16)+" ")
|
$sp.print(a.to_s(16)+" ")
|
||||||
begin
|
begin
|
||||||
line = $sp.gets()
|
line = $sp.gets()
|
||||||
|
@ -417,7 +429,7 @@ def expmod_test(a,b,c)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not /[\s]*enter b:[\s]*/.match(line)
|
end while ! /[\s]*enter b:[\s]*/.match(line)
|
||||||
$sp.print(b.to_s(16)+" ")
|
$sp.print(b.to_s(16)+" ")
|
||||||
begin
|
begin
|
||||||
line = $sp.gets()
|
line = $sp.gets()
|
||||||
|
@ -427,18 +439,19 @@ def expmod_test(a,b,c)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not /[\s]*enter c:[\s]*/.match(line)
|
end while ! /[\s]*enter c:[\s]*/.match(line)
|
||||||
$sp.print(c.to_s(16)+" ")
|
$sp.print(c.to_s(16)+" ")
|
||||||
line=''
|
line=''
|
||||||
begin
|
begin
|
||||||
line = $sp.gets()
|
line_tmp = $sp.gets()
|
||||||
line = '' if line==nil
|
line_tmp = '' if line_tmp==nil
|
||||||
|
line += line_tmp
|
||||||
puts("DBG got: "+line) if $debug
|
puts("DBG got: "+line) if $debug
|
||||||
if /^Error:.*/.match(line)
|
if /^Error:.*/.match(line)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not m=/[\s]*([+-]?[0-9a-fA-F]*)\*\*([+-]?[0-9a-fA-F]*)[\s]+%[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]+)/.match(line)
|
end while ! m=/[\s]*([+-]?[0-9a-fA-F]*)\*\*([+-]?[0-9a-fA-F]*)[\s]+%[\s]+([+-]?[0-9a-fA-F]*)[\s]*=[\s]*([+-]?[0-9a-fA-F]+)/.match(line)
|
||||||
a_ = m[1].to_i(16)
|
a_ = m[1].to_i(16)
|
||||||
b_ = m[2].to_i(16)
|
b_ = m[2].to_i(16)
|
||||||
c_ = m[3].to_i(16)
|
c_ = m[3].to_i(16)
|
||||||
|
@ -468,7 +481,7 @@ def gcdext_test(a,b)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not /[\s]*enter a:[\s]*/.match(line)
|
end while ! /[\s]*enter a:[\s]*/.match(line)
|
||||||
$sp.print(a.to_s(16)+" ")
|
$sp.print(a.to_s(16)+" ")
|
||||||
begin
|
begin
|
||||||
line = $sp.gets()
|
line = $sp.gets()
|
||||||
|
@ -478,18 +491,20 @@ def gcdext_test(a,b)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not /[\s]*enter b:[\s]*/.match(line)
|
end while ! /[\s]*enter b:[\s]*/.match(line)
|
||||||
$sp.print(b.to_s(16)+" ")
|
$sp.print(b.to_s(16)+" ")
|
||||||
line=''
|
line=''
|
||||||
begin
|
begin
|
||||||
line = $sp.gets()
|
line_tmp = $sp.gets()
|
||||||
line = '' if line==nil
|
line_tmp = '' if line_tmp==nil
|
||||||
|
line = '' if line.end_with?('\n')
|
||||||
|
line += line_tmp
|
||||||
puts("DBG got: "+line) if $debug
|
puts("DBG got: "+line) if $debug
|
||||||
if /^Error:.*/.match(line)
|
if /^Error:.*/.match(line)
|
||||||
puts line
|
puts line
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
end while not m=/gcdext\([\s]*([+-]?[0-9a-fA-F]*)[\s]*,[\s]*([+-]?[0-9a-fA-F]*)[\s]*\)[\s]*=>[\s]*a[\s]*=[\s]*([+-]?[0-9a-fA-F]+);[\s]*b[\s]*=[\s]*([+-]?[0-9a-fA-F]+);[\s]*gcd[\s]*=[\s]*([+-]?[0-9a-fA-F]+)/.match(line)
|
end while ! m=/gcdext\([\s]*([+-]?[0-9a-fA-F]*)[\s]*,[\s]*([+-]?[0-9a-fA-F]*)[\s]*\)[\s]*=> a = ([+-]?[0-9a-fA-F]+); b = ([+-]?[0-9a-fA-F]+); gcd = ([+-]?[0-9a-fA-F]+)/.match(line)
|
||||||
a_ = m[1].to_i(16)
|
a_ = m[1].to_i(16)
|
||||||
b_ = m[2].to_i(16)
|
b_ = m[2].to_i(16)
|
||||||
c_ = m[3].to_i(16)
|
c_ = m[3].to_i(16)
|
||||||
|
@ -548,6 +563,80 @@ def run_test_add(skip=0)
|
||||||
end while length_a_B<4096/8
|
end while length_a_B<4096/8
|
||||||
end
|
end
|
||||||
|
|
||||||
|
################################################################################
|
||||||
|
# run_test_add_scale #
|
||||||
|
################################################################################
|
||||||
|
|
||||||
|
def run_test_add_scale(skip=0)
|
||||||
|
length_a_B = skip+1
|
||||||
|
length_b_B = skip+1
|
||||||
|
begin
|
||||||
|
$size = length_a_B
|
||||||
|
(0..4).each do |i|
|
||||||
|
scales = [0, 300]
|
||||||
|
16.times { scales << rand(301) }
|
||||||
|
scales.sort!
|
||||||
|
scales.each do |scale|
|
||||||
|
a = rand(256**length_a_B)
|
||||||
|
b = rand(256**length_a_B)
|
||||||
|
v = add_scale_test(a, b, scale)
|
||||||
|
screen_progress(v)
|
||||||
|
v = add_scale_test(b, a, scale)
|
||||||
|
screen_progress(v)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
(0..4).each do |i|
|
||||||
|
scales = [0, 300]
|
||||||
|
16.times { scales << rand(301) }
|
||||||
|
scales.sort!
|
||||||
|
scales.each do |scale|
|
||||||
|
b_size = rand(length_b_B+1)+1
|
||||||
|
a = rand(256**length_a_B)
|
||||||
|
b = rand(256**b_size)
|
||||||
|
v = add_scale_test(a, b, scale)
|
||||||
|
screen_progress(v)
|
||||||
|
v = add_scale_test(b, a, scale)
|
||||||
|
screen_progress(v)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
length_a_B += 10
|
||||||
|
length_b_B += 10
|
||||||
|
end while length_a_B<4096/8
|
||||||
|
end
|
||||||
|
|
||||||
|
def run_test_add_scale_dummy(skip=0)
|
||||||
|
length_a_B = skip+1
|
||||||
|
length_b_B = skip+1
|
||||||
|
begin
|
||||||
|
$size = length_a_B
|
||||||
|
(0..4).each do |i|
|
||||||
|
scales = [0, 300]
|
||||||
|
16.times { scales << rand(301) }
|
||||||
|
scales.sort!
|
||||||
|
scales.each do |scale|
|
||||||
|
a = rand(256**length_a_B)
|
||||||
|
b = rand(256**length_a_B)
|
||||||
|
v = add_scale_test_dummy(a, b, scale)
|
||||||
|
v = add_scale_test_dummy(b, a, scale)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
(0..4).each do |i|
|
||||||
|
scales = [0, 300]
|
||||||
|
16.times { scales << rand(301) }
|
||||||
|
scales.sort!
|
||||||
|
scales.each do |scale|
|
||||||
|
b_size = rand(length_b_B+1)
|
||||||
|
a = rand(256**length_a_B)
|
||||||
|
b = rand(256**b_size)
|
||||||
|
v = add_scale_test_dummy(a, b, scale)
|
||||||
|
v = add_scale_test_dummy(b, a, scale)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
length_a_B += 10
|
||||||
|
length_b_B += 10
|
||||||
|
end while length_a_B<4096/8
|
||||||
|
end
|
||||||
|
|
||||||
################################################################################
|
################################################################################
|
||||||
# run_test_mul #
|
# run_test_mul #
|
||||||
################################################################################
|
################################################################################
|
||||||
|
@ -667,7 +756,7 @@ def run_test_gcdext(skip=0)
|
||||||
begin
|
begin
|
||||||
$size = length_a_B
|
$size = length_a_B
|
||||||
(0..16).each do |i|
|
(0..16).each do |i|
|
||||||
a = rand(256**length_a_B)+1
|
a = rand(256**length_a_B)
|
||||||
b = rand(256**length_a_B)+1
|
b = rand(256**length_a_B)+1
|
||||||
v = gcdext_test(a, b)
|
v = gcdext_test(a, b)
|
||||||
$logfile.flush()
|
$logfile.flush()
|
||||||
|
@ -675,7 +764,7 @@ def run_test_gcdext(skip=0)
|
||||||
end
|
end
|
||||||
(0..16).each do |i|
|
(0..16).each do |i|
|
||||||
b_size = rand(length_b_B+1)
|
b_size = rand(length_b_B+1)
|
||||||
a = rand(256**length_a_B)+1
|
a = rand(256**length_a_B)
|
||||||
b = rand(256**b_size)+1
|
b = rand(256**b_size)+1
|
||||||
v = gcdext_test(a, b)
|
v = gcdext_test(a, b)
|
||||||
$logfile.flush()
|
$logfile.flush()
|
||||||
|
@ -686,6 +775,36 @@ def run_test_gcdext(skip=0)
|
||||||
end while length_a_B<4096/8
|
end while length_a_B<4096/8
|
||||||
end
|
end
|
||||||
|
|
||||||
|
def init_serialport(conf)
|
||||||
|
puts("serial port interface version: " + SerialPort::VERSION);
|
||||||
|
$linewidth = 64
|
||||||
|
$linepos = 0
|
||||||
|
$testno = 0
|
||||||
|
params = { "baud" => conf["PORT"]["baud"].to_i,
|
||||||
|
"data_bits" => conf["PORT"]["databits"].to_i,
|
||||||
|
"stop_bits" => conf["PORT"]["stopbits"].to_i,
|
||||||
|
"parity" => SerialPort::NONE }
|
||||||
|
params["paraty"] = SerialPort::ODD if conf["PORT"]["paraty"].downcase == "odd"
|
||||||
|
params["paraty"] = SerialPort::EVEN if conf["PORT"]["paraty"].downcase == "even"
|
||||||
|
params["paraty"] = SerialPort::MARK if conf["PORT"]["paraty"].downcase == "mark"
|
||||||
|
params["paraty"] = SerialPort::SPACE if conf["PORT"]["paraty"].downcase == "space"
|
||||||
|
|
||||||
|
puts("\nPort: "+conf["PORT"]["port"]+"@" +
|
||||||
|
params["baud"].to_s +
|
||||||
|
" " +
|
||||||
|
params["data_bits"].to_s +
|
||||||
|
conf["PORT"]["paraty"][0,1].upcase +
|
||||||
|
params["stop_bits"].to_s +
|
||||||
|
"\n")
|
||||||
|
|
||||||
|
$sp = SerialPort.new(conf["PORT"]["port"], params)
|
||||||
|
|
||||||
|
$sp.read_timeout=1000; # 5 minutes
|
||||||
|
$sp.flow_control = SerialPort::SOFT
|
||||||
|
|
||||||
|
reset_system()
|
||||||
|
end
|
||||||
|
|
||||||
################################################################################
|
################################################################################
|
||||||
# MAIN #
|
# MAIN #
|
||||||
################################################################################
|
################################################################################
|
||||||
|
@ -699,34 +818,9 @@ conf = readconfigfile("testport.conf", conf)
|
||||||
conf = readconfigfile(opts["f"], conf) if opts["f"]
|
conf = readconfigfile(opts["f"], conf) if opts["f"]
|
||||||
|
|
||||||
#puts conf.inspect
|
#puts conf.inspect
|
||||||
|
init_serialport(conf)
|
||||||
|
|
||||||
puts("serial port interface version: " + SerialPort::VERSION);
|
$max_timeout = 5 * 60
|
||||||
$linewidth = 64
|
|
||||||
$linepos = 0
|
|
||||||
$testno = 0
|
|
||||||
params = { "baud" => conf["PORT"]["baud"].to_i,
|
|
||||||
"data_bits" => conf["PORT"]["databits"].to_i,
|
|
||||||
"stop_bits" => conf["PORT"]["stopbits"].to_i,
|
|
||||||
"parity" => SerialPort::NONE }
|
|
||||||
params["paraty"] = SerialPort::ODD if conf["PORT"]["paraty"].downcase == "odd"
|
|
||||||
params["paraty"] = SerialPort::EVEN if conf["PORT"]["paraty"].downcase == "even"
|
|
||||||
params["paraty"] = SerialPort::MARK if conf["PORT"]["paraty"].downcase == "mark"
|
|
||||||
params["paraty"] = SerialPort::SPACE if conf["PORT"]["paraty"].downcase == "space"
|
|
||||||
|
|
||||||
puts("\nPort: "+conf["PORT"]["port"]+"@" +
|
|
||||||
params["baud"].to_s +
|
|
||||||
" " +
|
|
||||||
params["data_bits"].to_s +
|
|
||||||
conf["PORT"]["paraty"][0,1].upcase +
|
|
||||||
params["stop_bits"].to_s +
|
|
||||||
"\n")
|
|
||||||
|
|
||||||
$sp = SerialPort.new(conf["PORT"]["port"], params)
|
|
||||||
|
|
||||||
$sp.read_timeout=1000; # 5 minutes
|
|
||||||
$sp.flow_control = SerialPort::SOFT
|
|
||||||
|
|
||||||
reset_system()
|
|
||||||
|
|
||||||
if opts['d']
|
if opts['d']
|
||||||
$debug = true
|
$debug = true
|
||||||
|
@ -740,12 +834,16 @@ if File.exists?(logfilename)
|
||||||
i+=1
|
i+=1
|
||||||
end while(File.exists?(logfilename))
|
end while(File.exists?(logfilename))
|
||||||
while(i>2) do
|
while(i>2) do
|
||||||
File.move(sprintf('%s%04d%s', conf['PORT']['testlogbase']+'bigint_',i-2,'.txt'),
|
n1 = sprintf('%s%04d%s', conf['PORT']['testlogbase']+'bigint_',i-2,'.txt')
|
||||||
sprintf('%s%04d%s', conf['PORT']['testlogbase']+'bigint_',i-1,'.txt'), true)
|
n2 = sprintf('%s%04d%s', conf['PORT']['testlogbase']+'bigint_',i-1,'.txt')
|
||||||
|
File.rename(n1, n2)
|
||||||
|
printf("%s -> %s\n", n1, n2)
|
||||||
i-=1
|
i-=1
|
||||||
end
|
end
|
||||||
File.move(sprintf('%s%s', conf['PORT']['testlogbase'],'bigint.txt'),
|
n1 = sprintf('%s%s', conf['PORT']['testlogbase'],'bigint.txt')
|
||||||
sprintf('%s%04d%s', conf['PORT']['testlogbase']+'bigint_',1,'.txt'), true)
|
n2 = sprintf('%s%04d%s', conf['PORT']['testlogbase']+'bigint_',1,'.txt')
|
||||||
|
File.rename(n1, n2)
|
||||||
|
printf("%s -> %s\n", n1, n2)
|
||||||
logfilename = conf['PORT']['testlogbase']+'bigint.txt'
|
logfilename = conf['PORT']['testlogbase']+'bigint.txt'
|
||||||
end
|
end
|
||||||
$logfile = File.open(logfilename, 'w')
|
$logfile = File.open(logfilename, 'w')
|
||||||
|
@ -758,12 +856,14 @@ $logfile.printf("seed = 0x%X\n", 0xdeadbeef)
|
||||||
tests = Hash.new
|
tests = Hash.new
|
||||||
tests['a'] = proc {|x| run_test_add(x) }
|
tests['a'] = proc {|x| run_test_add(x) }
|
||||||
tests['m'] = proc {|x| run_test_mul(x) }
|
tests['m'] = proc {|x| run_test_mul(x) }
|
||||||
|
tests['x'] = proc {|x| run_test_add_scale(x) }
|
||||||
tests['s'] = proc {|x| run_test_square(x) }
|
tests['s'] = proc {|x| run_test_square(x) }
|
||||||
tests['r'] = proc {|x| run_test_reduce(x) }
|
tests['r'] = proc {|x| run_test_reduce(x) }
|
||||||
tests['e'] = proc {|x| run_test_expmod(x) }
|
tests['e'] = proc {|x| run_test_expmod(x) }
|
||||||
tests['g'] = proc {|x| run_test_gcdext(x) }
|
tests['g'] = proc {|x| run_test_gcdext(x) }
|
||||||
init_str = Hash.new
|
init_str = Hash.new
|
||||||
init_str['a'] = 'add-test'
|
init_str['a'] = 'add-test'
|
||||||
|
init_str['x'] = 'add-scale-test'
|
||||||
init_str['m'] = 'mul-test'
|
init_str['m'] = 'mul-test'
|
||||||
init_str['s'] = 'square-test'
|
init_str['s'] = 'square-test'
|
||||||
init_str['r'] = 'reduce-test'
|
init_str['r'] = 'reduce-test'
|
||||||
|
|
|
@ -1,7 +1,7 @@
|
||||||
#!/usr/bin/ruby
|
#!/usr/bin/ruby
|
||||||
# nessie_check.rb
|
# rsa_oaep_check.rb
|
||||||
=begin
|
=begin
|
||||||
This file is part of the ARM-Crypto-Lib.
|
This file is part of the AVR-Crypto-Lib.
|
||||||
Copyright (C) 2008 Daniel Otte (daniel.otte@rub.de)
|
Copyright (C) 2008 Daniel Otte (daniel.otte@rub.de)
|
||||||
|
|
||||||
This program is free software: you can redistribute it and/or modify
|
This program is free software: you can redistribute it and/or modify
|
||||||
|
@ -25,6 +25,8 @@ require 'getopt/std'
|
||||||
$buffer_size = 0 # set automatically in init_system
|
$buffer_size = 0 # set automatically in init_system
|
||||||
$conffile_check = Hash.new
|
$conffile_check = Hash.new
|
||||||
$conffile_check.default = 0
|
$conffile_check.default = 0
|
||||||
|
$debug = false
|
||||||
|
$logfile = nil
|
||||||
|
|
||||||
################################################################################
|
################################################################################
|
||||||
# readconfigfile #
|
# readconfigfile #
|
||||||
|
@ -38,7 +40,12 @@ def read_line_from_device()
|
||||||
l = $sp.gets()
|
l = $sp.gets()
|
||||||
repeat_counter -= 1
|
repeat_counter -= 1
|
||||||
end while !l && repeat_counter > 0
|
end while !l && repeat_counter > 0
|
||||||
# printf("DBG: << %s\n", l.inspect)
|
t = Time.new
|
||||||
|
$logfile.printf("DBG: (%02d:%02d:%02d)<< %s\n", t.hour, t.min, t.sec, l.inspect) if $debug
|
||||||
|
if l && l.include?("AVR-Crypto-Lib")
|
||||||
|
$logfile.printf("DBG: system crashed !!!\n")
|
||||||
|
exit(false)
|
||||||
|
end
|
||||||
return l
|
return l
|
||||||
end
|
end
|
||||||
|
|
||||||
|
@ -202,24 +209,59 @@ def read_tv(f)
|
||||||
return h
|
return h
|
||||||
end
|
end
|
||||||
|
|
||||||
|
def wait_for_dot
|
||||||
|
begin
|
||||||
|
s = $sp.gets()
|
||||||
|
end while !s || !s.include?('.')
|
||||||
|
end
|
||||||
|
|
||||||
def load_bigint(d)
|
def load_bigint(d)
|
||||||
$sp.printf("%d\r", d.length)
|
$sp.printf("%d\r", d.length)
|
||||||
while l = read_line_from_device()
|
while l = read_line_from_device()
|
||||||
break if /data:/.match(l)
|
break if /data:/.match(l)
|
||||||
end
|
end
|
||||||
printf "ERROR: got no answer from system!" if !l
|
printf "ERROR: got no answer from system!" if !l
|
||||||
|
i = 0
|
||||||
d.each do |e|
|
d.each do |e|
|
||||||
$sp.printf(" %02x", e)
|
$sp.printf("%02x", e)
|
||||||
|
i += 1
|
||||||
|
if i % 60 == 0
|
||||||
|
# we should now wait for incomming dot
|
||||||
|
wait_for_dot()
|
||||||
|
print('.')
|
||||||
|
end
|
||||||
end
|
end
|
||||||
end
|
end
|
||||||
|
|
||||||
|
def hexdump(a)
|
||||||
|
i = 0
|
||||||
|
a.each do |e|
|
||||||
|
printf("\n\t") if i % 16 == 0
|
||||||
|
printf('%02x ', e)
|
||||||
|
i += 1
|
||||||
|
end
|
||||||
|
puts('') if i % 16 != 1
|
||||||
|
end
|
||||||
|
|
||||||
|
def str_hexdump(a)
|
||||||
|
i = 0
|
||||||
|
s = ''
|
||||||
|
a.each do |e|
|
||||||
|
s += "\n\t" if i % 16 == 0
|
||||||
|
s += sprintf('%02x ', e)
|
||||||
|
i += 1
|
||||||
|
end
|
||||||
|
s += "\n" if i % 16 != 1
|
||||||
|
return s
|
||||||
|
end
|
||||||
|
|
||||||
def load_key(k)
|
def load_key(k)
|
||||||
$sp.print("load-key\r")
|
$sp.print("load-key\r")
|
||||||
sleep 0.1
|
sleep 0.1
|
||||||
v = ['n', 'e', 'p', 'q', 'dP', 'dQ', 'qInv']
|
v = ['n', 'e', 'p', 'q', 'dP', 'dQ', 'qInv']
|
||||||
v.each do |e|
|
v.each do |e|
|
||||||
load_bigint(k[e])
|
load_bigint(k[e])
|
||||||
# printf("DBG: loaded %s\n", e)
|
$logfile.printf("DBG: loaded %s\n", e) if $debug
|
||||||
end
|
end
|
||||||
while l = read_line_from_device()
|
while l = read_line_from_device()
|
||||||
break if />/.match(l)
|
break if />/.match(l)
|
||||||
|
@ -231,7 +273,7 @@ def check_tv(tv)
|
||||||
$sp.print("seed-test\r")
|
$sp.print("seed-test\r")
|
||||||
sleep 0.1
|
sleep 0.1
|
||||||
load_bigint(tv['msg'])
|
load_bigint(tv['msg'])
|
||||||
# printf("DBG: loaded %s\n", 'msg')
|
$logfile.printf("DBG: loaded %s\n", 'msg') if $debug
|
||||||
sleep 0.1
|
sleep 0.1
|
||||||
tv['seed'].each { |e| $sp.printf(" %02x", e) }
|
tv['seed'].each { |e| $sp.printf(" %02x", e) }
|
||||||
while l = read_line_from_device()
|
while l = read_line_from_device()
|
||||||
|
@ -240,7 +282,7 @@ def check_tv(tv)
|
||||||
test_enc = ''
|
test_enc = ''
|
||||||
loop do
|
loop do
|
||||||
l = read_line_from_device()
|
l = read_line_from_device()
|
||||||
break if /decrypting/.match(l)
|
break if ! /([0-9A-Fa-f]{2}\s*)+/.match(l)
|
||||||
test_enc += l if l
|
test_enc += l if l
|
||||||
end
|
end
|
||||||
test_enc_a = Array.new
|
test_enc_a = Array.new
|
||||||
|
@ -252,7 +294,7 @@ def check_tv(tv)
|
||||||
test_enc_a.collect!{ |e| e.to_i(16) }
|
test_enc_a.collect!{ |e| e.to_i(16) }
|
||||||
enc_ok = (test_enc_a == tv['enc'])
|
enc_ok = (test_enc_a == tv['enc'])
|
||||||
if !enc_ok
|
if !enc_ok
|
||||||
printf("DBG: ref = %s test = %s\n", tv['enc'].inspect , test_enc_a.inspect)
|
$logfile.printf("DBG: ref = %s test = %s\n", str_hexdump(tv['enc']) , str_hexdump(test_enc_a))
|
||||||
end
|
end
|
||||||
m = nil
|
m = nil
|
||||||
loop do
|
loop do
|
||||||
|
@ -264,13 +306,15 @@ def check_tv(tv)
|
||||||
return false
|
return false
|
||||||
end
|
end
|
||||||
|
|
||||||
def run_test(f)
|
def run_test(f,skip_key=1,skip_vec=1)
|
||||||
ok = 0
|
ok = 0
|
||||||
fail = 0
|
fail = 0
|
||||||
|
key_idx = 0
|
||||||
|
vec_idx = 0
|
||||||
skip_file_header(f)
|
skip_file_header(f)
|
||||||
loop do
|
loop do
|
||||||
a,b = goto_next_header(f)
|
a,b = goto_next_header(f)
|
||||||
# printf("DBG: a=%s b=%s\n", a.inspect, b.inspect)
|
$logfile.printf("DBG: a=%s b=%s\n", a.inspect, b.inspect) if $debug
|
||||||
return ok,fail if !b
|
return ok,fail if !b
|
||||||
if a == :mainblock
|
if a == :mainblock
|
||||||
# Example 1: A 1024-bit RSA Key Pair
|
# Example 1: A 1024-bit RSA Key Pair
|
||||||
|
@ -281,17 +325,24 @@ def run_test(f)
|
||||||
if a == :subblock
|
if a == :subblock
|
||||||
if b == 'Components of the RSA Key Pair'
|
if b == 'Components of the RSA Key Pair'
|
||||||
k = read_key(f)
|
k = read_key(f)
|
||||||
load_key(k)
|
key_idx += 1
|
||||||
|
vec_idx = 0
|
||||||
|
load_key(k) if skip_key <= key_idx
|
||||||
else
|
else
|
||||||
tv = read_tv(f)
|
tv = read_tv(f)
|
||||||
r = check_tv(tv)
|
vec_idx += 1
|
||||||
if r
|
if (key_idx > skip_key) || (key_idx == skip_key && vec_idx >= skip_vec)
|
||||||
ok += 1
|
r = check_tv(tv)
|
||||||
putc('*')
|
if r
|
||||||
|
ok += 1
|
||||||
|
putc('*')
|
||||||
|
else
|
||||||
|
fail += 1
|
||||||
|
putc('!')
|
||||||
|
end
|
||||||
else
|
else
|
||||||
fail += 1
|
putc('o')
|
||||||
putc('!')
|
end
|
||||||
end
|
|
||||||
end
|
end
|
||||||
end
|
end
|
||||||
end
|
end
|
||||||
|
@ -302,7 +353,7 @@ end
|
||||||
########################################
|
########################################
|
||||||
|
|
||||||
|
|
||||||
opts = Getopt::Std.getopts("c:f:")
|
opts = Getopt::Std.getopts("dc:f:il:s:")
|
||||||
|
|
||||||
conf = Hash.new
|
conf = Hash.new
|
||||||
conf = readconfigfile("/etc/testport.conf", conf)
|
conf = readconfigfile("/etc/testport.conf", conf)
|
||||||
|
@ -336,11 +387,27 @@ $sp = SerialPort.new(conf["PORT"]["port"], params)
|
||||||
$sp.read_timeout=1000; # 5 minutes
|
$sp.read_timeout=1000; # 5 minutes
|
||||||
$sp.flow_control = SerialPort::SOFT
|
$sp.flow_control = SerialPort::SOFT
|
||||||
|
|
||||||
|
$debug = true if opts['d']
|
||||||
|
|
||||||
|
if opts['s'] && m = opts['s'].match(/([\d]+\.([\d]+))/)
|
||||||
|
sk = m[1].to_i
|
||||||
|
sv = m[2].to_i
|
||||||
|
else
|
||||||
|
sk = 1
|
||||||
|
sv = 1
|
||||||
|
end
|
||||||
|
|
||||||
|
if opts['l']
|
||||||
|
$logfile = File.open(opts['l'], 'w')
|
||||||
|
end
|
||||||
|
|
||||||
|
$logfile = STDOUT if ! $logfile
|
||||||
|
$logfile.sync = true
|
||||||
reset_system()
|
reset_system()
|
||||||
|
|
||||||
f = File.open(opts['f'], "r")
|
f = File.open(opts['f'], "r")
|
||||||
exit if !f
|
exit if !f
|
||||||
ok,fail = run_test(f)
|
ok,fail = run_test(f,sk,sv)
|
||||||
printf("\nOK: %d FAIL: %d :-%s\n",ok,fail, fail==0 ? ')':'(')
|
printf("\nOK: %d FAIL: %d :-%s\n",ok,fail, fail==0 ? ')':'(')
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -0,0 +1,390 @@
|
||||||
|
#!/usr/bin/ruby
|
||||||
|
# rsa_pkcs15_check.rb
|
||||||
|
=begin
|
||||||
|
This file is part of the AVR-Crypto-Lib.
|
||||||
|
Copyright (C) 2008 Daniel Otte (daniel.otte@rub.de)
|
||||||
|
|
||||||
|
This program is free software: you can redistribute it and/or modify
|
||||||
|
it under the terms of the GNU General Public License as published by
|
||||||
|
the Free Software Foundation, either version 3 of the License, or
|
||||||
|
(at your option) any later version.
|
||||||
|
|
||||||
|
This program is distributed in the hope that it will be useful,
|
||||||
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
GNU General Public License for more details.
|
||||||
|
|
||||||
|
You should have received a copy of the GNU General Public License
|
||||||
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
=end
|
||||||
|
|
||||||
|
require 'rubygems'
|
||||||
|
require 'serialport'
|
||||||
|
require 'getopt/std'
|
||||||
|
|
||||||
|
$buffer_size = 0 # set automatically in init_system
|
||||||
|
$conffile_check = Hash.new
|
||||||
|
$conffile_check.default = 0
|
||||||
|
$debug = false
|
||||||
|
$logfile = nil
|
||||||
|
|
||||||
|
################################################################################
|
||||||
|
# readconfigfile #
|
||||||
|
################################################################################
|
||||||
|
|
||||||
|
def read_line_from_device()
|
||||||
|
repeat_counter = 10000
|
||||||
|
l = nil
|
||||||
|
s = ''
|
||||||
|
begin
|
||||||
|
l = $sp.gets()
|
||||||
|
repeat_counter -= 1
|
||||||
|
end while !l && repeat_counter > 0
|
||||||
|
t = Time.new
|
||||||
|
$logfile.printf("DBG: (%02d:%02d:%02d)<< %s\n", t.hour, t.min, t.sec, l.inspect) if $debug
|
||||||
|
if l && l.include?("AVR-Crypto-Lib")
|
||||||
|
$logfile.printf("DBG: system crashed !!!\n")
|
||||||
|
exit(false)
|
||||||
|
end
|
||||||
|
return l
|
||||||
|
end
|
||||||
|
|
||||||
|
def readconfigfile(fname, conf)
|
||||||
|
return conf if $conffile_check[fname]==1
|
||||||
|
$conffile_check[fname]=1
|
||||||
|
section = "default"
|
||||||
|
if not File.exists?(fname)
|
||||||
|
return conf
|
||||||
|
end
|
||||||
|
file = File.open(fname, "r")
|
||||||
|
until file.eof
|
||||||
|
line = file.gets()
|
||||||
|
next if /[\s]*#/.match(line)
|
||||||
|
if m=/\[[\s]*([^\s]*)[\s]*\]/.match(line)
|
||||||
|
section=m[1]
|
||||||
|
conf[m[1]] = Hash.new
|
||||||
|
next
|
||||||
|
end
|
||||||
|
next if ! /=/.match(line)
|
||||||
|
m=/[\s]*([^\s]*)[\s]*=[\s]*([^\s]*)/.match(line)
|
||||||
|
if m[1]=="include"
|
||||||
|
Dir.glob(m[2]){ |fn| conf = readconfigfile(fn, conf) }
|
||||||
|
else
|
||||||
|
conf[section][m[1]] = m[2]
|
||||||
|
end
|
||||||
|
end
|
||||||
|
file.close()
|
||||||
|
return conf
|
||||||
|
end
|
||||||
|
|
||||||
|
################################################################################
|
||||||
|
# reset_system #
|
||||||
|
################################################################################
|
||||||
|
|
||||||
|
def reset_system
|
||||||
|
$sp.print("\r")
|
||||||
|
sleep 0.1
|
||||||
|
$sp.print("\r")
|
||||||
|
sleep 0.1
|
||||||
|
$sp.print("echo off\r")
|
||||||
|
sleep 0.1
|
||||||
|
end
|
||||||
|
|
||||||
|
|
||||||
|
def read_block(f)
|
||||||
|
d = Array.new
|
||||||
|
begin
|
||||||
|
l = f.gets
|
||||||
|
x = l.split.collect { |e| e.to_i(16) }
|
||||||
|
d += x
|
||||||
|
end while x.length == 16
|
||||||
|
return d
|
||||||
|
end
|
||||||
|
|
||||||
|
=begin
|
||||||
|
# Modulus:
|
||||||
|
# Exponent:
|
||||||
|
# Modulus:
|
||||||
|
# Public exponent:
|
||||||
|
# Exponent:
|
||||||
|
# Prime 1:
|
||||||
|
# Prime 2:
|
||||||
|
# Prime exponent 1:
|
||||||
|
# Prime exponent 2:
|
||||||
|
# Coefficient:
|
||||||
|
# Message:
|
||||||
|
# Seed:
|
||||||
|
# Encryption:
|
||||||
|
|
||||||
|
=end
|
||||||
|
|
||||||
|
def get_next_block(f)
|
||||||
|
ret = Hash.new
|
||||||
|
data = Array.new
|
||||||
|
begin
|
||||||
|
l = f.gets
|
||||||
|
end while l && ! m= l.match(/^#[\s](.*):[\s]*$/)
|
||||||
|
return nil if ! l
|
||||||
|
ret['tag'] = m[1]
|
||||||
|
ret['line'] = f.lineno
|
||||||
|
data = read_block(f)
|
||||||
|
ret['data'] = data
|
||||||
|
return ret
|
||||||
|
end
|
||||||
|
|
||||||
|
$key_sequence = [
|
||||||
|
'Modulus', # 0
|
||||||
|
'Exponent', # 1
|
||||||
|
'Modulus', # 2
|
||||||
|
'Public exponent', # 3
|
||||||
|
'Exponent', # 4
|
||||||
|
'Prime 1', # 5
|
||||||
|
'Prime 2', # 6
|
||||||
|
'Prime exponent 1', # 7
|
||||||
|
'Prime exponent 2', # 8
|
||||||
|
'Coefficient', # 9
|
||||||
|
]
|
||||||
|
|
||||||
|
def key_consitency_check(k)
|
||||||
|
return true
|
||||||
|
end
|
||||||
|
|
||||||
|
def process_file(f, skip_key=1, skip_vec=1)
|
||||||
|
a = get_next_block(f)
|
||||||
|
key_no = 0
|
||||||
|
ok_counter = 0
|
||||||
|
fail_counter = 0
|
||||||
|
begin
|
||||||
|
if !a || ! a['tag'] == 'Modulus'
|
||||||
|
printf("ERROR: a = %s %d\n", a.inspect, __LINE__)
|
||||||
|
return
|
||||||
|
end
|
||||||
|
k_seq = Array.new
|
||||||
|
k_seq[0] = a
|
||||||
|
(1..($key_sequence.length-1)).each do |i|
|
||||||
|
a = get_next_block(f)
|
||||||
|
if ! a || a['tag'] != $key_sequence[i]
|
||||||
|
printf("ERROR: (expecting: %s) a = %s %d\n", $key_sequence[i], a.inspect, __LINE__)
|
||||||
|
end
|
||||||
|
k_seq[i] = a
|
||||||
|
end
|
||||||
|
key = convert_key(k_seq)
|
||||||
|
printf("ERROR: %d\n", __LINE__) if ! key
|
||||||
|
key_no += 1
|
||||||
|
vec_no = 0
|
||||||
|
printf("\n run %3d: ", key_no)
|
||||||
|
skip_key_flag = (key_no < skip_key)
|
||||||
|
load_key(key) if ! skip_key_flag
|
||||||
|
test_seq = Array.new
|
||||||
|
a = get_next_block(f)
|
||||||
|
printf("ERROR: %d\n", __LINE__) if ! a
|
||||||
|
begin
|
||||||
|
vec_no += 1
|
||||||
|
b = get_next_block(f)
|
||||||
|
c = get_next_block(f)
|
||||||
|
tv = Hash.new
|
||||||
|
tv['msg'] = a['data']
|
||||||
|
tv['seed'] = b['data']
|
||||||
|
tv['enc'] = c['data']
|
||||||
|
skip_vec_flag = (skip_key_flag || (key_no == skip_key && vec_no < skip_vec))
|
||||||
|
if skip_vec_flag
|
||||||
|
printf('o')
|
||||||
|
else
|
||||||
|
v = check_tv(tv)
|
||||||
|
if(v == true)
|
||||||
|
printf('*')
|
||||||
|
$logfile.printf("[[Test %2d.%02d = OK]]\n", key_no, vec_no)
|
||||||
|
ok_counter += 1
|
||||||
|
else
|
||||||
|
printf('%c', v ? '*' : '!')
|
||||||
|
$logfile.printf("[[Test %2d.%02d = FAIL]]\n", key_no, vec_no)
|
||||||
|
fail_counter += 1
|
||||||
|
end
|
||||||
|
end
|
||||||
|
a = get_next_block(f)
|
||||||
|
end while a && a['tag'] == 'Message'
|
||||||
|
end while a && a['tag'] = 'Modulus'
|
||||||
|
# printf("\nResult: %d OK / %d FAIL ==> %s \nFinished\n", ok_counter, fail_counter, fail_counter==0 ? ':-)' : ':-(')
|
||||||
|
return ok_counter,fail_counter
|
||||||
|
end
|
||||||
|
|
||||||
|
def convert_key(k_seq)
|
||||||
|
l = ['n', 'e', 'd', 'p', 'q', 'dP', 'dQ', 'qInv']
|
||||||
|
r = Hash.new
|
||||||
|
return nil if k_seq[0]['data'] != k_seq[2]['data']
|
||||||
|
return nil if k_seq[1]['data'] != k_seq[3]['data']
|
||||||
|
8.times do |i|
|
||||||
|
r[l[i]] = k_seq[2 + i]['data']
|
||||||
|
end
|
||||||
|
return r
|
||||||
|
end
|
||||||
|
|
||||||
|
def wait_for_dot
|
||||||
|
begin
|
||||||
|
s = $sp.gets()
|
||||||
|
end while !s || !s.include?('.')
|
||||||
|
end
|
||||||
|
|
||||||
|
def load_bigint(d)
|
||||||
|
$sp.printf("%d\r", d.length)
|
||||||
|
while l = read_line_from_device()
|
||||||
|
break if /data:/.match(l)
|
||||||
|
end
|
||||||
|
printf "ERROR: got no answer from system!" if !l
|
||||||
|
i = 0
|
||||||
|
d.each do |e|
|
||||||
|
$sp.printf("%02x", e)
|
||||||
|
i += 1
|
||||||
|
if i % 60 == 0
|
||||||
|
# we should now wait for incomming dot
|
||||||
|
wait_for_dot()
|
||||||
|
print('.')
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def hexdump(a)
|
||||||
|
i = 0
|
||||||
|
a.each do |e|
|
||||||
|
printf("\n\t") if i % 16 == 0
|
||||||
|
printf('%02x ', e)
|
||||||
|
i += 1
|
||||||
|
end
|
||||||
|
puts('') if i % 16 != 1
|
||||||
|
end
|
||||||
|
|
||||||
|
def str_hexdump(a)
|
||||||
|
i = 0
|
||||||
|
s = ''
|
||||||
|
a.each do |e|
|
||||||
|
s += "\n\t" if i % 16 == 0
|
||||||
|
s += sprintf('%02x ', e)
|
||||||
|
i += 1
|
||||||
|
end
|
||||||
|
s += "\n" if i % 16 != 1
|
||||||
|
return s
|
||||||
|
end
|
||||||
|
|
||||||
|
def load_key(k)
|
||||||
|
$sp.print("load-key\r")
|
||||||
|
sleep 0.1
|
||||||
|
v = ['n', 'e', 'p', 'q', 'dP', 'dQ', 'qInv']
|
||||||
|
v.each do |e|
|
||||||
|
load_bigint(k[e])
|
||||||
|
$logfile.printf("DBG: loaded %s\n", e) if $debug
|
||||||
|
end
|
||||||
|
while l = read_line_from_device()
|
||||||
|
break if />/.match(l)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def strip_leading_zeros(a)
|
||||||
|
loop do
|
||||||
|
return [] if a.length == 0
|
||||||
|
return a if a[0] != 0
|
||||||
|
a.delete_at(0)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
def check_tv(tv)
|
||||||
|
sleep 0.1
|
||||||
|
$sp.print("seed-test\r")
|
||||||
|
sleep 0.1
|
||||||
|
load_bigint(tv['msg'])
|
||||||
|
$logfile.printf("DBG: loaded %s\n", 'msg') if $debug
|
||||||
|
sleep 0.1
|
||||||
|
tv['seed'].each { |e| $sp.printf(" %02x", e) }
|
||||||
|
while l = read_line_from_device()
|
||||||
|
break if /ciphertext:/.match(l)
|
||||||
|
end
|
||||||
|
test_enc = ''
|
||||||
|
loop do
|
||||||
|
l = read_line_from_device()
|
||||||
|
break if ! /([0-9A-Fa-f]{2}\s*)+/.match(l)
|
||||||
|
test_enc += l if l
|
||||||
|
end
|
||||||
|
test_enc_a = Array.new
|
||||||
|
test_enc = test_enc.split(/[\W\r\n]+/)
|
||||||
|
test_enc.each do |e|
|
||||||
|
v = e.sub(/[^0-9A-Fa-f]/, '')
|
||||||
|
test_enc_a << v if v.length == 2
|
||||||
|
end
|
||||||
|
test_enc_a.collect!{ |e| e.to_i(16) }
|
||||||
|
strip_leading_zeros(test_enc_a)
|
||||||
|
strip_leading_zeros(tv['enc'])
|
||||||
|
enc_ok = (test_enc_a == tv['enc'])
|
||||||
|
if !enc_ok
|
||||||
|
$logfile.printf("DBG: ref = %s test = %s\n", str_hexdump(tv['enc']) , str_hexdump(test_enc_a))
|
||||||
|
end
|
||||||
|
m = nil
|
||||||
|
loop do
|
||||||
|
l = read_line_from_device()
|
||||||
|
m = /(>>OK<<|ERROR)/.match(l)
|
||||||
|
break if m
|
||||||
|
end
|
||||||
|
return true if enc_ok && (m[1] == '>>OK<<')
|
||||||
|
return false
|
||||||
|
end
|
||||||
|
|
||||||
|
########################################
|
||||||
|
# MAIN
|
||||||
|
########################################
|
||||||
|
|
||||||
|
|
||||||
|
opts = Getopt::Std.getopts('dc:f:il:s:')
|
||||||
|
|
||||||
|
conf = Hash.new
|
||||||
|
conf = readconfigfile("/etc/testport.conf", conf)
|
||||||
|
conf = readconfigfile("~/.testport.conf", conf)
|
||||||
|
conf = readconfigfile("testport.conf", conf)
|
||||||
|
conf = readconfigfile(opts["c"], conf) if opts["c"]
|
||||||
|
|
||||||
|
#puts conf.inspect
|
||||||
|
|
||||||
|
puts("serial port interface version: " + SerialPort::VERSION);
|
||||||
|
$linewidth = 64
|
||||||
|
params = { "baud" => conf["PORT"]["baud"].to_i,
|
||||||
|
"data_bits" => conf["PORT"]["databits"].to_i,
|
||||||
|
"stop_bits" => conf["PORT"]["stopbits"].to_i,
|
||||||
|
"parity" => SerialPort::NONE }
|
||||||
|
params["paraty"] = SerialPort::ODD if conf["PORT"]["paraty"].downcase == "odd"
|
||||||
|
params["paraty"] = SerialPort::EVEN if conf["PORT"]["paraty"].downcase == "even"
|
||||||
|
params["paraty"] = SerialPort::MARK if conf["PORT"]["paraty"].downcase == "mark"
|
||||||
|
params["paraty"] = SerialPort::SPACE if conf["PORT"]["paraty"].downcase == "space"
|
||||||
|
|
||||||
|
puts("\nPort: "+conf["PORT"]["port"]+"@" +
|
||||||
|
params["baud"].to_s +
|
||||||
|
" " +
|
||||||
|
params["data_bits"].to_s +
|
||||||
|
conf["PORT"]["paraty"][0,1].upcase +
|
||||||
|
params["stop_bits"].to_s +
|
||||||
|
"\n")
|
||||||
|
|
||||||
|
$sp = SerialPort.new(conf["PORT"]["port"], params)
|
||||||
|
|
||||||
|
$sp.read_timeout=1000; # 5 minutes
|
||||||
|
$sp.flow_control = SerialPort::SOFT
|
||||||
|
|
||||||
|
$debug = true if opts['d']
|
||||||
|
|
||||||
|
if opts['l']
|
||||||
|
$logfile = File.open(opts['l'], 'w')
|
||||||
|
end
|
||||||
|
|
||||||
|
$logfile = STDOUT if ! $logfile
|
||||||
|
reset_system()
|
||||||
|
|
||||||
|
if opts['s'] && m = opts['s'].match(/([\d]+\.([\d]+))/)
|
||||||
|
sk = m[1].to_i
|
||||||
|
sv = m[2].to_i
|
||||||
|
else
|
||||||
|
sk = 1
|
||||||
|
sv = 1
|
||||||
|
end
|
||||||
|
|
||||||
|
f = File.open(opts['f'], "r")
|
||||||
|
exit if !f
|
||||||
|
ok,fail = process_file(f,sk,sv)
|
||||||
|
printf("\nOK: %d FAIL: %d :-%s\n",ok,fail, fail==0 ? ')':'(')
|
||||||
|
|
||||||
|
|
|
@ -24,8 +24,12 @@
|
||||||
#include "bigint_io.h"
|
#include "bigint_io.h"
|
||||||
#include "rsa_basic.h"
|
#include "rsa_basic.h"
|
||||||
|
|
||||||
|
#define DEBUG 0
|
||||||
|
|
||||||
|
#if DEBUG
|
||||||
#include "cli.h"
|
#include "cli.h"
|
||||||
#include "uart_lowlevel.h"
|
#include "uart_lowlevel.h"
|
||||||
|
#endif
|
||||||
|
|
||||||
void rsa_enc(bigint_t* data, rsa_publickey_t* key){
|
void rsa_enc(bigint_t* data, rsa_publickey_t* key){
|
||||||
/*
|
/*
|
||||||
|
@ -52,18 +56,29 @@ uint8_t rsa_dec_crt_mono(bigint_t* data, rsa_privatekey_t* key){
|
||||||
m1.wordv = malloc(key->components[0]->length_B * sizeof(bigint_word_t));
|
m1.wordv = malloc(key->components[0]->length_B * sizeof(bigint_word_t));
|
||||||
m2.wordv = malloc(key->components[1]->length_B * sizeof(bigint_word_t));
|
m2.wordv = malloc(key->components[1]->length_B * sizeof(bigint_word_t));
|
||||||
if(!m1.wordv || !m2.wordv){
|
if(!m1.wordv || !m2.wordv){
|
||||||
|
#if DEBUG
|
||||||
cli_putstr("\r\nERROR: OOM!");
|
cli_putstr("\r\nERROR: OOM!");
|
||||||
|
#endif
|
||||||
free(m1.wordv);
|
free(m1.wordv);
|
||||||
free(m2.wordv);
|
free(m2.wordv);
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
#if DEBUG
|
||||||
|
cli_putstr("\r\nDBG: expmod m1 ...");
|
||||||
|
#endif
|
||||||
bigint_expmod_u(&m1, data, key->components[2], key->components[0]);
|
bigint_expmod_u(&m1, data, key->components[2], key->components[0]);
|
||||||
|
#if DEBUG
|
||||||
|
cli_putstr("expmod m2 ...");
|
||||||
|
#endif
|
||||||
bigint_expmod_u(&m2, data, key->components[3], key->components[1]);
|
bigint_expmod_u(&m2, data, key->components[3], key->components[1]);
|
||||||
bigint_sub_s(&m1, &m1, &m2);
|
bigint_sub_s(&m1, &m1, &m2);
|
||||||
while(BIGINT_NEG_MASK & m1.info){
|
while(BIGINT_NEG_MASK & m1.info){
|
||||||
bigint_add_s(&m1, &m1, key->components[0]);
|
bigint_add_s(&m1, &m1, key->components[0]);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#if DEBUG
|
||||||
|
cli_putstr("\r\nDBG: reduce-mul ...");
|
||||||
|
#endif
|
||||||
bigint_reduce(&m1, key->components[0]);
|
bigint_reduce(&m1, key->components[0]);
|
||||||
bigint_mul_u(data, &m1, key->components[4]);
|
bigint_mul_u(data, &m1, key->components[4]);
|
||||||
bigint_reduce(data, key->components[0]);
|
bigint_reduce(data, key->components[0]);
|
||||||
|
|
|
@ -117,7 +117,6 @@ uint8_t rsa_encrypt_oaep(void* dest, uint16_t* out_length,
|
||||||
// cli_hexdump_block(dest, bigint_length_B(key->modulus), 4, 16);
|
// cli_hexdump_block(dest, bigint_length_B(key->modulus), 4, 16);
|
||||||
|
|
||||||
x.wordv = dest;
|
x.wordv = dest;
|
||||||
x.length_B = key->modulus->length_B;
|
|
||||||
bigint_adjust(&x);
|
bigint_adjust(&x);
|
||||||
|
|
||||||
rsa_os2ip(&x, NULL, bigint_length_B(key->modulus));
|
rsa_os2ip(&x, NULL, bigint_length_B(key->modulus));
|
||||||
|
|
|
@ -23,8 +23,12 @@
|
||||||
#include "bigint.h"
|
#include "bigint.h"
|
||||||
#include "rsa_basic.h"
|
#include "rsa_basic.h"
|
||||||
|
|
||||||
|
#define DEBUG 0
|
||||||
|
|
||||||
|
#if DEBUG
|
||||||
#include "bigint_io.h"
|
#include "bigint_io.h"
|
||||||
#include "cli.h"
|
#include "cli.h"
|
||||||
|
#endif
|
||||||
|
|
||||||
#include "random_dummy.h"
|
#include "random_dummy.h"
|
||||||
|
|
||||||
|
@ -34,8 +38,10 @@ uint8_t rsa_encrypt_pkcs15(void* dest, uint16_t* out_length, const void* src,
|
||||||
bigint_t x;
|
bigint_t x;
|
||||||
pad_length = (bigint_get_first_set_bit(key->modulus) + 7) / 8 - length_B - 3;
|
pad_length = (bigint_get_first_set_bit(key->modulus) + 7) / 8 - length_B - 3;
|
||||||
if(pad_length<8){
|
if(pad_length<8){
|
||||||
|
#if DEBUG
|
||||||
cli_putstr("\r\nERROR: pad_length<8; pad_length: ");
|
cli_putstr("\r\nERROR: pad_length<8; pad_length: ");
|
||||||
cli_hexdump_rev(&pad_length, 2);
|
cli_hexdump_rev(&pad_length, 2);
|
||||||
|
#endif
|
||||||
return 2; /* message to long */
|
return 2; /* message to long */
|
||||||
}
|
}
|
||||||
if(!pad){
|
if(!pad){
|
||||||
|
@ -69,9 +75,13 @@ uint8_t rsa_decrypt_pkcs15(void* dest, uint16_t* out_length, const void* src,
|
||||||
uint16_t m_length, pad_length=0, idx=0;
|
uint16_t m_length, pad_length=0, idx=0;
|
||||||
x.wordv = dest;
|
x.wordv = dest;
|
||||||
rsa_os2ip(&x, src, length_B);
|
rsa_os2ip(&x, src, length_B);
|
||||||
|
#if DEBUG
|
||||||
cli_putstr("\r\ncalling rsa_dec() ...");
|
cli_putstr("\r\ncalling rsa_dec() ...");
|
||||||
|
#endif
|
||||||
rsa_dec(&x, key);
|
rsa_dec(&x, key);
|
||||||
|
#if DEBUG
|
||||||
cli_putstr("\r\nfinished rsa_dec() ...");
|
cli_putstr("\r\nfinished rsa_dec() ...");
|
||||||
|
#endif
|
||||||
rsa_i2osp(NULL, &x, &m_length);
|
rsa_i2osp(NULL, &x, &m_length);
|
||||||
while(((uint8_t*)x.wordv)[idx]==0 && idx<m_length){
|
while(((uint8_t*)x.wordv)[idx]==0 && idx<m_length){
|
||||||
++idx;
|
++idx;
|
||||||
|
@ -87,10 +97,10 @@ uint8_t rsa_decrypt_pkcs15(void* dest, uint16_t* out_length, const void* src,
|
||||||
return 2;
|
return 2;
|
||||||
}
|
}
|
||||||
*out_length = m_length - idx - pad_length - 1;
|
*out_length = m_length - idx - pad_length - 1;
|
||||||
memcpy(dest, ((uint8_t*)x.wordv) + idx + pad_length + 1, m_length - idx - pad_length - 1);
|
|
||||||
if(pad){
|
if(pad){
|
||||||
memcpy(pad, ((uint8_t*)x.wordv)+idx, pad_length);
|
memcpy(pad, ((uint8_t*)x.wordv)+idx, pad_length);
|
||||||
}
|
}
|
||||||
|
memcpy(dest, ((uint8_t*)x.wordv) + idx + pad_length + 1, m_length - idx - pad_length - 1);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -124,15 +124,15 @@ void test_add_scale_bigint(void){
|
||||||
cli_hexdump_rev(&scale, 2);
|
cli_hexdump_rev(&scale, 2);
|
||||||
cli_putstr(" = ");
|
cli_putstr(" = ");
|
||||||
bigint_word_t *c_b;
|
bigint_word_t *c_b;
|
||||||
c_b = malloc(((a.length_B>(b.length_B+scale))?a.length_B:(b.length_B+scale))*sizeof(bigint_word_t)+8);
|
c_b = malloc((((a.length_B>(b.length_B+scale))?a.length_B:(b.length_B+scale))+1)*sizeof(bigint_word_t));
|
||||||
if(c_b==NULL){
|
if(c_b==NULL){
|
||||||
cli_putstr("\n\rERROR: Out of memory!");
|
cli_putstr("\n\rERROR: Out of memory!");
|
||||||
free(a.wordv);
|
free(a.wordv);
|
||||||
free(b.wordv);
|
free(b.wordv);
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
bigint_copy(&c, &a);
|
|
||||||
c.wordv = c_b;
|
c.wordv = c_b;
|
||||||
|
bigint_copy(&c, &a);
|
||||||
bigint_add_scale_u(&c, &b, scale);
|
bigint_add_scale_u(&c, &b, scale);
|
||||||
bigint_print_hex(&c);
|
bigint_print_hex(&c);
|
||||||
cli_putstr("\r\n");
|
cli_putstr("\r\n");
|
||||||
|
|
|
@ -40,7 +40,7 @@ const char* algo_name = "RSA-OAEP";
|
||||||
/*****************************************************************************
|
/*****************************************************************************
|
||||||
* additional validation-functions *
|
* additional validation-functions *
|
||||||
*****************************************************************************/
|
*****************************************************************************/
|
||||||
|
#if 0
|
||||||
/* ==================================
|
/* ==================================
|
||||||
* Example 1: A 1024-bit RSA Key Pair
|
* Example 1: A 1024-bit RSA Key Pair
|
||||||
* ================================== */
|
* ================================== */
|
||||||
|
@ -199,7 +199,7 @@ const uint8_t encrypted3[] = {
|
||||||
0xef, 0xcc, 0x05, 0x4e, 0x70, 0x96, 0x8e, 0xa5, 0x40, 0xc8, 0x1b, 0x04, 0xbc, 0xae, 0xfe, 0x72,
|
0xef, 0xcc, 0x05, 0x4e, 0x70, 0x96, 0x8e, 0xa5, 0x40, 0xc8, 0x1b, 0x04, 0xbc, 0xae, 0xfe, 0x72,
|
||||||
0x0e
|
0x0e
|
||||||
};
|
};
|
||||||
|
#endif
|
||||||
/**********************************************************************************************/
|
/**********************************************************************************************/
|
||||||
|
|
||||||
/* ---------------------------------
|
/* ---------------------------------
|
||||||
|
@ -207,7 +207,7 @@ const uint8_t encrypted3[] = {
|
||||||
* --------------------------------- */
|
* --------------------------------- */
|
||||||
|
|
||||||
/* Message to be encrypted: */
|
/* Message to be encrypted: */
|
||||||
const uint8_t message4[] = {
|
const uint8_t message4[] = {
|
||||||
0xa7, 0xeb, 0x2a, 0x50, 0x36, 0x93, 0x1d, 0x27, 0xd4, 0xe8, 0x91, 0x32, 0x6d, 0x99, 0x69, 0x2f,
|
0xa7, 0xeb, 0x2a, 0x50, 0x36, 0x93, 0x1d, 0x27, 0xd4, 0xe8, 0x91, 0x32, 0x6d, 0x99, 0x69, 0x2f,
|
||||||
0xfa, 0xdd, 0xa9, 0xbf, 0x7e, 0xfd, 0x3e, 0x34, 0xe6, 0x22, 0xc4, 0xad, 0xc0, 0x85, 0xf7, 0x21,
|
0xfa, 0xdd, 0xa9, 0xbf, 0x7e, 0xfd, 0x3e, 0x34, 0xe6, 0x22, 0xc4, 0xad, 0xc0, 0x85, 0xf7, 0x21,
|
||||||
0xdf, 0xe8, 0x85, 0x07, 0x2c, 0x78, 0xa2, 0x03, 0xb1, 0x51, 0x73, 0x9b, 0xe5, 0x40, 0xfa, 0x8c,
|
0xdf, 0xe8, 0x85, 0x07, 0x2c, 0x78, 0xa2, 0x03, 0xb1, 0x51, 0x73, 0x9b, 0xe5, 0x40, 0xfa, 0x8c,
|
||||||
|
@ -215,14 +215,14 @@ const uint8_t message4[] = {
|
||||||
};
|
};
|
||||||
|
|
||||||
/* Seed: */
|
/* Seed: */
|
||||||
const uint8_t seed4[] = {
|
const uint8_t seed4[] = {
|
||||||
0x9a, 0x7b, 0x3b, 0x0e, 0x70, 0x8b, 0xd9, 0x6f, 0x81, 0x90, 0xec, 0xab, 0x4f, 0xb9, 0xb2, 0xb3,
|
0x9a, 0x7b, 0x3b, 0x0e, 0x70, 0x8b, 0xd9, 0x6f, 0x81, 0x90, 0xec, 0xab, 0x4f, 0xb9, 0xb2, 0xb3,
|
||||||
0x80, 0x5a, 0x81, 0x56
|
0x80, 0x5a, 0x81, 0x56
|
||||||
};
|
};
|
||||||
|
|
||||||
/* Encryption: */
|
/* Encryption: */
|
||||||
const uint8_t encrypted4[] = {
|
const uint8_t encrypted4[] = {
|
||||||
0x00, 0xa4, 0x57, 0x8c, 0xbc, 0x17, 0x63, 0x18, 0xa6, 0x38, 0xfb, 0xa7, 0xd0, 0x1d, 0xf1, 0x57,
|
/* 0x00,*/ 0xa4, 0x57, 0x8c, 0xbc, 0x17, 0x63, 0x18, 0xa6, 0x38, 0xfb, 0xa7, 0xd0, 0x1d, 0xf1, 0x57,
|
||||||
0x46, 0xaf, 0x44, 0xd4, 0xf6, 0xcd, 0x96, 0xd7, 0xe7, 0xc4, 0x95, 0xcb, 0xf4, 0x25, 0xb0, 0x9c,
|
0x46, 0xaf, 0x44, 0xd4, 0xf6, 0xcd, 0x96, 0xd7, 0xe7, 0xc4, 0x95, 0xcb, 0xf4, 0x25, 0xb0, 0x9c,
|
||||||
0x64, 0x9d, 0x32, 0xbf, 0x88, 0x6d, 0xa4, 0x8f, 0xba, 0xf9, 0x89, 0xa2, 0x11, 0x71, 0x87, 0xca,
|
0x64, 0x9d, 0x32, 0xbf, 0x88, 0x6d, 0xa4, 0x8f, 0xba, 0xf9, 0x89, 0xa2, 0x11, 0x71, 0x87, 0xca,
|
||||||
0xfb, 0x1f, 0xb5, 0x80, 0x31, 0x76, 0x90, 0xe3, 0xcc, 0xd4, 0x46, 0x92, 0x0b, 0x7a, 0xf8, 0x2b,
|
0xfb, 0x1f, 0xb5, 0x80, 0x31, 0x76, 0x90, 0xe3, 0xcc, 0xd4, 0x46, 0x92, 0x0b, 0x7a, 0xf8, 0x2b,
|
||||||
|
@ -234,9 +234,9 @@ const uint8_t encrypted4[] = {
|
||||||
};
|
};
|
||||||
|
|
||||||
/**********************************************************************************************/
|
/**********************************************************************************************/
|
||||||
|
#if 1
|
||||||
/* RSA modulus n: */
|
/* RSA modulus n: */
|
||||||
const uint8_t modulus2[] = {
|
const uint8_t modulus2[] = {
|
||||||
0x01, 0x94, 0x7c, 0x7f, 0xce, 0x90, 0x42, 0x5f, 0x47, 0x27, 0x9e, 0x70, 0x85, 0x1f, 0x25, 0xd5,
|
0x01, 0x94, 0x7c, 0x7f, 0xce, 0x90, 0x42, 0x5f, 0x47, 0x27, 0x9e, 0x70, 0x85, 0x1f, 0x25, 0xd5,
|
||||||
0xe6, 0x23, 0x16, 0xfe, 0x8a, 0x1d, 0xf1, 0x93, 0x71, 0xe3, 0xe6, 0x28, 0xe2, 0x60, 0x54, 0x3e,
|
0xe6, 0x23, 0x16, 0xfe, 0x8a, 0x1d, 0xf1, 0x93, 0x71, 0xe3, 0xe6, 0x28, 0xe2, 0x60, 0x54, 0x3e,
|
||||||
0x49, 0x01, 0xef, 0x60, 0x81, 0xf6, 0x8c, 0x0b, 0x81, 0x41, 0x19, 0x0d, 0x2a, 0xe8, 0xda, 0xba,
|
0x49, 0x01, 0xef, 0x60, 0x81, 0xf6, 0x8c, 0x0b, 0x81, 0x41, 0x19, 0x0d, 0x2a, 0xe8, 0xda, 0xba,
|
||||||
|
@ -249,12 +249,12 @@ const uint8_t modulus2[] = {
|
||||||
};
|
};
|
||||||
|
|
||||||
/* RSA public exponent e: */
|
/* RSA public exponent e: */
|
||||||
const uint8_t public_exponent2[] = {
|
const uint8_t public_exponent2[] = {
|
||||||
0x01, 0x00, 0x01
|
0x01, 0x00, 0x01
|
||||||
};
|
};
|
||||||
|
|
||||||
/* RSA private exponent d: */
|
/* RSA private exponent d: */
|
||||||
const uint8_t private_exponent2[] = {
|
const uint8_t private_exponent2[] = {
|
||||||
0x08, 0x23, 0xf2, 0x0f, 0xad, 0xb5, 0xda, 0x89, 0x08, 0x8a, 0x9d, 0x00, 0x89, 0x3e, 0x21, 0xfa,
|
0x08, 0x23, 0xf2, 0x0f, 0xad, 0xb5, 0xda, 0x89, 0x08, 0x8a, 0x9d, 0x00, 0x89, 0x3e, 0x21, 0xfa,
|
||||||
0x4a, 0x1b, 0x11, 0xfb, 0xc9, 0x3c, 0x64, 0xa3, 0xbe, 0x0b, 0xaa, 0xea, 0x97, 0xfb, 0x3b, 0x93,
|
0x4a, 0x1b, 0x11, 0xfb, 0xc9, 0x3c, 0x64, 0xa3, 0xbe, 0x0b, 0xaa, 0xea, 0x97, 0xfb, 0x3b, 0x93,
|
||||||
0xc3, 0xff, 0x71, 0x37, 0x04, 0xc1, 0x9c, 0x96, 0x3c, 0x1d, 0x10, 0x7a, 0xae, 0x99, 0x05, 0x47,
|
0xc3, 0xff, 0x71, 0x37, 0x04, 0xc1, 0x9c, 0x96, 0x3c, 0x1d, 0x10, 0x7a, 0xae, 0x99, 0x05, 0x47,
|
||||||
|
@ -266,7 +266,7 @@ const uint8_t private_exponent2[] = {
|
||||||
};
|
};
|
||||||
|
|
||||||
/* Prime p: */
|
/* Prime p: */
|
||||||
const uint8_t p2[] = {
|
const uint8_t p2[] = {
|
||||||
0x01, 0x59, 0xdb, 0xde, 0x04, 0xa3, 0x3e, 0xf0, 0x6f, 0xb6, 0x08, 0xb8, 0x0b, 0x19, 0x0f, 0x4d,
|
0x01, 0x59, 0xdb, 0xde, 0x04, 0xa3, 0x3e, 0xf0, 0x6f, 0xb6, 0x08, 0xb8, 0x0b, 0x19, 0x0f, 0x4d,
|
||||||
0x3e, 0x22, 0xbc, 0xc1, 0x3a, 0xc8, 0xe4, 0xa0, 0x81, 0x03, 0x3a, 0xbf, 0xa4, 0x16, 0xed, 0xb0,
|
0x3e, 0x22, 0xbc, 0xc1, 0x3a, 0xc8, 0xe4, 0xa0, 0x81, 0x03, 0x3a, 0xbf, 0xa4, 0x16, 0xed, 0xb0,
|
||||||
0xb3, 0x38, 0xaa, 0x08, 0xb5, 0x73, 0x09, 0xea, 0x5a, 0x52, 0x40, 0xe7, 0xdc, 0x6e, 0x54, 0x37,
|
0xb3, 0x38, 0xaa, 0x08, 0xb5, 0x73, 0x09, 0xea, 0x5a, 0x52, 0x40, 0xe7, 0xdc, 0x6e, 0x54, 0x37,
|
||||||
|
@ -275,7 +275,7 @@ const uint8_t p2[] = {
|
||||||
};
|
};
|
||||||
|
|
||||||
/* Prime q: */
|
/* Prime q: */
|
||||||
const uint8_t q2[] = {
|
const uint8_t q2[] = {
|
||||||
0x01, 0x2b, 0x65, 0x2f, 0x30, 0x40, 0x3b, 0x38, 0xb4, 0x09, 0x95, 0xfd, 0x6f, 0xf4, 0x1a, 0x1a,
|
0x01, 0x2b, 0x65, 0x2f, 0x30, 0x40, 0x3b, 0x38, 0xb4, 0x09, 0x95, 0xfd, 0x6f, 0xf4, 0x1a, 0x1a,
|
||||||
0xcc, 0x8a, 0xda, 0x70, 0x37, 0x32, 0x36, 0xb7, 0x20, 0x2d, 0x39, 0xb2, 0xee, 0x30, 0xcf, 0xb4,
|
0xcc, 0x8a, 0xda, 0x70, 0x37, 0x32, 0x36, 0xb7, 0x20, 0x2d, 0x39, 0xb2, 0xee, 0x30, 0xcf, 0xb4,
|
||||||
0x6d, 0xb0, 0x95, 0x11, 0xf6, 0xf3, 0x07, 0xcc, 0x61, 0xcc, 0x21, 0x60, 0x6c, 0x18, 0xa7, 0x5b,
|
0x6d, 0xb0, 0x95, 0x11, 0xf6, 0xf3, 0x07, 0xcc, 0x61, 0xcc, 0x21, 0x60, 0x6c, 0x18, 0xa7, 0x5b,
|
||||||
|
@ -284,7 +284,7 @@ const uint8_t q2[] = {
|
||||||
};
|
};
|
||||||
|
|
||||||
/* p's CRT exponent dP: */
|
/* p's CRT exponent dP: */
|
||||||
const uint8_t dp2[] = {
|
const uint8_t dp2[] = {
|
||||||
0x43, 0x6e, 0xf5, 0x08, 0xde, 0x73, 0x65, 0x19, 0xc2, 0xda, 0x4c, 0x58, 0x0d, 0x98, 0xc8, 0x2c,
|
0x43, 0x6e, 0xf5, 0x08, 0xde, 0x73, 0x65, 0x19, 0xc2, 0xda, 0x4c, 0x58, 0x0d, 0x98, 0xc8, 0x2c,
|
||||||
0xb7, 0x45, 0x2a, 0x3f, 0xb5, 0xef, 0xad, 0xc3, 0xb9, 0xc7, 0x78, 0x9a, 0x1b, 0xc6, 0x58, 0x4f,
|
0xb7, 0x45, 0x2a, 0x3f, 0xb5, 0xef, 0xad, 0xc3, 0xb9, 0xc7, 0x78, 0x9a, 0x1b, 0xc6, 0x58, 0x4f,
|
||||||
0x79, 0x5a, 0xdd, 0xbb, 0xd3, 0x24, 0x39, 0xc7, 0x46, 0x86, 0x55, 0x2e, 0xcb, 0x6c, 0x2c, 0x30,
|
0x79, 0x5a, 0xdd, 0xbb, 0xd3, 0x24, 0x39, 0xc7, 0x46, 0x86, 0x55, 0x2e, 0xcb, 0x6c, 0x2c, 0x30,
|
||||||
|
@ -292,7 +292,7 @@ const uint8_t dp2[] = {
|
||||||
};
|
};
|
||||||
|
|
||||||
/* q's CRT exponent dQ: */
|
/* q's CRT exponent dQ: */
|
||||||
const uint8_t dq2[] = {
|
const uint8_t dq2[] = {
|
||||||
0x01, 0x2b, 0x15, 0xa8, 0x9f, 0x3d, 0xfb, 0x2b, 0x39, 0x07, 0x3e, 0x73, 0xf0, 0x2b, 0xdd, 0x0c,
|
0x01, 0x2b, 0x15, 0xa8, 0x9f, 0x3d, 0xfb, 0x2b, 0x39, 0x07, 0x3e, 0x73, 0xf0, 0x2b, 0xdd, 0x0c,
|
||||||
0x1a, 0x7b, 0x37, 0x9d, 0xd4, 0x35, 0xf0, 0x5c, 0xdd, 0xe2, 0xef, 0xf9, 0xe4, 0x62, 0x94, 0x8b,
|
0x1a, 0x7b, 0x37, 0x9d, 0xd4, 0x35, 0xf0, 0x5c, 0xdd, 0xe2, 0xef, 0xf9, 0xe4, 0x62, 0x94, 0x8b,
|
||||||
0x7c, 0xec, 0x62, 0xee, 0x90, 0x50, 0xd5, 0xe0, 0x81, 0x6e, 0x07, 0x85, 0xa8, 0x56, 0xb4, 0x91,
|
0x7c, 0xec, 0x62, 0xee, 0x90, 0x50, 0xd5, 0xe0, 0x81, 0x6e, 0x07, 0x85, 0xa8, 0x56, 0xb4, 0x91,
|
||||||
|
@ -301,13 +301,14 @@ const uint8_t dq2[] = {
|
||||||
};
|
};
|
||||||
|
|
||||||
/* CRT coefficient qInv: */
|
/* CRT coefficient qInv: */
|
||||||
const uint8_t qinv2[] = {
|
const uint8_t qinv2[] = {
|
||||||
0x02, 0x70, 0xdb, 0x17, 0xd5, 0x91, 0x4b, 0x01, 0x8d, 0x76, 0x11, 0x8b, 0x24, 0x38, 0x9a, 0x73,
|
0x02, 0x70, 0xdb, 0x17, 0xd5, 0x91, 0x4b, 0x01, 0x8d, 0x76, 0x11, 0x8b, 0x24, 0x38, 0x9a, 0x73,
|
||||||
0x50, 0xec, 0x83, 0x6b, 0x00, 0x63, 0xa2, 0x17, 0x21, 0x23, 0x6f, 0xd8, 0xed, 0xb6, 0xd8, 0x9b,
|
0x50, 0xec, 0x83, 0x6b, 0x00, 0x63, 0xa2, 0x17, 0x21, 0x23, 0x6f, 0xd8, 0xed, 0xb6, 0xd8, 0x9b,
|
||||||
0x51, 0xe7, 0xee, 0xb8, 0x7b, 0x61, 0x1b, 0x71, 0x32, 0xcb, 0x7e, 0xa7, 0x35, 0x6c, 0x23, 0x15,
|
0x51, 0xe7, 0xee, 0xb8, 0x7b, 0x61, 0x1b, 0x71, 0x32, 0xcb, 0x7e, 0xa7, 0x35, 0x6c, 0x23, 0x15,
|
||||||
0x1c, 0x1e, 0x77, 0x51, 0x50, 0x7c, 0x78, 0x6d, 0x9e, 0xe1, 0x79, 0x41, 0x70, 0xa8, 0xc8, 0xe8
|
0x1c, 0x1e, 0x77, 0x51, 0x50, 0x7c, 0x78, 0x6d, 0x9e, 0xe1, 0x79, 0x41, 0x70, 0xa8, 0xc8, 0xe8
|
||||||
};
|
};
|
||||||
|
|
||||||
|
#endif
|
||||||
/**********************************************************************************************/
|
/**********************************************************************************************/
|
||||||
|
|
||||||
|
|
||||||
|
@ -354,7 +355,7 @@ uint8_t convert_nibble(uint8_t c){
|
||||||
}
|
}
|
||||||
|
|
||||||
const char *block_ignore_string=" \t\r\n,;";
|
const char *block_ignore_string=" \t\r\n,;";
|
||||||
|
#define BUFFER_LIMIT 120
|
||||||
uint16_t read_os(void* dst, uint16_t length, const char* ignore_string){
|
uint16_t read_os(void* dst, uint16_t length, const char* ignore_string){
|
||||||
uint16_t counter = 0;
|
uint16_t counter = 0;
|
||||||
uint16_t c;
|
uint16_t c;
|
||||||
|
@ -377,6 +378,9 @@ uint16_t read_os(void* dst, uint16_t length, const char* ignore_string){
|
||||||
if(idx){
|
if(idx){
|
||||||
((uint8_t*)dst)[counter++] = (tmp << 4) | v;
|
((uint8_t*)dst)[counter++] = (tmp << 4) | v;
|
||||||
idx = 0;
|
idx = 0;
|
||||||
|
if(counter % (BUFFER_LIMIT/2) == 0){
|
||||||
|
cli_putc('.');
|
||||||
|
}
|
||||||
}else{
|
}else{
|
||||||
tmp = v;
|
tmp = v;
|
||||||
idx = 1;
|
idx = 1;
|
||||||
|
@ -394,6 +398,36 @@ uint16_t own_atou(const char* str){
|
||||||
return r;
|
return r;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
char* own_utoa(unsigned value, char* str, uint8_t radix){
|
||||||
|
char *p = str, *b = str;
|
||||||
|
char t;
|
||||||
|
div_t d;
|
||||||
|
if(radix>36){
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
if(value == 0){
|
||||||
|
*p++ = '0';
|
||||||
|
*p = '\0';
|
||||||
|
return str;
|
||||||
|
}
|
||||||
|
while(value){
|
||||||
|
d = div(value, radix);
|
||||||
|
value = d.quot;
|
||||||
|
if(d.rem < 10){
|
||||||
|
*p++ = '0' + d.rem;
|
||||||
|
}else{
|
||||||
|
*p++ = 'a' + d.rem - 10;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
*p = '\0';
|
||||||
|
while(str<p){
|
||||||
|
t = *str;
|
||||||
|
*str++ = *--p;
|
||||||
|
*p = t;
|
||||||
|
}
|
||||||
|
return b;
|
||||||
|
}
|
||||||
|
|
||||||
uint8_t read_bigint(bigint_t* a, char* prompt){
|
uint8_t read_bigint(bigint_t* a, char* prompt){
|
||||||
uint16_t read_length, actual_length;
|
uint16_t read_length, actual_length;
|
||||||
uint8_t off;
|
uint8_t off;
|
||||||
|
@ -530,13 +564,13 @@ void load_priv_conventional(void){
|
||||||
cli_putstr("\r\nERROR: OOM!");
|
cli_putstr("\r\nERROR: OOM!");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
epriv->length_B = (sizeof(private_exponent) + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
|
epriv->length_B = (sizeof(PRIV_EXPONENT) + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
|
||||||
epriv->wordv = malloc(epriv->length_B * sizeof(bigint_word_t));
|
epriv->wordv = malloc(epriv->length_B * sizeof(bigint_word_t));
|
||||||
if(!epriv->wordv){
|
if(!epriv->wordv){
|
||||||
cli_putstr("\r\nERROR: OOM!");
|
cli_putstr("\r\nERROR: OOM!");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
memcpy(epriv->wordv, private_exponent, sizeof(private_exponent));
|
memcpy(epriv->wordv, PRIV_EXPONENT, sizeof(PRIV_EXPONENT));
|
||||||
priv_key.components = malloc(sizeof(bigint_t*));
|
priv_key.components = malloc(sizeof(bigint_t*));
|
||||||
priv_key.components[0] = epriv;
|
priv_key.components[0] = epriv;
|
||||||
priv_key.n = 1;
|
priv_key.n = 1;
|
||||||
|
@ -547,8 +581,8 @@ void load_priv_conventional(void){
|
||||||
|
|
||||||
void load_priv_crt_mono(void){
|
void load_priv_crt_mono(void){
|
||||||
bigint_t **v;
|
bigint_t **v;
|
||||||
const uint8_t *bv[5] = {p,q,dp,dq,qinv};
|
const uint8_t *bv[5] = {P,Q,DP,DQ,QINV};
|
||||||
uint16_t sv[5] = {sizeof(p), sizeof(q), sizeof(dp), sizeof(dq), sizeof(qinv)};
|
uint16_t sv[5] = {sizeof(P), sizeof(Q), sizeof(DP), sizeof(DQ), sizeof(QINV)};
|
||||||
uint8_t i;
|
uint8_t i;
|
||||||
v = malloc(5 * sizeof(bigint_t));
|
v = malloc(5 * sizeof(bigint_t));
|
||||||
if(!v){
|
if(!v){
|
||||||
|
@ -618,30 +652,36 @@ void load_fix_rsa(void){
|
||||||
|
|
||||||
void quick_test(void){
|
void quick_test(void){
|
||||||
uint8_t *ciphertext, *plaintext, rc;
|
uint8_t *ciphertext, *plaintext, rc;
|
||||||
|
uint8_t seed[sizeof(SEED)];
|
||||||
uint16_t clen, plen;
|
uint16_t clen, plen;
|
||||||
ciphertext = malloc(clen = pub_key.modulus->length_B * sizeof(bigint_word_t));
|
ciphertext = malloc(clen = pub_key.modulus->length_B * sizeof(bigint_word_t));
|
||||||
plaintext = malloc(pub_key.modulus->length_B * sizeof(bigint_word_t));
|
plaintext = malloc(pub_key.modulus->length_B * sizeof(bigint_word_t));
|
||||||
// memcpy(ciphertext, message1, sizeof(message1));
|
memcpy(plaintext, MSG, sizeof(MSG));
|
||||||
|
memcpy(seed, SEED, sizeof(SEED));
|
||||||
cli_putstr("\r\nplaintext:");
|
cli_putstr("\r\nplaintext:");
|
||||||
cli_hexdump_block(MSG, sizeof(MSG), 4, 8);
|
cli_hexdump_block(plaintext, sizeof(MSG), 4, 8);
|
||||||
uart_flush(0);
|
cli_putstr("\r\nencrypting: ...");
|
||||||
rc = rsa_encrypt_oaep(ciphertext, &clen, MSG, sizeof(MSG), &pub_key, NULL, NULL, SEED);
|
rc = rsa_encrypt_oaep(ciphertext, &clen, plaintext, sizeof(MSG), &pub_key, NULL, NULL, seed);
|
||||||
if(rc){
|
if(rc){
|
||||||
cli_putstr("\r\nERROR: rsa_encrypt_oaep returned: ");
|
cli_putstr("\r\nERROR: rsa_encrypt_oaep returned: ");
|
||||||
cli_hexdump_byte(rc);
|
cli_hexdump_byte(rc);
|
||||||
return;
|
return;
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
cli_putstr("\r\n\r\nciphertext:");
|
cli_putstr("\r\n\r\nciphertext:");
|
||||||
cli_hexdump_block(ciphertext, clen, 4, 8);
|
cli_hexdump_block(ciphertext, clen, 4, 8);
|
||||||
if(clen!=sizeof(ENCRYPTED) || memcmp(ENCRYPTED, ciphertext, clen)){
|
if(clen!=sizeof(ENCRYPTED)){
|
||||||
cli_putstr("\r\n>>FAIL<<");
|
cli_putstr("\r\n>>FAIL (no size match)<<");
|
||||||
}else{
|
}else{
|
||||||
cli_putstr("\r\n>>OK<<");
|
if(memcmp(ciphertext, ENCRYPTED, clen)){
|
||||||
|
cli_putstr("\r\n>>FAIL (no content match)<<");
|
||||||
|
}else{
|
||||||
|
cli_putstr("\r\n>>OK<<");
|
||||||
|
}
|
||||||
}
|
}
|
||||||
uart_flush(0);
|
|
||||||
|
|
||||||
|
|
||||||
|
cli_putstr("\r\ndecrypting: ...");
|
||||||
rc = rsa_decrypt_oaep(plaintext, &plen, ciphertext, clen, &priv_key, NULL, NULL, NULL);
|
rc = rsa_decrypt_oaep(plaintext, &plen, ciphertext, clen, &priv_key, NULL, NULL, NULL);
|
||||||
if(rc){
|
if(rc){
|
||||||
cli_putstr("\r\nERROR: rsa_decrypt_oaep returned: ");
|
cli_putstr("\r\nERROR: rsa_decrypt_oaep returned: ");
|
||||||
|
@ -689,23 +729,41 @@ void run_seed_test(void){
|
||||||
rsa_encrypt_oaep(ciph, &ciph_len, msg, msg_len, &pub_key, NULL, NULL, seed);
|
rsa_encrypt_oaep(ciph, &ciph_len, msg, msg_len, &pub_key, NULL, NULL, seed);
|
||||||
cli_putstr("\r\n ciphertext:");
|
cli_putstr("\r\n ciphertext:");
|
||||||
cli_hexdump_block(ciph, ciph_len, 4, 16);
|
cli_hexdump_block(ciph, ciph_len, 4, 16);
|
||||||
cli_putstr("\r\n decrypting ...");
|
cli_putstr("\r\n decrypting ... ");
|
||||||
uart_flush(0);
|
|
||||||
rsa_decrypt_oaep(msg_, &msg_len_, ciph, ciph_len, &priv_key, NULL, NULL, seed_out);
|
rsa_decrypt_oaep(msg_, &msg_len_, ciph, ciph_len, &priv_key, NULL, NULL, seed_out);
|
||||||
|
cli_putstr("[done]");
|
||||||
if(msg_len != msg_len_){
|
if(msg_len != msg_len_){
|
||||||
cli_putstr("\r\nERROR: wrong decryted message length");
|
char tstr[16];
|
||||||
return;
|
cli_putstr("\r\nERROR: wrong decrypted message length (");
|
||||||
|
|
||||||
|
own_utoa(msg_len_, tstr, 10);
|
||||||
|
cli_putstr(tstr);
|
||||||
|
cli_putstr(" instead of ");
|
||||||
|
own_utoa(msg_len, tstr, 10);
|
||||||
|
cli_putstr(tstr);
|
||||||
|
cli_putc(')');
|
||||||
|
goto end;
|
||||||
}
|
}
|
||||||
if(memcmp(msg, msg_, msg_len)){
|
if(memcmp(msg, msg_, msg_len)){
|
||||||
cli_putstr("\r\nERROR: wrong decryted message");
|
cli_putstr("\r\nERROR: wrong decrypted message:");
|
||||||
return;
|
cli_hexdump_block(msg_, msg_len_, 4, 16);
|
||||||
|
cli_putstr("\r\nreference:");
|
||||||
|
cli_hexdump_block(msg, msg_len, 4, 16);
|
||||||
|
goto end;
|
||||||
}
|
}
|
||||||
|
|
||||||
if(memcmp(seed, seed_out, 20)){
|
if(memcmp(seed, seed_out, 20)){
|
||||||
cli_putstr("\r\nERROR: wrong decryted seed");
|
cli_putstr("\r\nERROR: wrong decrypted seed:");
|
||||||
return;
|
cli_hexdump_block(seed_out, 20, 4, 16);
|
||||||
|
cli_putstr("\r\nreference:");
|
||||||
|
cli_hexdump_block(seed, 20, 4, 16);
|
||||||
|
goto end;
|
||||||
}
|
}
|
||||||
cli_putstr("\r\n >>OK<<");
|
cli_putstr("\r\n >>OK<<");
|
||||||
|
end:
|
||||||
|
free(msg);
|
||||||
|
free(msg_);
|
||||||
|
free(ciph);
|
||||||
}
|
}
|
||||||
|
|
||||||
void reset_prng(void){
|
void reset_prng(void){
|
||||||
|
@ -727,6 +785,18 @@ void load_key(void){
|
||||||
read_key_crt();
|
read_key_crt();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void test_dump(void){
|
||||||
|
char lstr[16];
|
||||||
|
int len;
|
||||||
|
cli_putstr("\r\nenter dump length: ");
|
||||||
|
cli_getsn(lstr, 15);
|
||||||
|
len = own_atou(lstr);
|
||||||
|
cli_putstr("\r\ndumping 0x");
|
||||||
|
cli_hexdump_rev(&len, 2);
|
||||||
|
cli_putstr(" byte:");
|
||||||
|
cli_hexdump_block(pub_key.modulus->wordv, len, 4, 8);
|
||||||
|
}
|
||||||
|
|
||||||
/*****************************************************************************
|
/*****************************************************************************
|
||||||
* main *
|
* main *
|
||||||
*****************************************************************************/
|
*****************************************************************************/
|
||||||
|
@ -737,15 +807,17 @@ const char load_key_str[] = "load-key";
|
||||||
const char load_fix_key_str[] = "load-fix-key";
|
const char load_fix_key_str[] = "load-fix-key";
|
||||||
const char quick_test_str[] = "quick-test";
|
const char quick_test_str[] = "quick-test";
|
||||||
const char seed_test_str[] = "seed-test";
|
const char seed_test_str[] = "seed-test";
|
||||||
|
const char dump_test_str[] = "dump-test";
|
||||||
const char performance_str[] = "performance";
|
const char performance_str[] = "performance";
|
||||||
const char echo_str[] = "echo";
|
const char echo_str[] = "echo";
|
||||||
|
|
||||||
cmdlist_entry_t cmdlist[] = {
|
const cmdlist_entry_t cmdlist[] = {
|
||||||
{ reset_prng_str, NULL, reset_prng },
|
{ reset_prng_str, NULL, reset_prng },
|
||||||
{ load_key_str, NULL, load_key },
|
{ load_key_str, NULL, load_key },
|
||||||
{ load_fix_key_str, NULL, load_fix_rsa },
|
{ load_fix_key_str, NULL, load_fix_rsa },
|
||||||
{ quick_test_str, NULL, quick_test },
|
{ quick_test_str, NULL, quick_test },
|
||||||
{ seed_test_str, NULL, run_seed_test },
|
{ seed_test_str, NULL, run_seed_test },
|
||||||
|
{ dump_test_str, NULL, test_dump },
|
||||||
// { performance_str, NULL, testrun_performance_bigint },
|
// { performance_str, NULL, testrun_performance_bigint },
|
||||||
{ echo_str, (void*)1, (void_fpt)echo_ctrl },
|
{ echo_str, (void*)1, (void_fpt)echo_ctrl },
|
||||||
{ NULL, NULL, NULL }
|
{ NULL, NULL, NULL }
|
||||||
|
|
Loading…
Reference in New Issue