X-Git-Url: https://git.cryptolib.org/?a=blobdiff_plain;f=nessie_bc_test.c;h=4d6d42b38c09bca42452afbae23428cd1515822a;hb=cc0d247149bad70179dff52f544381545054da44;hp=db28588354e46134e9cc101cba8b0c0030f2dad5;hpb=b74ffe54a472b5eab2511b835568044c39486858;p=avr-crypto-lib.git

diff --git a/nessie_bc_test.c b/nessie_bc_test.c
index db28588..4d6d42b 100644
--- a/nessie_bc_test.c
+++ b/nessie_bc_test.c
@@ -14,7 +14,7 @@
 
 
 
-nessie_ctx_t nessie_ctx;
+nessie_bc_ctx_t nessie_bc_ctx;
 
 static void printblock(uint8_t* block, uint16_t blocksize_bit){
 	char tab [] = {'0', '1', '2', '3', 
@@ -66,49 +66,49 @@ static void printitem(char* name, uint8_t* buffer, uint16_t size_B){
 	}
 } 
 
-void nessie_enc(uint8_t* key, uint8_t* pt){
-	uint8_t ctx[nessie_ctx.ctx_size_B];
-	uint8_t buffer[nessie_ctx.blocksize_B];
+void nessie_bc_enc(uint8_t* key, uint8_t* pt){
+	uint8_t ctx[nessie_bc_ctx.ctx_size_B];
+	uint8_t buffer[nessie_bc_ctx.blocksize_B];
 	uint16_t i;
 	
 	/* single test */
-	printitem("key", key, (nessie_ctx.keysize+7)/8);
-	nessie_ctx.cipher_genctx(key, nessie_ctx.keysize, ctx);
-	memcpy(buffer, pt, nessie_ctx.blocksize_B);
-	printitem("plain", buffer, nessie_ctx.blocksize_B);
-	nessie_ctx.cipher_enc(buffer, ctx);
-	printitem("cipher", buffer, nessie_ctx.blocksize_B);
-	nessie_ctx.cipher_dec(buffer, ctx);
-	printitem("decrypted", buffer, nessie_ctx.blocksize_B);
+	printitem("key", key, (nessie_bc_ctx.keysize_b+7)/8);
+	nessie_bc_ctx.cipher_genctx(key, nessie_bc_ctx.keysize_b, ctx);
+	memcpy(buffer, pt, nessie_bc_ctx.blocksize_B);
+	printitem("plain", buffer, nessie_bc_ctx.blocksize_B);
+	nessie_bc_ctx.cipher_enc(buffer, ctx);
+	printitem("cipher", buffer, nessie_bc_ctx.blocksize_B);
+	nessie_bc_ctx.cipher_dec(buffer, ctx);
+	printitem("decrypted", buffer, nessie_bc_ctx.blocksize_B);
 	
 	/* 100 times test */
-	memcpy(buffer, pt, nessie_ctx.blocksize_B);
+	memcpy(buffer, pt, nessie_bc_ctx.blocksize_B);
 	for(i=0; i<100; ++i){
-		nessie_ctx.cipher_enc(buffer, ctx);
+		nessie_bc_ctx.cipher_enc(buffer, ctx);
 	}
-	printitem("Iterated 100 times", buffer, nessie_ctx.blocksize_B);
+	printitem("Iterated 100 times", buffer, nessie_bc_ctx.blocksize_B);
 #ifndef NESSIE_NO1KTEST	
 	/* 1000 times test, we use the 100 precedig steps to fasten things a bit */
 	for(; i<1000; ++i){
-		nessie_ctx.cipher_enc(buffer, ctx);
+		nessie_bc_ctx.cipher_enc(buffer, ctx);
 	}
-	printitem("Iterated 1000 times", buffer, nessie_ctx.blocksize_B);
+	printitem("Iterated 1000 times", buffer, nessie_bc_ctx.blocksize_B);
 #endif
 }
 
-void nessie_dec(uint8_t* key, uint8_t* ct){
-	uint8_t ctx[nessie_ctx.ctx_size_B];
-	uint8_t buffer[nessie_ctx.blocksize_B];
+void nessie_bc_dec(uint8_t* key, uint8_t* ct){
+	uint8_t ctx[nessie_bc_ctx.ctx_size_B];
+	uint8_t buffer[nessie_bc_ctx.blocksize_B];
 	
 	/* single test */
-	printitem("key", key, (nessie_ctx.keysize+7)/8);
-	nessie_ctx.cipher_genctx(key, nessie_ctx.keysize, ctx);
-	memcpy(buffer, ct, nessie_ctx.blocksize_B);
-	printitem("cipher", buffer, nessie_ctx.blocksize_B);
-	nessie_ctx.cipher_dec(buffer, ctx);
-	printitem("plain", buffer, nessie_ctx.blocksize_B);
-	nessie_ctx.cipher_enc(buffer, ctx);
-	printitem("encrypted", buffer, nessie_ctx.blocksize_B);
+	printitem("key", key, (nessie_bc_ctx.keysize_b+7)/8);
+	nessie_bc_ctx.cipher_genctx(key, nessie_bc_ctx.keysize_b, ctx);
+	memcpy(buffer, ct, nessie_bc_ctx.blocksize_B);
+	printitem("cipher", buffer, nessie_bc_ctx.blocksize_B);
+	nessie_bc_ctx.cipher_dec(buffer, ctx);
+	printitem("plain", buffer, nessie_bc_ctx.blocksize_B);
+	nessie_bc_ctx.cipher_enc(buffer, ctx);
+	printitem("encrypted", buffer, nessie_bc_ctx.blocksize_B);
 	
 }
 
@@ -151,27 +151,27 @@ static void print_header(void){
 	"********************************************************************************\r\n"
 	"\r\n"));
 	uart_putstr_P(PSTR("Primitive Name: "));
-	uart_putstr(nessie_ctx.name);
+	uart_putstr(nessie_bc_ctx.name);
 	uart_putstr_P(PSTR("\r\n"));
-	for(i=0; i<16+strlen(nessie_ctx.name); ++i){
+	for(i=0; i<16+strlen(nessie_bc_ctx.name); ++i){
 		uart_putc('=');
 	}
 	uart_putstr_P(PSTR("\r\nKey size: "));
-	if(nessie_ctx.keysize>100){
-		uart_putc('0'+nessie_ctx.keysize/100);
+	if(nessie_bc_ctx.keysize_b>100){
+		uart_putc('0'+nessie_bc_ctx.keysize_b/100);
 	}
-	if(nessie_ctx.keysize>10){
-		uart_putc('0'+(nessie_ctx.keysize/10)%10);
+	if(nessie_bc_ctx.keysize_b>10){
+		uart_putc('0'+(nessie_bc_ctx.keysize_b/10)%10);
 	}
-	uart_putc('0'+nessie_ctx.keysize%10);
+	uart_putc('0'+nessie_bc_ctx.keysize_b%10);
 	uart_putstr_P(PSTR(" bits\r\nBlock size: "));
-	if(nessie_ctx.blocksize_B*8>100){
-		uart_putc('0'+(nessie_ctx.blocksize_B*8)/100);
+	if(nessie_bc_ctx.blocksize_B*8>100){
+		uart_putc('0'+(nessie_bc_ctx.blocksize_B*8)/100);
 	}
-	if(nessie_ctx.blocksize_B*8>10){
-		uart_putc('0'+((nessie_ctx.blocksize_B*8)/10)%10);
+	if(nessie_bc_ctx.blocksize_B*8>10){
+		uart_putc('0'+((nessie_bc_ctx.blocksize_B*8)/10)%10);
 	}
-	uart_putc('0'+(nessie_ctx.blocksize_B*8)%10);
+	uart_putc('0'+(nessie_bc_ctx.blocksize_B*8)%10);
 	uart_putstr_P(PSTR(" bits"));
 }
 
@@ -179,54 +179,54 @@ static void print_footer(void){
 	uart_putstr_P(PSTR("\r\n\r\n\r\n\r\nEnd of test vectors\r\n\r\n"));
 }
 
-void nessie_run(void){
+void nessie_bc_run(void){
 	uint16_t i;
 	uint8_t set;
-	uint8_t key[(nessie_ctx.keysize+7)/8];
-	uint8_t buffer[nessie_ctx.blocksize_B];
+	uint8_t key[(nessie_bc_ctx.keysize_b+7)/8];
+	uint8_t buffer[nessie_bc_ctx.blocksize_B];
 	
 	print_header();
 	/* test set 1 */
 	set=1;
 	print_setheader(set);
-	for(i=0; i<nessie_ctx.keysize; ++i){
+	for(i=0; i<nessie_bc_ctx.keysize_b; ++i){
 		print_set_vector(set, i);
-		memset(key, 0, (nessie_ctx.keysize+7)/8);
+		memset(key, 0, (nessie_bc_ctx.keysize_b+7)/8);
 		key[i/8] |= 0x80>>(i%8);
-		memset(buffer, 0, nessie_ctx.blocksize_B);
-		nessie_enc(key, buffer);
+		memset(buffer, 0, nessie_bc_ctx.blocksize_B);
+		nessie_bc_enc(key, buffer);
 	}
 	/* test set 2 */
 	set=2;
 	print_setheader(set);
-	for(i=0; i<nessie_ctx.blocksize_B*8; ++i){
+	for(i=0; i<nessie_bc_ctx.blocksize_B*8; ++i){
 		print_set_vector(set, i);
-		memset(key, 0, (nessie_ctx.keysize+7)/8);
-		memset(buffer, 0, nessie_ctx.blocksize_B);
+		memset(key, 0, (nessie_bc_ctx.keysize_b+7)/8);
+		memset(buffer, 0, nessie_bc_ctx.blocksize_B);
 		buffer[i/8] |= 0x80>>(i%8);
-		nessie_enc(key, buffer);
+		nessie_bc_enc(key, buffer);
 	}
 	/* test set 3 */
 	set=3;
 	print_setheader(set);
 	for(i=0; i<256; ++i){
 		print_set_vector(set, i);
-		memset(key, i, (nessie_ctx.keysize+7)/8);
-		memset(buffer, i, nessie_ctx.blocksize_B);
-		nessie_enc(key, buffer);
+		memset(key, i, (nessie_bc_ctx.keysize_b+7)/8);
+		memset(buffer, i, nessie_bc_ctx.blocksize_B);
+		nessie_bc_enc(key, buffer);
 	}
 	/* test set 4 */
 	set=4;
 	print_setheader(set);
 	/* 4 - 0*/
 	print_set_vector(set, 0);
-	for(i=0; i<(nessie_ctx.keysize+7)/8; ++i){
+	for(i=0; i<(nessie_bc_ctx.keysize_b+7)/8; ++i){
 		key[i]=i;
 	}
-	for(i=0; i<nessie_ctx.blocksize_B; ++i){
+	for(i=0; i<nessie_bc_ctx.blocksize_B; ++i){
 		buffer[i]=i*0x11;
 	}
-	nessie_enc(key, buffer);
+	nessie_bc_enc(key, buffer);
 	/* 4 - 1 */
 	print_set_vector(set, 1);	
     /* This is the test vectors in Kasumi */
@@ -235,60 +235,60 @@ void nessie_run(void){
            0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48 };
     static uint8_t kasumi_plain[]={
            0xEA, 0x02, 0x47, 0x14, 0xAD, 0x5C, 0x4D, 0x84 };
-	for(i=0; i<(nessie_ctx.keysize+7)/8; ++i){
+	for(i=0; i<(nessie_bc_ctx.keysize_b+7)/8; ++i){
 		key[i]=kasumi_key[i%sizeof(kasumi_key)];
 	}
-	for(i=0; i<nessie_ctx.blocksize_B; ++i){
+	for(i=0; i<nessie_bc_ctx.blocksize_B; ++i){
 		buffer[i]=kasumi_plain[i%sizeof(kasumi_plain)];
 	}
 	/* half done ;-) */
 	/* test set 5 */
 	set=1;
 	print_setheader(set);
-	for(i=0; i<nessie_ctx.keysize; ++i){
+	for(i=0; i<nessie_bc_ctx.keysize_b; ++i){
 		print_set_vector(set, i);
-		memset(key, 0, (nessie_ctx.keysize+7)/8);
+		memset(key, 0, (nessie_bc_ctx.keysize_b+7)/8);
 		key[i/8] |= 0x80>>(i%8);
-		memset(buffer, 0, nessie_ctx.blocksize_B);
-		nessie_dec(key, buffer);
+		memset(buffer, 0, nessie_bc_ctx.blocksize_B);
+		nessie_bc_dec(key, buffer);
 	}
 	/* test set 6 */
 	set=6;
 	print_setheader(set);
-	for(i=0; i<nessie_ctx.blocksize_B*8; ++i){
+	for(i=0; i<nessie_bc_ctx.blocksize_B*8; ++i){
 		print_set_vector(set, i);
-		memset(key, 0, (nessie_ctx.keysize+7)/8);
-		memset(buffer, 0, nessie_ctx.blocksize_B);
+		memset(key, 0, (nessie_bc_ctx.keysize_b+7)/8);
+		memset(buffer, 0, nessie_bc_ctx.blocksize_B);
 		buffer[i/8] |= 0x80>>(i%8);
-		nessie_dec(key, buffer);
+		nessie_bc_dec(key, buffer);
 	}
 	/* test set 7 */
 	set=7;
 	print_setheader(set);
 	for(i=0; i<256; ++i){
 		print_set_vector(set, i);
-		memset(key, i, (nessie_ctx.keysize+7)/8);
-		memset(buffer, i, nessie_ctx.blocksize_B);
-		nessie_dec(key, buffer);
+		memset(key, i, (nessie_bc_ctx.keysize_b+7)/8);
+		memset(buffer, i, nessie_bc_ctx.blocksize_B);
+		nessie_bc_dec(key, buffer);
 	}
 	/* test set 8 */
 	set=8;
 	print_setheader(set);
 	/* 8 - 0*/
 	print_set_vector(set, 0);
-	for(i=0; i<(nessie_ctx.keysize+7)/8; ++i){
+	for(i=0; i<(nessie_bc_ctx.keysize_b+7)/8; ++i){
 		key[i]=i;
 	}
-	for(i=0; i<nessie_ctx.blocksize_B; ++i){
+	for(i=0; i<nessie_bc_ctx.blocksize_B; ++i){
 		buffer[i]=i*0x11;
 	}
-	nessie_dec(key, buffer);
+	nessie_bc_dec(key, buffer);
 	/* 8 - 1 */
 	print_set_vector(set, 1);	
- 	for(i=0; i<(nessie_ctx.keysize+7)/8; ++i){
+ 	for(i=0; i<(nessie_bc_ctx.keysize_b+7)/8; ++i){
 		key[i]=kasumi_key[i%sizeof(kasumi_key)];
 	}
-	for(i=0; i<nessie_ctx.blocksize_B; ++i){
+	for(i=0; i<nessie_bc_ctx.blocksize_B; ++i){
 		buffer[i]=kasumi_plain[i%sizeof(kasumi_plain)];
 	}
 	print_footer();