define BLA_TEMPLATE2
$(2): $(3)
- echo $$@
- echo $$^
- $(CC) $(CFLAGS) $(LDFLAGS)$(patsubst %.elf,%.map,$(2)) -o \
+ @echo "[gcc]: $$@"
+# echo $$^
+ @$(CC) $(CFLAGS) $(LDFLAGS)$(patsubst %.elf,%.map,$(2)) -o \
$(2) \
$(3) \
$(LIBS)
uint8_t buffer[SHA256_BLOCK_BITS/8];
uint8_t i;
+ memset(buffer, 0, SHA256_BLOCK_BITS/8);
if (kl > SHA256_BLOCK_BITS){
sha256((void*)buffer, key, kl);
} else {
uint8_t i;
sha256_ctx_t a;
+ memset(buffer, 0, SHA256_BLOCK_BITS/8);
if (kl > SHA256_BLOCK_BITS){
sha256((void*)buffer, key, kl);
} else {
sha256_init(&a);
sha256_nextBlock(&a, buffer); /* hash key ^ opad */
sha256_ctx2hash((void*)buffer, s); /* copy hash(key ^ ipad, msg) to buffer */
- sha256_lastBlock(s, buffer, SHA256_HASH_BITS);
+ sha256_lastBlock(&a, buffer, SHA256_HASH_BITS);
+ memcpy(s, &a, sizeof(sha256_ctx_t));
#if defined SECURE_WIPE_BUFFER
memset(buffer, 0, SHA256_BLOCK_BITS/8);
memset(a.h, 0, 8*4);
#include "sha256.h"
#define HMAC_BITS SHA256_HASH_BITS
-#define HMAC_BYTES (HMAC_BITS/8)
+#define HMAC_BYTES ((HMAC_BITS+7)/8)
typedef sha256_ctx_t hmac_sha256_ctx_t;
# comment out the following line for removement of HMAC-SHA256 from the build process
MACS += $(ALGO_NAME)
-$(ALGO_NAME)_OBJ := hmac-sha256.o
-$(ALGO_NAME)_TEST_BIN := main.o debug.o uart.o serial-tools.o sha256-asm.o \
- xtea-asm.o arcfour-asm.o prng.o cast5.o
+$(ALGO_NAME)_OBJ := hmac-sha256.o sha256-asm.o
+$(ALGO_NAME)_TEST_BIN := main-hmac-sha256-test.o debug.o uart.o serial-tools.o \
+ hmac-sha256.o sha256-asm.o nessie_mac_test.o
$(ALGO_NAME)_NESSIE_TEST := "nessie"
$(ALGO_NAME)_PEROFRMANCE_TEST := "performance"
--- /dev/null
+/*
+ * HMAC-SHA256 test-suit
+ *
+*/
+
+#include "config.h"
+#include "serial-tools.h"
+#include "uart.h"
+#include "debug.h"
+
+#include "sha256.h"
+#include "hmac-sha256.h"
+
+#include "nessie_mac_test.h"
+
+#include <stdint.h>
+#include <string.h>
+
+char* algo_name = "HMAC-SHA256";
+
+/*****************************************************************************
+ * additional validation-functions *
+ *****************************************************************************/
+void hmacsha256_next_dummy(void* buffer, void* ctx){
+ sha256_nextBlock(ctx, buffer);
+}
+
+void hmacsha256_init_dummy(void* key, uint16_t keysize_b, void* ctx){
+ hmac_sha256_init(ctx, key, keysize_b);
+}
+
+void hmacsha256_last_dummy(void* buffer, uint16_t size_b, void* key, uint16_t keysize_b, void* ctx){
+ sha256_lastBlock(ctx, buffer, size_b);
+ hmac_sha256_final(ctx, key, keysize_b);
+}
+
+void testrun_nessie_hmacsha256(void){
+ nessie_mac_ctx.macsize_b = 256;
+ nessie_mac_ctx.keysize_b = 512;
+ nessie_mac_ctx.blocksize_B = 512/8;
+ nessie_mac_ctx.ctx_size_B = sizeof(hmac_sha256_ctx_t);
+ nessie_mac_ctx.name = algo_name;
+ nessie_mac_ctx.mac_init = (nessie_mac_init_fpt)hmacsha256_init_dummy;
+ nessie_mac_ctx.mac_next = (nessie_mac_next_fpt)hmacsha256_next_dummy;
+ nessie_mac_ctx.mac_last = (nessie_mac_last_fpt)hmacsha256_last_dummy;
+ nessie_mac_ctx.mac_conv = (nessie_mac_conv_fpt)sha256_ctx2hash;
+
+ nessie_mac_run();
+}
+
+
+
+/*****************************************************************************
+ * main *
+ *****************************************************************************/
+
+int main (void){
+ char str[20];
+ DEBUG_INIT();
+ uart_putstr("\r\n");
+
+ uart_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
+ uart_putstr(algo_name);
+ uart_putstr_P(PSTR(")\r\nloaded and running\r\n"));
+
+restart:
+ while(1){
+ if (!getnextwordn(str,20)) {DEBUG_S("DBG: W1\r\n"); goto error;}
+ if (strcmp(str, "nessie")) {DEBUG_S("DBG: 1b\r\n"); goto error;}
+ testrun_nessie_hmacsha256();
+ goto restart;
+ continue;
+ error:
+ uart_putstr("ERROR\r\n");
+ }
+
+}
+
}
void testrun_nessie_serpent(void){
- nessie_ctx.blocksize_B = 16;
- nessie_ctx.keysize = 128;
- nessie_ctx.name = cipher_name;
- nessie_ctx.ctx_size_B = sizeof(serpent_ctx_t);
- nessie_ctx.cipher_enc = (nessie_enc_fpt)serpent_enc;
- nessie_ctx.cipher_dec = (nessie_dec_fpt)serpent_dec;
- nessie_ctx.cipher_genctx = (nessie_gen_fpt)serpent_genctx_dummy;
+ nessie_bc_ctx.blocksize_B = 16;
+ nessie_bc_ctx.keysize_b = 128;
+ nessie_bc_ctx.name = cipher_name;
+ nessie_bc_ctx.ctx_size_B = sizeof(serpent_ctx_t);
+ nessie_bc_ctx.cipher_enc = (nessie_bc_enc_fpt)serpent_enc;
+ nessie_bc_ctx.cipher_dec = (nessie_bc_dec_fpt)serpent_dec;
+ nessie_bc_ctx.cipher_genctx = (nessie_bc_gen_fpt)serpent_genctx_dummy;
- nessie_run();
+ nessie_bc_run();
- nessie_ctx.keysize = 192;
- nessie_run();
-
- nessie_ctx.keysize = 256;
- nessie_run();
+ nessie_bc_ctx.keysize_b = 192;
+ nessie_bc_run();
+ nessie_bc_ctx.keysize_b = 256;
+ nessie_bc_run();
}
xtea_dec((uint32_t*)buffer, (uint32_t*)buffer, ctx);
}
-void testrun_xtea(void){
- nessie_ctx.blocksize_B = 8;
- nessie_ctx.keysize = 128;
- nessie_ctx.name = cipher_name;
- nessie_ctx.ctx_size_B = 128/8;
- nessie_ctx.cipher_enc = (nessie_enc_fpt)xtea_enc_dummy;
- nessie_ctx.cipher_dec = (nessie_dec_fpt)xtea_dec_dummy;
- nessie_ctx.cipher_genctx = (nessie_gen_fpt)xtea_genctx_dummy;
+void testrun_nessie_xtea(void){
+ nessie_bc_ctx.blocksize_B = 8;
+ nessie_bc_ctx.keysize_b = 128;
+ nessie_bc_ctx.name = cipher_name;
+ nessie_bc_ctx.ctx_size_B = 128/8;
+ nessie_bc_ctx.cipher_enc = (nessie_bc_enc_fpt)xtea_enc_dummy;
+ nessie_bc_ctx.cipher_dec = (nessie_bc_dec_fpt)xtea_dec_dummy;
+ nessie_bc_ctx.cipher_genctx = (nessie_bc_gen_fpt)xtea_genctx_dummy;
- nessie_run();
+ nessie_bc_run();
}
while(1){
if (!getnextwordn(str,20)) {DEBUG_S("DBG: W1\r\n"); goto error;}
if (strcmp(str, "nessie")) {DEBUG_S("DBG: 1b\r\n"); goto error;}
- testrun_xtea();
+ testrun_nessie_xtea();
goto restart;
continue;
error:
-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',
}
}
-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);
}
"********************************************************************************\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"));
}
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 */
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();
#include <stdint.h>
-typedef void (*nessie_gen_fpt)(uint8_t*, uint16_t, void*);
-typedef void (*nessie_enc_fpt)(void*, void*);
-typedef void (*nessie_dec_fpt)(void*, void*);
+typedef void (*nessie_bc_gen_fpt)(uint8_t* key, uint16_t keysize_b, void* ctx);
+typedef void (*nessie_bc_enc_fpt)(void* buffer, void* ctx);
+typedef void (*nessie_bc_dec_fpt)(void* buffer, void* ctx);
-typedef struct nessie_ctx_st{
- uint16_t keysize;
+typedef struct nessie_bc_ctx_st{
+ uint16_t keysize_b;
uint16_t blocksize_B;
uint16_t ctx_size_B;
char* name;
- void (*cipher_genctx)(uint8_t* key, uint16_t keysize, void* ctx);
- void (*cipher_enc)(void* buffer, void* ctx);
- void (*cipher_dec)(void* buffer, void* ctx);
-} nessie_ctx_t;
+ nessie_bc_gen_fpt cipher_genctx;
+ nessie_bc_enc_fpt cipher_enc;
+ nessie_bc_dec_fpt cipher_dec;
+} nessie_bc_ctx_t;
-extern nessie_ctx_t nessie_ctx;
+extern nessie_bc_ctx_t nessie_bc_ctx;
-void nessie_enc(uint8_t* key, uint8_t* pt);
-void nessie_dec(uint8_t* key, uint8_t* ct);
-void nessie_run(void);
+void nessie_bc_run(void);
#endif /*NESSIE_BC_TEST_H_*/
--- /dev/null
+/**
+ *
+ * author: Daniel Otte
+ * email: daniel.otte@rub.de
+ * license: GPLv3
+ *
+ * a suit for running the nessie-tests for MACs
+ *
+ * */
+#include <stdint.h>
+#include <string.h>
+#include "nessie_mac_test.h"
+#include "uart.h"
+
+nessie_mac_ctx_t nessie_mac_ctx;
+
+#define KEYSIZE_B ((nessie_mac_ctx.keysize_b+7)/8)
+#define MACSIZE_B ((nessie_mac_ctx.macsize_b+7)/8)
+
+#define PRINTKEY printitem("key", key, KEYSIZE_B)
+#define PRINTMAC printitem("MAC", mac, MACSIZE_B)
+
+static void printblock(uint8_t* block, uint16_t blocksize_bit){
+ char tab [] = {'0', '1', '2', '3',
+ '4', '5', '6', '7',
+ '8', '9', 'A', 'B',
+ 'C', 'D', 'E', 'F'};
+ uint16_t i;
+ for(i=0; i<(blocksize_bit+7)/8; ++i){
+ uart_putc(tab[(block[i])>>4]);
+ uart_putc(tab[(block[i])&0xf]);
+ }
+}
+
+#define SPACES 31
+#define BYTESPERLINE 16
+
+static void printitem(char* name, uint8_t* buffer, uint16_t size_B){
+ uint8_t name_len;
+ uint8_t i;
+ name_len=strlen(name);
+ if(name_len>SPACES-1){
+ uart_putstr_P(PSTR("\r\n!!! formatting error !!!\r\n"));
+ return;
+ }
+ uart_putstr_P(PSTR("\r\n"));
+ for(i=0; i<SPACES-name_len-1; ++i){
+ uart_putc(' ');
+ }
+ uart_putstr(name);
+ uart_putc('=');
+ /* now the data printing begins */
+ if(size_B<=BYTESPERLINE){
+ /* one line seems sufficient */
+ printblock(buffer, size_B*8);
+ } else {
+ /* we need more lines */
+ printblock(buffer, BYTESPERLINE*8); /* first line */
+ int16_t toprint = size_B - BYTESPERLINE;
+ buffer += BYTESPERLINE;
+ while(toprint > 0){
+ uart_putstr_P(PSTR("\r\n"));
+ for(i=0; i<SPACES; ++i){
+ uart_putc(' ');
+ }
+ printblock(buffer, ((toprint>BYTESPERLINE)?BYTESPERLINE:toprint)*8);
+ buffer += BYTESPERLINE;
+ toprint -= BYTESPERLINE;
+ }
+ }
+}
+
+static void print_set_vector(uint8_t set, uint16_t vector){
+ uart_putstr_P(PSTR("\r\n\r\nSet "));
+ uart_putc('0'+set%10);
+ uart_putstr_P(PSTR(", vector#"));
+ uart_putc((vector<100)?' ':'0'+vector/100);
+ uart_putc((vector<10 )?' ':'0'+(vector/10)%10);
+ uart_putc('0'+vector%10);
+ uart_putc(':');
+}
+
+/* example:
+Test vectors -- set 3
+=====================
+ */
+static void print_setheader(uint8_t set){
+ uart_putstr_P(PSTR("\r\n\r\nTest vectors -- set "));
+ uart_putc('0'+set%10);
+ uart_putstr_P(PSTR("\r\n====================="));
+}
+
+/* example:
+********************************************************************************
+*Project NESSIE - New European Schemes for Signature, Integrity, and Encryption*
+********************************************************************************
+
+Primitive Name: Serpent
+=======================
+Key size: 256 bits
+Block size: 128 bits
+*/
+
+static void print_header(void){
+ uint16_t i;
+ uart_putstr_P(PSTR("\r\n\r\n"
+ "********************************************************************************\r\n"
+ "* micro-cryt - crypto primitives for microcontrolles by Daniel Otte *\r\n"
+ "********************************************************************************\r\n"
+ "\r\n"));
+ uart_putstr_P(PSTR("Primitive Name: "));
+ uart_putstr(nessie_mac_ctx.name);
+ uart_putstr_P(PSTR("\r\n"));
+ for(i=0; i<16+strlen(nessie_mac_ctx.name); ++i){
+ uart_putc('=');
+ }
+ uart_putstr_P(PSTR("\r\nHash size: "));
+ if(nessie_mac_ctx.macsize_b >100){
+ uart_putc('0'+nessie_mac_ctx.macsize_b/100);
+ }
+ if(nessie_mac_ctx.macsize_b>10){
+ uart_putc('0'+(nessie_mac_ctx.macsize_b/10)%10);
+ }
+ uart_putc('0'+nessie_mac_ctx.macsize_b%10);
+ uart_putstr_P(PSTR(" bits\r\n"));
+}
+
+static void print_footer(void){
+ uart_putstr_P(PSTR("\r\n\r\n\r\n\r\nEnd of test vectors\r\n\r\n"));
+}
+
+static
+void ascii_mac(char* data, char* desc, uint8_t* key){
+ uint8_t ctx[nessie_mac_ctx.ctx_size_B];
+ uint8_t mac[MACSIZE_B];
+ uint16_t sl;
+
+ uart_putstr_P(PSTR("\r\n message="));
+ uart_putstr(desc);
+ PRINTKEY;
+ nessie_mac_ctx.mac_init(key, nessie_mac_ctx.keysize_b, ctx);
+ sl = strlen(data);
+ while(sl>=nessie_mac_ctx.blocksize_B){
+ nessie_mac_ctx.mac_next(data, ctx);
+ data += nessie_mac_ctx.blocksize_B;
+ sl -= nessie_mac_ctx.blocksize_B;
+ }
+ nessie_mac_ctx.mac_last(data, sl*8, key, nessie_mac_ctx.keysize_b, ctx);
+ nessie_mac_ctx.mac_conv(mac, ctx);
+ PRINTMAC;
+}
+
+// message=1 million times "a"
+
+static
+void amillion_mac(uint8_t* key){
+ uint8_t ctx[nessie_mac_ctx.ctx_size_B];
+ uint8_t mac[MACSIZE_B];
+ uint8_t block[nessie_mac_ctx.blocksize_B];
+ uint32_t n=1000000LL;
+
+ uart_putstr_P(PSTR("\r\n message="));
+ uart_putstr_P(PSTR("1 million times \"a\""));
+ PRINTKEY;
+
+ memset(block, 'a', nessie_mac_ctx.blocksize_B);
+ nessie_mac_ctx.mac_init(key, nessie_mac_ctx.keysize_b, ctx);
+ while(n>=nessie_mac_ctx.blocksize_B){
+ nessie_mac_ctx.mac_next(block, ctx);
+ n -= nessie_mac_ctx.blocksize_B;
+ }
+ nessie_mac_ctx.mac_last(block, n*8, key, nessie_mac_ctx.keysize_b, ctx);
+ nessie_mac_ctx.mac_conv(mac, ctx);
+ PRINTMAC;
+}
+
+
+static
+void zero_mac(uint16_t n, uint8_t* key){
+ uint8_t ctx[nessie_mac_ctx.ctx_size_B];
+ uint8_t mac[MACSIZE_B];
+ uint8_t block[nessie_mac_ctx.blocksize_B];
+
+ uart_putstr_P(PSTR("\r\n message="));
+ if(n>=10000)
+ uart_putc('0'+n/10000);
+ if(n>=1000)
+ uart_putc('0'+(n/1000)%10);
+ if(n>=100)
+ uart_putc('0'+(n/100)%10);
+ if(n>=10)
+ uart_putc('0'+(n/10)%10);
+ uart_putc('0'+n%10);
+ uart_putstr_P(PSTR(" zero bits"));
+ PRINTKEY;
+
+ memset(block, 0, nessie_mac_ctx.blocksize_B);
+ nessie_mac_ctx.mac_init(key, nessie_mac_ctx.keysize_b,ctx);;
+ while(n>=nessie_mac_ctx.blocksize_B*8){
+ nessie_mac_ctx.mac_next(block, ctx);
+ n -= nessie_mac_ctx.blocksize_B*8;
+ }
+ nessie_mac_ctx.mac_last(block, n, key, nessie_mac_ctx.keysize_b, ctx);
+ nessie_mac_ctx.mac_conv(mac, ctx);
+ PRINTMAC;
+}
+
+static
+void one_in512_mac(uint16_t pos, uint8_t* key){
+ uint8_t ctx[nessie_mac_ctx.ctx_size_B];
+ uint8_t mac[MACSIZE_B];
+ uint8_t block[nessie_mac_ctx.blocksize_B];
+ uint16_t n=512;
+ char* tab[8]={"80", "40", "20", "10",
+ "08", "04", "02", "01" };
+
+ pos&=511;
+ uart_putstr_P(PSTR("\r\n message="));
+ uart_putstr_P(PSTR("512-bit string: "));
+ if((pos/8) >=10){
+ uart_putc('0'+(pos/8/10)%10);
+ } else {
+ uart_putc(' ');
+ }
+ uart_putc('0'+(pos/8)%10);
+ uart_putstr_P(PSTR("*00,"));
+ uart_putstr(tab[pos&7]);
+ uart_putc(',');
+ if(63-(pos/8) >=10){
+ uart_putc('0'+((63-pos/8)/10)%10);
+ } else {
+ uart_putc(' ');
+ }
+ uart_putc('0'+(63-pos/8)%10);
+ uart_putstr_P(PSTR("*00"));
+ PRINTKEY;
+
+ /* now the real stuff */
+ memset(block, 0, 512/8);
+ block[pos>>3] = 0x80>>(pos&0x7);
+ nessie_mac_ctx.mac_init(key, nessie_mac_ctx.keysize_b, ctx);;
+ while(n>=nessie_mac_ctx.blocksize_B*8){
+ nessie_mac_ctx.mac_next(block, ctx);
+ n -= nessie_mac_ctx.blocksize_B*8;
+ }
+ nessie_mac_ctx.mac_last(block, n, key, nessie_mac_ctx.keysize_b, ctx);
+ nessie_mac_ctx.mac_conv(mac, ctx);
+ PRINTMAC;
+}
+
+static
+void tv4_mac(uint8_t* key){
+ uint8_t ctx[nessie_mac_ctx.ctx_size_B];
+ uint8_t mac[MACSIZE_B];
+ uint8_t block[256/8];
+ uint16_t n=256;
+ uint32_t i;
+
+ uart_putstr_P(PSTR("\r\n message="));
+ uart_putstr(PSTR("256 zero bits"));
+ memset(block, 0, 256/8);
+
+ nessie_mac_ctx.mac_init(key, nessie_mac_ctx.keysize_b, ctx);;
+ while(n>=nessie_mac_ctx.blocksize_B*8){
+ nessie_mac_ctx.mac_next(block, ctx);
+ n -= nessie_mac_ctx.blocksize_B*8;
+ }
+ nessie_mac_ctx.mac_last(block, n, key, nessie_mac_ctx.keysize_b, ctx);
+ nessie_mac_ctx.mac_conv(mac, ctx);
+ PRINTMAC;
+ for(i=1; i<100000L; ++i){ /* this assumes BLOCKSIZE >= HASHSIZE */
+ nessie_mac_ctx.mac_init(key, nessie_mac_ctx.keysize_b, ctx);;
+ nessie_mac_ctx.mac_last(mac, nessie_mac_ctx.macsize_b, key, nessie_mac_ctx.keysize_b, ctx);
+ nessie_mac_ctx.mac_conv(mac, ctx);
+ }
+ printitem("iterated 100000 times", mac, MACSIZE_B);
+}
+
+
+void nessie_mac_run(void){
+ uint16_t i;
+ uint8_t set;
+ uint8_t keyproto[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
+ 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
+ 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
+ uint8_t key[KEYSIZE_B];
+
+ print_header();
+ /* test set 1 */
+ char* challange[10][2]= {
+ {"", "\"\" (empty string)"},
+ {"a", "\"a\""},
+ {"abc", "\"abc\""},
+ {"message digest", "\"message digest\""},
+ {"abcdefghijklmnopqrstuvwxyz","\"abcdefghijklmnopqrstuvwxyz\""},
+ {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+ "\"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq\""},
+ {"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "abcdefghijklmnopqrstuvwxyz"
+ "0123456789" , "\"A...Za...z0...9\""},
+ {"1234567890" "1234567890" "1234567890" "1234567890"
+ "1234567890" "1234567890" "1234567890" "1234567890",
+ "8 times \"1234567890\""},
+ {"Now is the time for all ", "\"Now is the time for all \""},
+ {"Now is the time for it", "\"Now is the time for it\""}
+ };
+ set=1;
+ print_setheader(set);
+ for(i=0; i<KEYSIZE_B; ++i){
+ key[i] = keyproto[i%sizeof(keyproto)];
+ }
+ for(i=0; i<10; ++i){
+ print_set_vector(set, i);
+ ascii_mac(challange[i][0], challange[i][1], key);
+ }
+ print_set_vector(set, i);
+ amillion_mac(key);
+ for(i=0; i<KEYSIZE_B; ++i){
+ key[i] = keyproto[16+i%8];
+ }
+ for(i=0; i<10; ++i){
+ print_set_vector(set, 11+i);
+ ascii_mac(challange[i][0], challange[i][1], key);
+ }
+ print_set_vector(set, 11+i);
+ amillion_mac(key);
+ /* test set 2 */
+ set=2;
+ for(i=0; i<KEYSIZE_B; ++i){
+ key[i] = keyproto[i%sizeof(keyproto)];
+ }
+ print_setheader(set);
+ for(i=0; i<1024; ++i){
+ print_set_vector(set, i);
+ zero_mac(i, key);
+ }
+ /* test set 3 */
+ set=3;
+ print_setheader(set);
+ /* we use the same key as above */
+ for(i=0; i<512; ++i){
+ print_set_vector(set, i);
+ one_in512_mac(i, key);
+ }
+ /* test set 4 */
+ set=4;
+ print_setheader(set);
+ /* we use the same key as above */
+ print_set_vector(set, 0);
+ tv4_mac(key);
+ /* test set 5 */
+ for(i=0; i<nessie_mac_ctx.keysize_b; ++i){
+ print_set_vector(set, i);
+ memset(key, 0, KEYSIZE_B);
+ key[i>>3]=0x80>>(i&0x7);
+ ascii_mac("ABC", "\"ABC\"", key);
+ }
+ print_footer();
+}
--- /dev/null
+#ifndef NESSIE_MAC_TEST_H_
+#define NESSIE_MAC_TEST_H_
+
+#include <stdint.h>
+
+typedef void (*nessie_mac_init_fpt)(void* key, uint16_t keysize_b, void* ctx);
+typedef void (*nessie_mac_next_fpt)(void* buffer, void* ctx);
+typedef void (*nessie_mac_last_fpt)(void* buffer, uint16_t size_b, void* key, uint16_t keysize_b, void* ctx);
+typedef void (*nessie_mac_conv_fpt)(void* buffer, void* ctx);
+
+
+typedef struct nessie_mac_ctx_st{
+ uint16_t macsize_b;
+ uint16_t keysize_b;
+ uint16_t blocksize_B;
+ uint16_t ctx_size_B;
+ char* name;
+ nessie_mac_init_fpt mac_init;
+ nessie_mac_next_fpt mac_next;
+ nessie_mac_last_fpt mac_last;
+ nessie_mac_conv_fpt mac_conv;
+} nessie_mac_ctx_t;
+
+
+extern nessie_mac_ctx_t nessie_mac_ctx;
+
+void nessie_mac_run(void);
+
+#endif /*NESSIE_MAC_TEST_H_*/
sha256_init(&s);
while(length >= SHA256_BLOCK_BITS){
sha256_nextBlock(&s, msg);
- msg += SHA256_BLOCK_BITS/8;
+ msg = (uint8_t*)msg + SHA256_BLOCK_BITS/8;
length -= SHA256_BLOCK_BITS;
}
sha256_lastBlock(&s, msg, length);
projects / avr-crypto-lib.git / commitdiff