1 /* main-shabal-test.c */
3 This file is part of the AVR-Crypto-Lib.
4 Copyright (C) 2008 Daniel Otte (daniel.otte@rub.de)
6 This program is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 #include "serial-tools.h"
29 #include "bmw_small.h"
30 #include "bmw_large.h"
32 #include "hfal_bmw_small.h"
33 #include "hfal_bmw_large.h"
35 #include "nessie_hash_test.h"
36 #include "performance_test.h"
42 char* algo_name = "BlueMidnightWish";
44 /*****************************************************************************
45 * additional validation-functions *
46 *****************************************************************************/
48 void performance_bmw(void){
64 cli_putstr_P(PSTR("\r\n\tctx-gen time (224): "));
65 ultoa((unsigned long)t, str, 10);
71 cli_putstr_P(PSTR("\r\n\tctx-gen time (256): "));
72 ultoa((unsigned long)t, str, 10);
78 cli_putstr_P(PSTR("\r\n\tctx-gen time (384): "));
79 ultoa((unsigned long)t, str, 10);
85 cli_putstr_P(PSTR("\r\n\tctx-gen time (512): "));
86 ultoa((unsigned long)t, str, 10);
90 bmw_small_nextBlock(&ctx1, data);
92 cli_putstr_P(PSTR("\r\n\tone-block (small) time: "));
93 ultoa((unsigned long)t, str, 10);
97 bmw_large_nextBlock(&ctx2, data);
99 cli_putstr_P(PSTR("\r\n\tone-block (large) time: "));
100 ultoa((unsigned long)t, str, 10);
104 bmw_small_lastBlock(&ctx1, data, 0);
106 cli_putstr_P(PSTR("\r\n\tlast block (small) time: "));
107 ultoa((unsigned long)t, str, 10);
111 bmw_large_lastBlock(&ctx2, data, 0);
113 cli_putstr_P(PSTR("\r\n\tlast block (large) time: "));
114 ultoa((unsigned long)t, str, 10);
118 bmw224_ctx2hash(hash, &ctx1);
120 cli_putstr_P(PSTR("\r\n\tctx2hash time (224): "));
121 ultoa((unsigned long)t, str, 10);
125 bmw256_ctx2hash(hash, &ctx1);
127 cli_putstr_P(PSTR("\r\n\tctx2hash time (256): "));
128 ultoa((unsigned long)t, str, 10);
132 bmw384_ctx2hash(hash, &ctx2);
134 cli_putstr_P(PSTR("\r\n\tctx2hash time (384): "));
135 ultoa((unsigned long)t, str, 10);
139 bmw512_ctx2hash(hash, &ctx2);
141 cli_putstr_P(PSTR("\r\n\tctx2hash time (512): "));
142 ultoa((unsigned long)t, str, 10);
145 cli_putstr_P(PSTR("\r\n"));
148 void testrun_nessie_bmw(void){
149 nessie_hash_ctx.hashsize_b = 224;
150 nessie_hash_ctx.name = "BlueMidnigthWish-224";
151 nessie_hash_ctx.blocksize_B = 512/8;
152 nessie_hash_ctx.ctx_size_B = sizeof(bmw224_ctx_t);
153 nessie_hash_ctx.hash_init = (nessie_hash_init_fpt)bmw224_init;
154 nessie_hash_ctx.hash_next = (nessie_hash_next_fpt)bmw224_nextBlock;
155 nessie_hash_ctx.hash_last = (nessie_hash_last_fpt)bmw224_lastBlock;
156 nessie_hash_ctx.hash_conv = (nessie_hash_conv_fpt)bmw224_ctx2hash;
160 nessie_hash_ctx.hashsize_b = 256;
161 nessie_hash_ctx.name = "BlueMidnigthWish-256";
162 nessie_hash_ctx.blocksize_B = 512/8;
163 nessie_hash_ctx.ctx_size_B = sizeof(bmw256_ctx_t);
164 nessie_hash_ctx.hash_init = (nessie_hash_init_fpt)bmw256_init;
165 nessie_hash_ctx.hash_next = (nessie_hash_next_fpt)bmw256_nextBlock;
166 nessie_hash_ctx.hash_last = (nessie_hash_last_fpt)bmw256_lastBlock;
167 nessie_hash_ctx.hash_conv = (nessie_hash_conv_fpt)bmw256_ctx2hash;
171 nessie_hash_ctx.hashsize_b = 384;
172 nessie_hash_ctx.name = "BlueMidnigthWish-384";
173 nessie_hash_ctx.blocksize_B = 1024/8;
174 nessie_hash_ctx.ctx_size_B = sizeof(bmw384_ctx_t);
175 nessie_hash_ctx.hash_init = (nessie_hash_init_fpt)bmw384_init;
176 nessie_hash_ctx.hash_next = (nessie_hash_next_fpt)bmw384_nextBlock;
177 nessie_hash_ctx.hash_last = (nessie_hash_last_fpt)bmw384_lastBlock;
178 nessie_hash_ctx.hash_conv = (nessie_hash_conv_fpt)bmw384_ctx2hash;
182 nessie_hash_ctx.hashsize_b = 512;
183 nessie_hash_ctx.name = "BlueMidnigthWish-512";
184 nessie_hash_ctx.blocksize_B = 1024/8;
185 nessie_hash_ctx.ctx_size_B = sizeof(bmw512_ctx_t);
186 nessie_hash_ctx.hash_init = (nessie_hash_init_fpt)bmw512_init;
187 nessie_hash_ctx.hash_next = (nessie_hash_next_fpt)bmw512_nextBlock;
188 nessie_hash_ctx.hash_last = (nessie_hash_last_fpt)bmw512_lastBlock;
189 nessie_hash_ctx.hash_conv = (nessie_hash_conv_fpt)bmw512_ctx2hash;
193 void bmw224_test(void* msg, uint32_t length_b){
194 uint8_t diggest[224/8];
195 cli_putstr_P(PSTR("\r\n=== BMW224 test ===\r\n message:\r\n"));
196 cli_hexdump_block(msg, (length_b+7)/8, 4, 16);
197 bmw224(diggest, msg, length_b);
198 cli_putstr_P(PSTR("\r\n diggest:\r\n"));
199 cli_hexdump_block(diggest, 224/8, 4, 16);
202 void bmw256_test(void* msg, uint32_t length_b){
203 uint8_t diggest[256/8];
204 cli_putstr_P(PSTR("\r\n=== BMW256 test ===\r\n message:\r\n"));
205 cli_hexdump_block(msg, (length_b+7)/8, 4, 16);
206 bmw256(diggest, msg, length_b);
207 cli_putstr_P(PSTR("\r\n diggest:\r\n"));
208 cli_hexdump_block(diggest, 256/8, 4, 16);
211 void bmw384_test(void* msg, uint32_t length_b){
212 uint8_t diggest[384/8];
213 cli_putstr_P(PSTR("\r\n=== BMW384 test ===\r\n message:\r\n"));
214 cli_hexdump_block(msg, (length_b+7)/8, 4, 16);
215 bmw384(diggest, msg, length_b);
216 cli_putstr_P(PSTR("\r\n diggest:\r\n"));
217 cli_hexdump_block(diggest, 384/8, 4, 16);
220 void bmw512_test(void* msg, uint32_t length_b){
221 uint8_t diggest[512/8];
222 cli_putstr_P(PSTR("\r\n=== BMW512 test ===\r\n message:\r\n"));
223 cli_hexdump_block(msg, (length_b+7)/8, 4, 16);
224 bmw512(diggest, msg, length_b);
225 cli_putstr_P(PSTR("\r\n diggest:\r\n"));
226 cli_hexdump_block(diggest, 512/8, 4, 16);
229 void testrun_stdtest_bmw(void){
231 char* msg1 = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
232 bmw224_test(msg0, strlen(msg0)*8);
233 bmw224_test(msg1, strlen(msg1)*8);
234 bmw256_test(msg0, strlen(msg0)*8);
235 bmw256_test(msg1, strlen(msg1)*8);
236 bmw384_test(msg0, strlen(msg0)*8);
237 bmw384_test(msg1, strlen(msg1)*8);
238 bmw512_test(msg0, strlen(msg0)*8);
239 bmw512_test(msg1, strlen(msg1)*8);
242 void testshort(void){
244 bmw224_test(msg0, strlen(msg0)*8);
247 void testlshort(void){
249 bmw384_test(msg0, strlen(msg0)*8);
252 /*****************************************************************************
254 *****************************************************************************/
256 const hfdesc_t* algolist[] PROGMEM = {
257 (hfdesc_t*)&bmw224_desc,
258 (hfdesc_t*)&bmw256_desc,
259 (hfdesc_t*)&bmw384_desc,
260 (hfdesc_t*)&bmw512_desc,
264 const char nessie_str[] PROGMEM = "nessie";
265 const char test_str[] PROGMEM = "test";
266 const char testshort_str[] PROGMEM = "short";
267 const char testlshort_str[] PROGMEM = "lshort";
268 const char performance_str[] PROGMEM = "performance";
269 const char echo_str[] PROGMEM = "echo";
270 const char shavs_list_str[] PROGMEM = "shavs_list";
271 const char shavs_set_str[] PROGMEM = "shavs_set";
272 const char shavs_test1_str[] PROGMEM = "shavs_test1";
274 cmdlist_entry_t cmdlist[] PROGMEM = {
275 { nessie_str, NULL, testrun_nessie_bmw},
276 { test_str, NULL, testrun_stdtest_bmw},
277 { testshort_str, NULL, testshort},
278 { testlshort_str, NULL, testlshort},
279 { performance_str, NULL, performance_bmw},
280 { shavs_list_str, NULL, shavs_listalgos},
281 { shavs_set_str, (void*)1, (void_fpt)shavs_setalgo},
282 { shavs_test1_str, NULL, shavs_test1},
283 { echo_str, (void*)1, (void_fpt)echo_ctrl},
292 shavs_algolist=(hfdesc_t**)algolist;
293 shavs_algo=(hfdesc_t*)&bmw256_desc;
295 cli_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
296 cli_putstr(algo_name);
297 cli_putstr_P(PSTR("; "));
298 cli_putstr(__DATE__);
299 cli_putstr_P(PSTR(" "));
300 cli_putstr(__TIME__);
301 cli_putstr_P(PSTR(")\r\nloaded and running\r\n"));
303 cmd_interface(cmdlist);