4 * email: daniel.otte@rub.de
7 * a suit for running the nessie-tests for streamciphers
12 #include "nessie_stream_test.h"
15 nessie_stream_ctx_t nessie_stream_ctx;
17 static void printblock(uint8_t* block, uint16_t blocksize_bit){
18 char tab [] = {'0', '1', '2', '3',
23 for(i=0; i<(blocksize_bit+7)/8; ++i){
24 uart_putc(tab[(block[i])>>4]);
25 uart_putc(tab[(block[i])&0xf]);
30 #define BYTESPERLINE 16
32 static void printitem(char* name, uint8_t* buffer, uint16_t size_B){
35 name_len=strlen(name);
36 if(name_len>SPACES-1){
37 uart_putstr_P(PSTR("\r\n!!! formatting error !!!\r\n"));
40 uart_putstr_P(PSTR("\r\n"));
41 for(i=0; i<SPACES-name_len-1; ++i){
46 /* now the data printing begins */
47 if(size_B<=BYTESPERLINE){
48 /* one line seems sufficient */
49 printblock(buffer, size_B*8);
51 /* we need more lines */
52 printblock(buffer, BYTESPERLINE*8); /* first line */
53 int16_t toprint = size_B - BYTESPERLINE;
54 buffer += BYTESPERLINE;
56 uart_putstr_P(PSTR("\r\n"));
57 for(i=0; i<SPACES; ++i){
60 printblock(buffer, ((toprint>BYTESPERLINE)?BYTESPERLINE:toprint)*8);
61 buffer += BYTESPERLINE;
62 toprint -= BYTESPERLINE;
68 void memxor(void* dest, void* src, uint8_t length){
70 *((uint8_t*)dest) ^= *((uint8_t*)src);
71 dest = (uint8_t*)dest +1;
72 src = (uint8_t*)src +1;
76 #define BLOCKSIZE_B 64
79 void nessie_gen_block(void* ctx, uint8_t* block){
81 for(i=0; i<BLOCKSIZE_B; ++i){
82 block[i] = nessie_stream_ctx.cipher_enc(ctx);
87 void nessie_stream_enc(uint8_t* key){
88 uint8_t ctx[nessie_stream_ctx.ctx_size_B];
89 uint8_t buffer[BLOCKSIZE_B];
90 uint8_t xorbuffer[BLOCKSIZE_B];
93 memset(xorbuffer, 0, BLOCKSIZE_B);
95 printitem("key", key, (nessie_stream_ctx.keysize_b+7)/8);
97 nessie_stream_ctx.cipher_genctx(key, nessie_stream_ctx.keysize_b, ctx);
99 nessie_gen_block(ctx, buffer);
100 memxor(xorbuffer, buffer, BLOCKSIZE_B);
101 printitem("stream[0..63]", buffer, BLOCKSIZE_B);
103 for(i=0; i<((192-0)/BLOCKSIZE_B-1); ++i){
104 nessie_gen_block(ctx, buffer);
105 memxor(xorbuffer, buffer, BLOCKSIZE_B);
108 nessie_gen_block(ctx, buffer);
109 memxor(xorbuffer, buffer, BLOCKSIZE_B);
110 printitem("stream[192..255]", buffer, BLOCKSIZE_B);
112 nessie_gen_block(ctx, buffer);
113 memxor(xorbuffer, buffer, BLOCKSIZE_B);
114 printitem("stream[256..319]", buffer, BLOCKSIZE_B);
116 for(i=0; i<((448-256)/BLOCKSIZE_B-1); ++i){
117 nessie_gen_block(ctx, buffer);
118 memxor(xorbuffer, buffer, BLOCKSIZE_B);
121 nessie_gen_block(ctx, buffer);
122 memxor(xorbuffer, buffer, BLOCKSIZE_B);
123 printitem("stream[448..511]", buffer, BLOCKSIZE_B);
125 printitem("stream[0..511]xored", xorbuffer, BLOCKSIZE_B);
131 void nessie_stream_enc_large(uint8_t* key){
132 uint8_t ctx[nessie_stream_ctx.ctx_size_B];
133 uint8_t buffer[BLOCKSIZE_B];
134 uint8_t xorbuffer[BLOCKSIZE_B];
137 memset(xorbuffer, 0, BLOCKSIZE_B);
139 printitem("key", key, (nessie_stream_ctx.keysize_b+7)/8);
141 nessie_stream_ctx.cipher_genctx(key, nessie_stream_ctx.keysize_b, ctx);
143 nessie_gen_block(ctx, buffer);
144 memxor(xorbuffer, buffer, BLOCKSIZE_B);
145 printitem("stream[0..63]", buffer, BLOCKSIZE_B);
147 for(i=0; i<((65472-0)/BLOCKSIZE_B-1); ++i){
148 nessie_gen_block(ctx, buffer);
149 memxor(xorbuffer, buffer, BLOCKSIZE_B);
152 nessie_gen_block(ctx, buffer);
153 memxor(xorbuffer, buffer, BLOCKSIZE_B);
154 printitem("stream[65472..65535]", buffer, BLOCKSIZE_B);
156 nessie_gen_block(ctx, buffer);
157 memxor(xorbuffer, buffer, BLOCKSIZE_B);
158 printitem("stream[65536..65599]", buffer, BLOCKSIZE_B);
160 for(i=0; i<((131008-65536)/BLOCKSIZE_B-1); ++i){
161 nessie_gen_block(ctx, buffer);
162 memxor(xorbuffer, buffer, BLOCKSIZE_B);
165 nessie_gen_block(ctx, buffer);
166 memxor(xorbuffer, buffer, BLOCKSIZE_B);
167 printitem("stream[131008..131071]", buffer, BLOCKSIZE_B);
169 printitem("stream[0..131071]xored", xorbuffer, BLOCKSIZE_B);
173 static void print_set_vector(uint8_t set, uint16_t vector){
174 uart_putstr_P(PSTR("\r\n\r\nSet "));
175 uart_putc('0'+set%10);
176 uart_putstr_P(PSTR(", vector#"));
177 uart_putc((vector<100)?' ':'0'+vector/100);
178 uart_putc((vector<10 )?' ':'0'+(vector/10)%10);
179 uart_putc('0'+vector%10);
184 Test vectors -- set 3
185 =====================
187 static void print_setheader(uint8_t set){
188 uart_putstr_P(PSTR("\r\n\r\nTest vectors -- set "));
189 uart_putc('0'+set%10);
190 uart_putstr_P(PSTR("\r\n====================="));
194 ********************************************************************************
195 *Project NESSIE - New European Schemes for Signature, Integrity, and Encryption*
196 ********************************************************************************
198 Primitive Name: Serpent
199 =======================
204 static void print_header(void){
206 uart_putstr_P(PSTR("\r\n\r\n"
207 "********************************************************************************\r\n"
208 "* micro-cryt - crypto primitives for microcontrolles by Daniel Otte *\r\n"
209 "********************************************************************************\r\n"
211 uart_putstr_P(PSTR("Primitive Name: "));
212 uart_putstr(nessie_stream_ctx.name);
213 uart_putstr_P(PSTR("\r\n"));
214 for(i=0; i<16+strlen(nessie_stream_ctx.name); ++i){
217 uart_putstr_P(PSTR("\r\nKey size: "));
218 if(nessie_stream_ctx.keysize_b>100){
219 uart_putc('0'+nessie_stream_ctx.keysize_b/100);
221 if(nessie_stream_ctx.keysize_b>10){
222 uart_putc('0'+(nessie_stream_ctx.keysize_b/10)%10);
224 uart_putc('0'+nessie_stream_ctx.keysize_b%10);
225 uart_putstr_P(PSTR(" bits\r\n"));
228 static void print_footer(void){
229 uart_putstr_P(PSTR("\r\n\r\n\r\n\r\nEnd of test vectors\r\n\r\n"));
232 void nessie_stream_run(void){
235 uint8_t key[(nessie_stream_ctx.keysize_b+7)/8];
240 print_setheader(set);
241 for(i=0; i<nessie_stream_ctx.keysize_b; ++i){
242 print_set_vector(set, i);
243 memset(key, 0, (nessie_stream_ctx.keysize_b+7)/8);
244 key[i/8] |= 0x80>>(i%8);
245 nessie_stream_enc(key);
249 print_setheader(set);
250 for(i=0; i<256; ++i){
251 print_set_vector(set, i);
252 memset(key, i, (nessie_stream_ctx.keysize_b+7)/8);
253 nessie_stream_enc(key);
257 print_setheader(set);
258 for(i=0; i<256; ++i){
260 print_set_vector(set, i);
261 for(j=0; j<(nessie_stream_ctx.keysize_b+7)/8; ++j){
264 nessie_stream_enc(key);
268 print_setheader(set);
271 print_set_vector(set, i);
272 for(j=0; j<(nessie_stream_ctx.keysize_b+7)/8; ++j){
273 key[j]=(i*5+j*0x53)&0xff;
275 nessie_stream_enc_large(key);