nessie_hash_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 hashes
   8  *
   9  * */
  10 #include <stdint.h>
  11 #include <string.h>
  12 #include "nessie_hash_test.h"
  13 #include "nessie_common.h"
  14 #include "uart.h"
  15
  16 nessie_hash_ctx_t nessie_hash_ctx;
  17
  18 static
  19 void ascii_hash(char* data, char* desc){
  20         uint8_t ctx[nessie_hash_ctx.ctx_size_B];
  21         uint8_t hash[(nessie_hash_ctx.hashsize_b+7)/8];
  22         uint16_t sl;
  23
  24         uart_putstr_P(PSTR("\r\n                       message="));
  25         uart_putstr(desc);
  26         nessie_hash_ctx.hash_init(ctx);
  27         sl = strlen(data);
  28         while(sl>=nessie_hash_ctx.blocksize_B){
  29                 nessie_hash_ctx.hash_next(data, ctx);
  30                 data += nessie_hash_ctx.blocksize_B;
  31                 sl   -= nessie_hash_ctx.blocksize_B;
  32         }
  33         nessie_hash_ctx.hash_last(data, sl*8, ctx);
  34         nessie_hash_ctx.hash_conv(hash, ctx);
  35         nessie_print_item("hash", hash, (nessie_hash_ctx.hashsize_b+7)/8);
  36 }
  37
  38 // message=1 million times "a"
  39
  40 static
  41 void amillion_hash(void){
  42         uint8_t ctx[nessie_hash_ctx.ctx_size_B];
  43         uint8_t hash[(nessie_hash_ctx.hashsize_b+7)/8];
  44         uint8_t block[nessie_hash_ctx.blocksize_B];
  45         uint32_t n=1000000LL;
  46
  47         uart_putstr_P(PSTR("\r\n                       message="));
  48         uart_putstr_P(PSTR("1 million times \"a\""));
  49         memset(block, 'a', nessie_hash_ctx.blocksize_B);
  50         nessie_hash_ctx.hash_init(ctx);
  51         while(n>=nessie_hash_ctx.blocksize_B){
  52                 nessie_hash_ctx.hash_next(block, ctx);
  53                 n    -= nessie_hash_ctx.blocksize_B;
  54         }
  55         nessie_hash_ctx.hash_last(block, n*8, ctx);
  56         nessie_hash_ctx.hash_conv(hash, ctx);
  57         nessie_print_item("hash", hash, (nessie_hash_ctx.hashsize_b+7)/8);
  58 }
  59
  60
  61 static
  62 void zero_hash(uint16_t n){
  63         uint8_t ctx[nessie_hash_ctx.ctx_size_B];
  64         uint8_t hash[(nessie_hash_ctx.hashsize_b+7)/8];
  65         uint8_t block[nessie_hash_ctx.blocksize_B];
  66
  67         uart_putstr_P(PSTR("\r\n                       message="));
  68         if(n>=10000)
  69                 uart_putc('0'+n/10000);
  70         if(n>=1000)
  71                 uart_putc('0'+(n/1000)%10);
  72         if(n>=100)
  73                 uart_putc('0'+(n/100)%10);
  74         if(n>=10)
  75                 uart_putc('0'+(n/10)%10);
  76         uart_putc('0'+n%10);
  77         uart_putstr_P(PSTR(" zero bits"));
  78
  79         memset(block, 0, nessie_hash_ctx.blocksize_B);
  80         nessie_hash_ctx.hash_init(ctx);
  81         while(n>=nessie_hash_ctx.blocksize_B*8){
  82                 nessie_hash_ctx.hash_next(block, ctx);
  83                 n   -= nessie_hash_ctx.blocksize_B*8;
  84         }
  85         nessie_hash_ctx.hash_last(block, n, ctx);
  86         nessie_hash_ctx.hash_conv(hash, ctx);
  87         nessie_print_item("hash", hash, (nessie_hash_ctx.hashsize_b+7)/8);
  88 }
  89
  90 static
  91 void one_in512_hash(uint16_t pos){
  92         uint8_t ctx[nessie_hash_ctx.ctx_size_B];
  93         uint8_t hash[(nessie_hash_ctx.hashsize_b+7)/8];
  94         uint8_t block[nessie_hash_ctx.blocksize_B];
  95         uint16_t n=512;
  96         char* tab[8]={"80", "40", "20", "10",
  97                       "08", "04", "02", "01" };
  98
  99         pos&=511;
 100         uart_putstr_P(PSTR("\r\n                       message="));
 101         uart_putstr_P(PSTR("512-bit string: "));
 102         if((pos/8) >=10){
 103                 uart_putc('0'+(pos/8/10)%10);
 104         } else {
 105                 uart_putc(' ');
 106         }
 107         uart_putc('0'+(pos/8)%10);
 108         uart_putstr_P(PSTR("*00,"));
 109         uart_putstr(tab[pos&7]);
 110         uart_putc(',');
 111         if(63-(pos/8) >=10){
 112                 uart_putc('0'+((63-pos/8)/10)%10);
 113         } else {
 114                 uart_putc(' ');
 115         }
 116         uart_putc('0'+(63-pos/8)%10);
 117         uart_putstr_P(PSTR("*00"));
 118
 119         /* now the real stuff */
 120         memset(block, 0, 512/8);
 121         block[pos>>3] = 0x80>>(pos&0x7);
 122         nessie_hash_ctx.hash_init(ctx);
 123         while(n>=nessie_hash_ctx.blocksize_B*8){
 124                 nessie_hash_ctx.hash_next(block, ctx);
 125                 n   -= nessie_hash_ctx.blocksize_B*8;
 126         }
 127         nessie_hash_ctx.hash_last(block, n, ctx);
 128         nessie_hash_ctx.hash_conv(hash, ctx);
 129         nessie_print_item("hash", hash, (nessie_hash_ctx.hashsize_b+7)/8);
 130 }
 131
 132 static
 133 void tv4_hash(void){
 134         uint8_t ctx[nessie_hash_ctx.ctx_size_B];
 135         uint8_t hash[(nessie_hash_ctx.hashsize_b+7)/8];
 136         uint8_t block[256/8];
 137         uint16_t n=256;
 138         uint32_t i;
 139
 140         uart_putstr_P(PSTR("\r\n                       message="));
 141         uart_putstr(PSTR("256 zero bits"));
 142         memset(block, 0, 256/8);
 143
 144         nessie_hash_ctx.hash_init(ctx);
 145         while(n>=nessie_hash_ctx.blocksize_B*8){
 146                 nessie_hash_ctx.hash_next(block, ctx);
 147                 n    -= nessie_hash_ctx.blocksize_B*8;
 148         }
 149         nessie_hash_ctx.hash_last(block, n, ctx);
 150         nessie_hash_ctx.hash_conv(hash, ctx);
 151         nessie_print_item("hash", hash, (nessie_hash_ctx.hashsize_b+7)/8);
 152         for(i=1; i<100000L; ++i){ /* this assumes BLOCKSIZE >= HASHSIZE */
 153                 nessie_hash_ctx.hash_init(ctx);
 154                 nessie_hash_ctx.hash_last(hash, nessie_hash_ctx.hashsize_b, ctx);
 155                 nessie_hash_ctx.hash_conv(hash, ctx);
 156         }
 157         nessie_print_item("iterated 100000 times", hash, (nessie_hash_ctx.hashsize_b+7)/8);
 158 }
 159
 160 /*
 161    "" (empty string)
 162    message="a"
 163    message="abc"
 164    message="message digest"
 165    message="abcdefghijklmnopqrstuvwxyz"
 166    message="abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
 167    message="A...Za...z0...9"
 168    message=8 times "1234567890"
 169 */
 170
 171
 172 void nessie_hash_run(void){
 173         uint16_t i;
 174         uint8_t set;
 175
 176         nessie_print_header(nessie_hash_ctx.name, 0, 0, nessie_hash_ctx.hashsize_b, 0, 0);
 177         /* test set 1 */
 178         char* challange[8][2]= {
 179                 {"", "\"\" (empty string)"},
 180                 {"a", "\"a\""},
 181                 {"abc", "\"abc\""},
 182                 {"message digest", "\"message digest\""},
 183                 {"abcdefghijklmnopqrstuvwxyz","\"abcdefghijklmnopqrstuvwxyz\""},
 184                 {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 185                         "\"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq\""},
 186                 {"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 187                  "abcdefghijklmnopqrstuvwxyz"
 188                  "0123456789"   , "\"A...Za...z0...9\""},
 189                 {"1234567890" "1234567890" "1234567890" "1234567890"
 190                  "1234567890" "1234567890" "1234567890" "1234567890",
 191                  "8 times \"1234567890\""}
 192         };
 193         set=1;
 194         nessie_print_setheader(set);
 195         for(i=0; i<8; ++i){
 196                 nessie_print_set_vector(set, i);
 197                 ascii_hash(challange[i][0], challange[i][1]);
 198         }
 199         nessie_print_set_vector(set, i);
 200         amillion_hash();
 201         /* test set 2 */
 202         set=2;
 203         nessie_print_setheader(set);
 204         for(i=0; i<1024; ++i){
 205                 nessie_print_set_vector(set, i);
 206                 zero_hash(i);
 207         }
 208         /* test set 3 */
 209         set=3;
 210         nessie_print_setheader(set);
 211         for(i=0; i<512; ++i){
 212                 nessie_print_set_vector(set, i);
 213                 one_in512_hash(i);
 214         }
 215         /* test set 4 */
 216         set=4;
 217         nessie_print_setheader(set);
 218         nessie_print_set_vector(set, 0);
 219         tv4_hash();
 220
 221         nessie_print_footer();
 222 }