4 * email: daniel.otte@rub.de
7 * a suit for running the nessie-tests for MACs
12 #include "nessie_mac_test.h"
13 #include "nessie_common.h"
16 nessie_mac_ctx_t nessie_mac_ctx;
18 #define KEYSIZE_B ((nessie_mac_ctx.keysize_b+7)/8)
19 #define MACSIZE_B ((nessie_mac_ctx.macsize_b+7)/8)
21 #define PRINTKEY nessie_print_item("key", key, KEYSIZE_B)
22 #define PRINTMAC nessie_print_item("MAC", mac, MACSIZE_B)
25 void ascii_mac(char* data, char* desc, uint8_t* key){
26 uint8_t ctx[nessie_mac_ctx.ctx_size_B];
27 uint8_t mac[MACSIZE_B];
30 uart_putstr_P(PSTR("\r\n message="));
33 nessie_mac_ctx.mac_init(key, nessie_mac_ctx.keysize_b, ctx);
35 while(sl>=nessie_mac_ctx.blocksize_B){
36 nessie_mac_ctx.mac_next(data, ctx);
37 data += nessie_mac_ctx.blocksize_B;
38 sl -= nessie_mac_ctx.blocksize_B;
40 nessie_mac_ctx.mac_last(data, sl*8, key, nessie_mac_ctx.keysize_b, ctx);
41 nessie_mac_ctx.mac_conv(mac, ctx);
45 // message=1 million times "a"
48 void amillion_mac(uint8_t* key){
49 uint8_t ctx[nessie_mac_ctx.ctx_size_B];
50 uint8_t mac[MACSIZE_B];
51 uint8_t block[nessie_mac_ctx.blocksize_B];
54 uart_putstr_P(PSTR("\r\n message="));
55 uart_putstr_P(PSTR("1 million times \"a\""));
58 memset(block, 'a', nessie_mac_ctx.blocksize_B);
59 nessie_mac_ctx.mac_init(key, nessie_mac_ctx.keysize_b, ctx);
60 while(n>=nessie_mac_ctx.blocksize_B){
61 nessie_mac_ctx.mac_next(block, ctx);
62 n -= nessie_mac_ctx.blocksize_B;
64 nessie_mac_ctx.mac_last(block, n*8, key, nessie_mac_ctx.keysize_b, ctx);
65 nessie_mac_ctx.mac_conv(mac, ctx);
71 void zero_mac(uint16_t n, uint8_t* key){
72 uint8_t ctx[nessie_mac_ctx.ctx_size_B];
73 uint8_t mac[MACSIZE_B];
74 uint8_t block[nessie_mac_ctx.blocksize_B];
76 uart_putstr_P(PSTR("\r\n message="));
78 uart_putc('0'+n/10000);
80 uart_putc('0'+(n/1000)%10);
82 uart_putc('0'+(n/100)%10);
84 uart_putc('0'+(n/10)%10);
86 uart_putstr_P(PSTR(" zero bits"));
89 memset(block, 0, nessie_mac_ctx.blocksize_B);
90 nessie_mac_ctx.mac_init(key, nessie_mac_ctx.keysize_b,ctx);;
91 while(n>=nessie_mac_ctx.blocksize_B*8){
92 nessie_mac_ctx.mac_next(block, ctx);
93 n -= nessie_mac_ctx.blocksize_B*8;
95 nessie_mac_ctx.mac_last(block, n, key, nessie_mac_ctx.keysize_b, ctx);
96 nessie_mac_ctx.mac_conv(mac, ctx);
101 void one_in512_mac(uint16_t pos, uint8_t* key){
102 uint8_t ctx[nessie_mac_ctx.ctx_size_B];
103 uint8_t mac[MACSIZE_B];
104 uint8_t block[nessie_mac_ctx.blocksize_B];
106 char* tab[8]={"80", "40", "20", "10",
107 "08", "04", "02", "01" };
110 uart_putstr_P(PSTR("\r\n message="));
111 uart_putstr_P(PSTR("512-bit string: "));
113 uart_putc('0'+(pos/8/10)%10);
117 uart_putc('0'+(pos/8)%10);
118 uart_putstr_P(PSTR("*00,"));
119 uart_putstr(tab[pos&7]);
122 uart_putc('0'+((63-pos/8)/10)%10);
126 uart_putc('0'+(63-pos/8)%10);
127 uart_putstr_P(PSTR("*00"));
130 /* now the real stuff */
131 memset(block, 0, 512/8);
132 block[pos>>3] = 0x80>>(pos&0x7);
133 nessie_mac_ctx.mac_init(key, nessie_mac_ctx.keysize_b, ctx);;
134 while(n>=nessie_mac_ctx.blocksize_B*8){
135 nessie_mac_ctx.mac_next(block, ctx);
136 n -= nessie_mac_ctx.blocksize_B*8;
138 nessie_mac_ctx.mac_last(block, n, key, nessie_mac_ctx.keysize_b, ctx);
139 nessie_mac_ctx.mac_conv(mac, ctx);
144 void tv4_mac(uint8_t* key){
145 uint8_t ctx[nessie_mac_ctx.ctx_size_B];
146 uint8_t mac[MACSIZE_B];
147 uint8_t block[256/8];
151 uart_putstr_P(PSTR("\r\n message="));
152 uart_putstr(PSTR("256 zero bits"));
153 memset(block, 0, 256/8);
155 nessie_mac_ctx.mac_init(key, nessie_mac_ctx.keysize_b, ctx);;
156 while(n>=nessie_mac_ctx.blocksize_B*8){
157 nessie_mac_ctx.mac_next(block, ctx);
158 n -= nessie_mac_ctx.blocksize_B*8;
160 nessie_mac_ctx.mac_last(block, n, key, nessie_mac_ctx.keysize_b, ctx);
161 nessie_mac_ctx.mac_conv(mac, ctx);
163 for(i=1; i<100000L; ++i){ /* this assumes BLOCKSIZE >= HASHSIZE */
164 nessie_mac_ctx.mac_init(key, nessie_mac_ctx.keysize_b, ctx);;
165 nessie_mac_ctx.mac_last(mac, nessie_mac_ctx.macsize_b, key, nessie_mac_ctx.keysize_b, ctx);
166 nessie_mac_ctx.mac_conv(mac, ctx);
168 nessie_print_item("iterated 100000 times", mac, MACSIZE_B);
172 void nessie_mac_run(void){
175 uint8_t keyproto[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
176 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
177 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
178 uint8_t key[KEYSIZE_B];
180 nessie_print_header(nessie_mac_ctx.name, nessie_mac_ctx.keysize_b, 0, 0,
181 nessie_mac_ctx.macsize_b, 0);
183 char* challange[10][2]= {
184 {"", "\"\" (empty string)"},
187 {"message digest", "\"message digest\""},
188 {"abcdefghijklmnopqrstuvwxyz","\"abcdefghijklmnopqrstuvwxyz\""},
189 {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
190 "\"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq\""},
191 {"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
192 "abcdefghijklmnopqrstuvwxyz"
193 "0123456789" , "\"A...Za...z0...9\""},
194 {"1234567890" "1234567890" "1234567890" "1234567890"
195 "1234567890" "1234567890" "1234567890" "1234567890",
196 "8 times \"1234567890\""},
197 {"Now is the time for all ", "\"Now is the time for all \""},
198 {"Now is the time for it", "\"Now is the time for it\""}
201 nessie_print_setheader(set);
202 for(i=0; i<KEYSIZE_B; ++i){
203 key[i] = keyproto[i%sizeof(keyproto)];
206 nessie_print_set_vector(set, i);
207 ascii_mac(challange[i][0], challange[i][1], key);
209 nessie_print_set_vector(set, i);
211 for(i=0; i<KEYSIZE_B; ++i){
212 key[i] = keyproto[16+i%8];
215 nessie_print_set_vector(set, 11+i);
216 ascii_mac(challange[i][0], challange[i][1], key);
218 nessie_print_set_vector(set, 11+i);
222 for(i=0; i<KEYSIZE_B; ++i){
223 key[i] = keyproto[i%sizeof(keyproto)];
225 nessie_print_setheader(set);
226 for(i=0; i<1024; ++i){
227 nessie_print_set_vector(set, i);
232 nessie_print_setheader(set);
233 /* we use the same key as above */
234 for(i=0; i<512; ++i){
235 nessie_print_set_vector(set, i);
236 one_in512_mac(i, key);
240 nessie_print_setheader(set);
241 /* we use the same key as above */
242 nessie_print_set_vector(set, 0);
245 for(i=0; i<nessie_mac_ctx.keysize_b; ++i){
246 nessie_print_set_vector(set, i);
247 memset(key, 0, KEYSIZE_B);
248 key[i>>3]=0x80>>(i&0x7);
249 ascii_mac("ABC", "\"ABC\"", key);
251 nessie_print_footer();