nessie_stream_test.c

   1 /**
   2  *
   3  * author: Daniel Otte
   4  * email:  daniel.otte@rub.de
   5  * license: GPLv3
   6  *
   7  * a suit for running the nessie-tests for streamciphers
   8  *
   9  * */
  10 #include <stdint.h>
  11 #include <string.h>
  12 #include "nessie_stream_test.h"
  13 #include "uart.h"
  14
  15 nessie_stream_ctx_t nessie_stream_ctx;
  16
  17 static void printblock(uint8_t* block, uint16_t blocksize_bit){
  18         char tab [] = {'0', '1', '2', '3',
  19                                    '4', '5', '6', '7',
  20                                    '8', '9', 'A', 'B',
  21                                    'C', 'D', 'E', 'F'};
  22         uint16_t i;
  23         for(i=0; i<(blocksize_bit+7)/8; ++i){
  24                 uart_putc(tab[(block[i])>>4]);
  25                 uart_putc(tab[(block[i])&0xf]);
  26         }
  27 }
  28
  29 #define SPACES 31
  30 #define BYTESPERLINE 16
  31
  32 static void printitem(char* name, uint8_t* buffer, uint16_t size_B){
  33         uint8_t name_len;
  34         uint8_t i;
  35         name_len=strlen(name);
  36         if(name_len>SPACES-1){
  37                 uart_putstr_P(PSTR("\r\n!!! formatting error !!!\r\n"));
  38                 return;
  39         }
  40         uart_putstr_P(PSTR("\r\n"));
  41         for(i=0; i<SPACES-name_len-1; ++i){
  42                 uart_putc(' ');
  43         }
  44         uart_putstr(name);
  45         uart_putc('=');
  46         /* now the data printing begins */
  47         if(size_B<=BYTESPERLINE){
  48                 /* one line seems sufficient */
  49                 printblock(buffer, size_B*8);
  50         } else {
  51                 /* we need more lines */
  52                 printblock(buffer, BYTESPERLINE*8); /* first line */
  53                 int16_t toprint = size_B - BYTESPERLINE;
  54                 buffer += BYTESPERLINE;
  55                 while(toprint > 0){
  56                         uart_putstr_P(PSTR("\r\n"));
  57                         for(i=0; i<SPACES; ++i){
  58                                 uart_putc(' ');
  59                         }
  60                         printblock(buffer, ((toprint>BYTESPERLINE)?BYTESPERLINE:toprint)*8);
  61                         buffer  += BYTESPERLINE;
  62                         toprint -= BYTESPERLINE;
  63                 }
  64         }
  65 }
  66
  67 static
  68 void memxor(void* dest, void* src, uint8_t length){
  69         while(length--){
  70                 *((uint8_t*)dest) ^= *((uint8_t*)src);
  71                 dest = (uint8_t*)dest +1;
  72                 src  = (uint8_t*)src +1;
  73         }
  74 }
  75
  76 #define BLOCKSIZE_B 64
  77
  78 static
  79 void nessie_gen_block(void* ctx, uint8_t* block){
  80         uint16_t i;
  81         for(i=0; i<BLOCKSIZE_B; ++i){
  82                 block[i] = nessie_stream_ctx.cipher_enc(ctx);
  83         }
  84 }
  85
  86 static
  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];
  91         uint8_t i;
  92
  93         memset(xorbuffer, 0, BLOCKSIZE_B);
  94
  95         printitem("key", key, (nessie_stream_ctx.keysize_b+7)/8);
  96
  97         nessie_stream_ctx.cipher_genctx(key, nessie_stream_ctx.keysize_b, ctx);
  98
  99         nessie_gen_block(ctx, buffer);
 100         memxor(xorbuffer, buffer, BLOCKSIZE_B);
 101         printitem("stream[0..63]", buffer, BLOCKSIZE_B);
 102
 103         for(i=0; i<((192-0)/BLOCKSIZE_B-1); ++i){
 104                 nessie_gen_block(ctx, buffer);
 105                 memxor(xorbuffer, buffer, BLOCKSIZE_B);
 106         }
 107
 108         nessie_gen_block(ctx, buffer);
 109         memxor(xorbuffer, buffer, BLOCKSIZE_B);
 110         printitem("stream[192..255]", buffer, BLOCKSIZE_B);
 111
 112         nessie_gen_block(ctx, buffer);
 113         memxor(xorbuffer, buffer, BLOCKSIZE_B);
 114         printitem("stream[256..319]", buffer, BLOCKSIZE_B);
 115
 116         for(i=0; i<((448-256)/BLOCKSIZE_B-1); ++i){
 117                 nessie_gen_block(ctx, buffer);
 118                 memxor(xorbuffer, buffer, BLOCKSIZE_B);
 119         }
 120
 121         nessie_gen_block(ctx, buffer);
 122         memxor(xorbuffer, buffer, BLOCKSIZE_B);
 123         printitem("stream[448..511]", buffer, BLOCKSIZE_B);
 124
 125         printitem("stream[0..511]xored", xorbuffer, BLOCKSIZE_B);
 126
 127 }
 128
 129
 130 static
 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];
 135         uint32_t i;
 136
 137         memset(xorbuffer, 0, BLOCKSIZE_B);
 138
 139         printitem("key", key, (nessie_stream_ctx.keysize_b+7)/8);
 140
 141         nessie_stream_ctx.cipher_genctx(key, nessie_stream_ctx.keysize_b, ctx);
 142
 143         nessie_gen_block(ctx, buffer);
 144         memxor(xorbuffer, buffer, BLOCKSIZE_B);
 145         printitem("stream[0..63]", buffer, BLOCKSIZE_B);
 146
 147         for(i=0; i<((65472-0)/BLOCKSIZE_B-1); ++i){
 148                 nessie_gen_block(ctx, buffer);
 149                 memxor(xorbuffer, buffer, BLOCKSIZE_B);
 150         }
 151
 152         nessie_gen_block(ctx, buffer);
 153         memxor(xorbuffer, buffer, BLOCKSIZE_B);
 154         printitem("stream[65472..65535]", buffer, BLOCKSIZE_B);
 155
 156         nessie_gen_block(ctx, buffer);
 157         memxor(xorbuffer, buffer, BLOCKSIZE_B);
 158         printitem("stream[65536..65599]", buffer, BLOCKSIZE_B);
 159
 160         for(i=0; i<((131008-65536)/BLOCKSIZE_B-1); ++i){
 161                 nessie_gen_block(ctx, buffer);
 162                 memxor(xorbuffer, buffer, BLOCKSIZE_B);
 163         }
 164
 165         nessie_gen_block(ctx, buffer);
 166         memxor(xorbuffer, buffer, BLOCKSIZE_B);
 167         printitem("stream[131008..131071]", buffer, BLOCKSIZE_B);
 168
 169         printitem("stream[0..131071]xored", xorbuffer, BLOCKSIZE_B);
 170
 171 }
 172
 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);
 180         uart_putc(':');
 181 }
 182
 183 /* example:
 184 Test vectors -- set 3
 185 =====================
 186  */
 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====================="));
 191 }
 192
 193 /* example:
 194 ********************************************************************************
 195 *Project NESSIE - New European Schemes for Signature, Integrity, and Encryption*
 196 ********************************************************************************
 197
 198 Primitive Name: Serpent
 199 =======================
 200 Key size: 256 bits
 201 Block size: 128 bits
 202 */
 203
 204 static void print_header(void){
 205         uint16_t i;
 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"
 210         "\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){
 215                 uart_putc('=');
 216         }
 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);
 220         }
 221         if(nessie_stream_ctx.keysize_b>10){
 222                 uart_putc('0'+(nessie_stream_ctx.keysize_b/10)%10);
 223         }
 224         uart_putc('0'+nessie_stream_ctx.keysize_b%10);
 225         uart_putstr_P(PSTR(" bits\r\n"));
 226 }
 227
 228 static void print_footer(void){
 229         uart_putstr_P(PSTR("\r\n\r\n\r\n\r\nEnd of test vectors"));
 230 }
 231
 232 void nessie_stream_run(void){
 233         uint16_t i;
 234         uint8_t set;
 235         uint8_t key[(nessie_stream_ctx.keysize_b+7)/8];
 236
 237         print_header();
 238         /* test set 1 */
 239         set=1;
 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);
 246         }
 247         /* test set 2 */
 248         set=2;
 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);
 254         }
 255         /* test set 3 */
 256         set=3;
 257         print_setheader(set);
 258         for(i=0; i<256; ++i){
 259                 uint8_t j;
 260                 print_set_vector(set, i);
 261                 for(j=0; j<(nessie_stream_ctx.keysize_b+7)/8; ++j){
 262                         key[j]=(i+j)&0xff;
 263                 }
 264                 nessie_stream_enc(key);
 265         }
 266         /* test set 4 */
 267         set=4;
 268         print_setheader(set);
 269         for(i=0; i<4; ++i){
 270                 uint8_t j;
 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;
 274                 }
 275                 nessie_stream_enc_large(key);
 276         }
 277
 278         print_footer();
 279 }