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 "nessie_common.h"
  14 #include "uart.h"
  15
  16 nessie_stream_ctx_t nessie_stream_ctx;
  17
  18
  19 #define BLOCKSIZE_B 64
  20
  21 static
  22 void memxor(void* dest, void* src, uint8_t length){
  23         while(length--){
  24                 *((uint8_t*)dest) ^= *((uint8_t*)src);
  25                 dest = (uint8_t*)dest +1;
  26                 src  = (uint8_t*)src +1;
  27         }
  28 }
  29
  30
  31 static
  32 void nessie_gen_block(void* ctx, uint8_t* block){
  33         uint16_t i;
  34         for(i=0; i<BLOCKSIZE_B; ++i){
  35                 block[i] = nessie_stream_ctx.cipher_enc(ctx);
  36         }
  37 }
  38
  39 static
  40 void nessie_stream_enc(uint8_t* key){
  41         uint8_t ctx[nessie_stream_ctx.ctx_size_B];
  42         uint8_t buffer[BLOCKSIZE_B];
  43         uint8_t xorbuffer[BLOCKSIZE_B];
  44         uint8_t i;
  45
  46         memset(xorbuffer, 0, BLOCKSIZE_B);
  47
  48         nessie_print_item("key", key, (nessie_stream_ctx.keysize_b+7)/8);
  49
  50         nessie_stream_ctx.cipher_genctx(key, nessie_stream_ctx.keysize_b, ctx);
  51
  52         nessie_gen_block(ctx, buffer);
  53         memxor(xorbuffer, buffer, BLOCKSIZE_B);
  54         nessie_print_item("stream[0..63]", buffer, BLOCKSIZE_B);
  55
  56         for(i=0; i<((192-0)/BLOCKSIZE_B-1); ++i){
  57                 nessie_gen_block(ctx, buffer);
  58                 memxor(xorbuffer, buffer, BLOCKSIZE_B);
  59         }
  60
  61         nessie_gen_block(ctx, buffer);
  62         memxor(xorbuffer, buffer, BLOCKSIZE_B);
  63         nessie_print_item("stream[192..255]", buffer, BLOCKSIZE_B);
  64
  65         nessie_gen_block(ctx, buffer);
  66         memxor(xorbuffer, buffer, BLOCKSIZE_B);
  67         nessie_print_item("stream[256..319]", buffer, BLOCKSIZE_B);
  68
  69         for(i=0; i<((448-256)/BLOCKSIZE_B-1); ++i){
  70                 nessie_gen_block(ctx, buffer);
  71                 memxor(xorbuffer, buffer, BLOCKSIZE_B);
  72         }
  73
  74         nessie_gen_block(ctx, buffer);
  75         memxor(xorbuffer, buffer, BLOCKSIZE_B);
  76         nessie_print_item("stream[448..511]", buffer, BLOCKSIZE_B);
  77
  78         nessie_print_item("stream[0..511]xored", xorbuffer, BLOCKSIZE_B);
  79
  80 }
  81
  82
  83 static
  84 void nessie_stream_enc_large(uint8_t* key){
  85         uint8_t ctx[nessie_stream_ctx.ctx_size_B];
  86         uint8_t buffer[BLOCKSIZE_B];
  87         uint8_t xorbuffer[BLOCKSIZE_B];
  88         uint32_t i;
  89
  90         memset(xorbuffer, 0, BLOCKSIZE_B);
  91
  92         nessie_print_item("key", key, (nessie_stream_ctx.keysize_b+7)/8);
  93
  94         nessie_stream_ctx.cipher_genctx(key, nessie_stream_ctx.keysize_b, ctx);
  95
  96         nessie_gen_block(ctx, buffer);
  97         memxor(xorbuffer, buffer, BLOCKSIZE_B);
  98         nessie_print_item("stream[0..63]", buffer, BLOCKSIZE_B);
  99
 100         for(i=0; i<((65472-0)/BLOCKSIZE_B-1); ++i){
 101                 nessie_gen_block(ctx, buffer);
 102                 memxor(xorbuffer, buffer, BLOCKSIZE_B);
 103         }
 104
 105         nessie_gen_block(ctx, buffer);
 106         memxor(xorbuffer, buffer, BLOCKSIZE_B);
 107         nessie_print_item("stream[65472..65535]", buffer, BLOCKSIZE_B);
 108
 109         nessie_gen_block(ctx, buffer);
 110         memxor(xorbuffer, buffer, BLOCKSIZE_B);
 111         nessie_print_item("stream[65536..65599]", buffer, BLOCKSIZE_B);
 112
 113         for(i=0; i<((131008-65536)/BLOCKSIZE_B-1); ++i){
 114                 nessie_gen_block(ctx, buffer);
 115                 memxor(xorbuffer, buffer, BLOCKSIZE_B);
 116         }
 117
 118         nessie_gen_block(ctx, buffer);
 119         memxor(xorbuffer, buffer, BLOCKSIZE_B);
 120         nessie_print_item("stream[131008..131071]", buffer, BLOCKSIZE_B);
 121
 122         nessie_print_item("stream[0..131071]xored", xorbuffer, BLOCKSIZE_B);
 123
 124 }
 125
 126 void nessie_stream_run(void){
 127         uint16_t i;
 128         uint8_t set;
 129         uint8_t key[(nessie_stream_ctx.keysize_b+7)/8];
 130
 131         nessie_print_header(nessie_stream_ctx.name, nessie_stream_ctx.keysize_b,
 132                             0, 0, 0, nessie_stream_ctx.ivsize_b);
 133         /* test set 1 */
 134         set=1;
 135         nessie_print_setheader(set);
 136         for(i=0; i<nessie_stream_ctx.keysize_b; ++i){
 137                 nessie_print_set_vector(set, i);
 138                 memset(key, 0, (nessie_stream_ctx.keysize_b+7)/8);
 139                 key[i/8] |= 0x80>>(i%8);
 140                 nessie_stream_enc(key);
 141         }
 142         /* test set 2 */
 143         set=2;
 144         nessie_print_setheader(set);
 145         for(i=0; i<256; ++i){
 146                 nessie_print_set_vector(set, i);
 147                 memset(key, i, (nessie_stream_ctx.keysize_b+7)/8);
 148                 nessie_stream_enc(key);
 149         }
 150         /* test set 3 */
 151         set=3;
 152         nessie_print_setheader(set);
 153         for(i=0; i<256; ++i){
 154                 uint8_t j;
 155                 nessie_print_set_vector(set, i);
 156                 for(j=0; j<(nessie_stream_ctx.keysize_b+7)/8; ++j){
 157                         key[j]=(i+j)&0xff;
 158                 }
 159                 nessie_stream_enc(key);
 160         }
 161         /* test set 4 */
 162         set=4;
 163         nessie_print_setheader(set);
 164         for(i=0; i<4; ++i){
 165                 uint8_t j;
 166                 nessie_print_set_vector(set, i);
 167                 for(j=0; j<(nessie_stream_ctx.keysize_b+7)/8; ++j){
 168                         key[j]=(i*5+j*0x53)&0xff;
 169                 }
 170                 nessie_stream_enc_large(key);
 171         }
 172
 173         nessie_print_footer();
 174 }