4 * email: daniel.otte@rub.de
7 * a suit for running the nessie-tests for hashes
12 #include "nessie_hash_test.h"
13 #include "nessie_common.h"
16 nessie_hash_ctx_t nessie_hash_ctx;
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];
24 uart_putstr_P(PSTR("\r\n message="));
26 nessie_hash_ctx.hash_init(ctx);
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;
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);
38 // message=1 million times "a"
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];
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;
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);
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];
67 uart_putstr_P(PSTR("\r\n message="));
69 uart_putc('0'+n/10000);
71 uart_putc('0'+(n/1000)%10);
73 uart_putc('0'+(n/100)%10);
75 uart_putc('0'+(n/10)%10);
77 uart_putstr_P(PSTR(" zero bits"));
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;
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);
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];
96 char* tab[8]={"80", "40", "20", "10",
97 "08", "04", "02", "01" };
100 uart_putstr_P(PSTR("\r\n message="));
101 uart_putstr_P(PSTR("512-bit string: "));
103 uart_putc('0'+(pos/8/10)%10);
107 uart_putc('0'+(pos/8)%10);
108 uart_putstr_P(PSTR("*00,"));
109 uart_putstr(tab[pos&7]);
112 uart_putc('0'+((63-pos/8)/10)%10);
116 uart_putc('0'+(63-pos/8)%10);
117 uart_putstr_P(PSTR("*00"));
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;
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);
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];
140 uart_putstr_P(PSTR("\r\n message="));
141 uart_putstr(PSTR("256 zero bits"));
142 memset(block, 0, 256/8);
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;
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);
157 nessie_print_item("iterated 100000 times", hash, (nessie_hash_ctx.hashsize_b+7)/8);
164 message="message digest"
165 message="abcdefghijklmnopqrstuvwxyz"
166 message="abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
167 message="A...Za...z0...9"
168 message=8 times "1234567890"
172 void nessie_hash_run(void){
176 nessie_print_header(nessie_hash_ctx.name, 0, 0, nessie_hash_ctx.hashsize_b, 0, 0);
178 char* challange[8][2]= {
179 {"", "\"\" (empty string)"},
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\""}
194 nessie_print_setheader(set);
196 nessie_print_set_vector(set, i);
197 ascii_hash(challange[i][0], challange[i][1]);
199 nessie_print_set_vector(set, i);
203 nessie_print_setheader(set);
204 for(i=0; i<1024; ++i){
205 nessie_print_set_vector(set, i);
210 nessie_print_setheader(set);
211 for(i=0; i<512; ++i){
212 nessie_print_set_vector(set, i);
217 nessie_print_setheader(set);
218 nessie_print_set_vector(set, 0);
221 nessie_print_footer();