1 /* main-bigint-test.c */
3 This file is part of the AVR-Crypto-Lib.
4 Copyright (C) 2008, 2009, 2010 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/>.
29 #include "uart_lowlevel.h"
34 #include "noekeon_prng.h"
36 #include "bigint_io.h"
38 #include "performance_test.h"
40 char* algo_name = "BigInt";
42 void uart0_putc(char byte){
43 uart_putc(UART_0, byte);
46 char uart0_getc(void){
47 return uart_getc(UART_0);
50 /*****************************************************************************
51 * additional validation-functions *
52 *****************************************************************************/
53 void test_echo_bigint(void){
55 cli_putstr("\r\necho test\r\n");
57 cli_putstr("\r\nenter hex number:");
58 if(bigint_read_hex_echo(&a)){
59 cli_putstr("\r\n end echo test");
62 cli_putstr("\r\necho: ");
69 void test_add_bigint(void){
71 cli_putstr("\r\nadd test\r\n");
73 cli_putstr("\r\nenter a:");
74 if(bigint_read_hex_echo(&a)){
75 cli_putstr("\r\n end add test");
78 cli_putstr("\r\nenter b:");
79 if(bigint_read_hex_echo(&b)){
81 cli_putstr("\r\n end add test");
90 c_b = malloc(((a.length_B>b.length_B)?a.length_B:b.length_B)*sizeof(bigint_word_t)+8);
92 cli_putstr("\n\rERROR: Out of memory!");
98 bigint_add_s(&c, &a, &b);
107 void test_add_scale_bigint(void){
110 cli_putstr("\r\nadd-scale test\r\n");
112 cli_putstr("\r\nenter a:");
113 if(bigint_read_hex_echo(&a)){
114 cli_putstr("\r\n end add test");
117 cli_putstr("\r\nenter b:");
118 if(bigint_read_hex_echo(&b)){
119 cli_putstr("\r\n end add test");
122 cli_putstr("\r\nenter scale:");
125 cli_getsn_cecho(str, 7);
129 if(bigint_read_hex_echo(&scale)){
131 cli_putstr("\r\n end add test");
136 bigint_print_hex(&a);
138 bigint_print_hex(&b);
140 cli_hexdump_rev(&scale, 2);
143 c_b = malloc(((a.length_B>(b.length_B+scale))?a.length_B:(b.length_B+scale))*sizeof(bigint_word_t)+8);
145 cli_putstr("\n\rERROR: Out of memory!");
152 bigint_add_scale_u(&c, &b, scale);
153 bigint_print_hex(&c);
161 void test_mul_bigint(void){
163 cli_putstr("\r\nmul test\r\n");
165 cli_putstr("\r\nenter a:");
166 if(bigint_read_hex_echo(&a)){
167 cli_putstr("\r\n end mul test");
170 cli_putstr("\r\nenter b:");
171 if(bigint_read_hex_echo(&b)){
173 cli_putstr("\r\n end mul test");
177 bigint_print_hex(&a);
179 bigint_print_hex(&b);
182 c_b = malloc((((a.length_B>b.length_B)?a.length_B:b.length_B)+1)*2*sizeof(bigint_word_t));
184 cli_putstr("\n\rERROR: Out of memory!");
190 bigint_mul_s(&c, &a, &b);
191 bigint_print_hex(&c);
199 void test_square_bigint(void){
201 cli_putstr("\r\nsquare test\r\n");
203 cli_putstr("\r\nenter a:");
204 if(bigint_read_hex_echo(&a)){
205 cli_putstr("\r\n end square test");
209 bigint_print_hex(&a);
210 cli_putstr("**2 = ");
212 c_b = malloc(a.length_B*2*sizeof(bigint_word_t));
214 cli_putstr("\n\rERROR: Out of memory!");
219 bigint_square(&c, &a);
220 bigint_print_hex(&c);
227 void test_reduce_bigint(void){
229 cli_putstr("\r\nreduce test\r\n");
231 cli_putstr("\r\nenter a:");
232 if(bigint_read_hex_echo(&a)){
233 cli_putstr("\r\n end reduce test");
236 cli_putstr("\r\nenter b:");
237 if(bigint_read_hex_echo(&b)){
239 cli_putstr("\r\n end reduce test");
243 bigint_print_hex(&a);
245 bigint_print_hex(&b);
247 bigint_reduce(&a, &b);
248 bigint_print_hex(&a);
255 void test_expmod_bigint(void){
258 cli_putstr("\r\nreduce test\r\n");
260 cli_putstr("\r\nenter a:");
261 if(bigint_read_hex_echo(&a)){
262 cli_putstr("\r\n end expmod test");
265 cli_putstr("\r\nenter b:");
266 if(bigint_read_hex_echo(&b)){
268 cli_putstr("\r\n end expmod test");
271 cli_putstr("\r\nenter c:");
272 if(bigint_read_hex_echo(&c)){
275 cli_putstr("\r\n end expmod test");
278 d_b = malloc(c.length_B*sizeof(bigint_word_t));
280 cli_putstr("\n\rERROR: Out of memory!");
288 bigint_print_hex(&a);
290 bigint_print_hex(&b);
292 bigint_print_hex(&c);
294 bigint_expmod_u(&d, &a, &b, &c);
295 bigint_print_hex(&d);
305 void test_gcdext_bigint(void){
306 bigint_t a, b, c, d, e;
307 cli_putstr("\r\ngcdext test\r\n");
309 cli_putstr("\r\nenter a:");
310 if(bigint_read_hex_echo(&a)){
311 cli_putstr("\r\n end gcdext test");
314 cli_putstr("\r\nenter b:");
315 if(bigint_read_hex_echo(&b)){
317 cli_putstr("\r\n end gcdext test");
320 c.wordv = malloc(((a.length_B<b.length_B)?a.length_B:b.length_B)*sizeof(bigint_word_t));
321 d.wordv = malloc((1+(a.length_B>b.length_B)?a.length_B:b.length_B)*sizeof(bigint_word_t));
322 e.wordv = malloc((1+(a.length_B>b.length_B)?a.length_B:b.length_B)*sizeof(bigint_word_t));
324 cli_putstr("\r\n gcdext( ");
325 bigint_print_hex(&a);
327 bigint_print_hex(&b);
329 bigint_gcdext(&c, &d, &e, &a, &b);
331 bigint_print_hex(&d);
332 cli_putstr("; b = ");
333 bigint_print_hex(&e);
334 cli_putstr("; gcd = ");
335 bigint_print_hex(&c);
346 void test_simple(void){
348 bigint_word_t a_b[1], b_b[1], c_b[2];
356 bigint_add_u(&c, &a, &b);
357 cli_putstr("\r\n 1+2=");
358 bigint_print_hex(&c);
361 void test_mul_simple(void){
363 uint8_t a_b[5] = {0x79, 0x36, 0x9e, 0x72, 0xec};
364 uint8_t b_b[5] = {0x4a, 0x47, 0x0d, 0xec, 0xfd};
373 bigint_mul_s(&c, &a, &b);
374 cli_putstr("\r\n test: ");
375 bigint_print_hex(&c);
379 // -3d1d 6db7 8251 f371 * -7a18 3791 d18b b7c5 = 1d25ce4fdf93390f8d6c709f4d711cf5
380 // -20538248dece6d29068d * 400b1411b874f81394c6 = -81646b193d95136a6fedb73cee6d30c39fb950e
381 // -BC8B 7D53 4921 853D * 0DDA 6044 00CE DDE6 = -a33eb0c5847db8837589c22db395dce
382 void test_mul_simple(void){
385 // uint8_t a_b[10] = {0x8d, 0x06, 0x29, 0x6d, 0xce, 0xde, 0x48, 0x82, 0x53, 0x20};
386 // uint8_t b_b[10] = {0xc6, 0x94, 0x13, 0xf8, 0x74, 0xb8, 0x11, 0x14, 0x0b, 0x40};
387 uint8_t a_b[8] = {0x3d, 0x85, 0x21, 0x49, 0x53, 0x7d, 0x8b, 0xbc};
388 uint8_t b_b[8] = {0xe6, 0xdd, 0xce, 0x00, 0x44, 0x60, 0xda, 0x0d};
391 a.wordv=(bigint_word_t*)a_b;
392 b.wordv=(bigint_word_t*)b_b;
393 c.wordv=(bigint_word_t*)c_b;
394 a.length_B = 8/sizeof(bigint_word_t);
395 b.length_B = 8/sizeof(bigint_word_t);
399 bigint_mul_s(&c, &a, &b);
400 cli_putstr("\r\n test: ");
401 bigint_print_hex(&a);
403 bigint_print_hex(&b);
405 bigint_print_hex(&c);
408 // f4 b86a 2220 0774 437d 70e6 **2 = e9f00f29ca1c876a7a682bd1e04f6925caffd6660ea4
410 uint8_t square_test_data[] PROGMEM = {
411 0xA0, 0x3C, 0x23, 0x9F, 0x7A, 0xFC, 0x60, 0xEB, 0x96, 0xC2, 0xA8, 0xAC, 0xC3, 0xC9, 0x9E, 0xEC,
412 0x4A, 0xF0, 0x1C, 0xB2, 0x36, 0x68, 0xD6, 0x4D, 0x3E, 0x4F, 0x8E, 0x55, 0xEA, 0x52, 0x46, 0x68,
413 0x6E, 0x18, 0x88, 0x37, 0x03, 0x70, 0xBD, 0x01, 0x60, 0xE2, 0xD6, 0x12, 0xA0, 0x0E, 0xD2, 0x72,
414 0x0D, 0x9D, 0x9F, 0x03, 0xC5, 0x81, 0xCA, 0x6E, 0x88, 0x1E, 0xF5, 0xD8, 0x14, 0x15, 0x30, 0xEB,
415 0x28, 0x7C, 0x80, 0x07, 0x34, 0x05, 0x5D, 0xAA, 0xDC, 0xA8, 0xAA, 0x88, 0xC5, 0xE5, 0xC9, 0xFE,
416 0x9C, 0xA1, 0xCE, 0xC2, 0x09, 0x0D, 0xC4, 0xC8, 0xD3, 0xE7, 0x3A, 0xF3, 0xEF, 0xDF, 0xAE, 0x07,
417 0xEC, 0xC7, 0x83, 0x50, 0x9F, 0x6D, 0xB9, 0x28, 0x77, 0xC0, 0xFE, 0x69, 0xB2, 0x2E, 0x55, 0x90,
418 0x50, 0xED, 0xE0, 0xA1, 0x4D, 0x3D, 0x38, 0xC9, 0x0E, 0xCD, 0x04, 0x3B, 0x64, 0x3F, 0x56, 0xC5,
419 0xC3, 0x9E, 0x89, 0x81, 0x44, 0x60, 0xBA, 0x8E, 0x88, 0xA4, 0xA3, 0x42, 0x7B, 0x06, 0x93, 0x1C,
420 0x6B, 0x04, 0x29, 0xF9, 0xDD, 0xFF, 0xB0, 0x48, 0x2F, 0x6D, 0xD1, 0x0F, 0x7D, 0xA6, 0x26, 0xD8,
421 0xEF, 0x5E, 0x04, 0x18, 0xD1, 0x61, 0x46, 0x37, 0x87, 0xE2, 0x97, 0xDF, 0x10, 0xB4, 0x9A, 0x39,
422 0xB1, 0xD0, 0xCA, 0x91, 0x48, 0x1E, 0x5D, 0xA1, 0x38, 0x89, 0x02, 0xC1, 0x49, 0x86, 0xB7, 0xAE,
423 0x69, 0x20, 0xFA, 0x0E, 0x39, 0xDA, 0xA5, 0xEF, 0x7F, 0xB2, 0x81, 0xB8, 0xC0, 0x3A, 0xF8, 0xDB,
424 0xBC, 0x45, 0xF6, 0xDA, 0xCD, 0xBE, 0x27, 0xBE, 0xF6, 0x20, 0x79, 0xF3, 0xC3, 0xC8, 0xFF, 0x85,
425 0x43, 0x9F, 0xB1, 0x9B, 0x72, 0x88, 0xDD, 0xA4, 0x0D, 0xFC, 0xC6, 0xB5, 0x74, 0x67, 0x29, 0xF5
429 void test_square_simple(void){
432 uint8_t a_b[12] = {0xe6, 0x70, 0x7d, 0x43, 0x74, 0x07, 0x20, 0x22, 0x6a, 0xb8, 0xf4, 0x00};
434 a.wordv=(bigint_word_t*)a_b;
435 c.wordv=(bigint_word_t*)c_b;
436 a.length_B = 12/sizeof(bigint_word_t);
439 bigint_square(&c, &a);
440 cli_putstr("\r\n test: ");
441 bigint_print_hex(&a);
442 cli_putstr("**2 = ");
443 bigint_print_hex(&c);
446 // [fail (c)]: A862 % 2752 = 0D1A ; should a862 % 2752 = b1a
447 void test_reduce_simple(void){
450 uint8_t a_b[4] = {0x62, 0xA8, 0x00, 0x00};
451 uint8_t b_b[4] = {0x52, 0x27, 0x00, 0x00};
453 a.wordv=(bigint_word_t*)a_b;
457 b.wordv=(bigint_word_t*)b_b;
461 c.wordv = (bigint_word_t*)c_b;
463 bigint_reduce(&c, &b);
464 cli_putstr("\r\n test: ");
465 bigint_print_hex(&a);
467 bigint_print_hex(&b);
469 bigint_print_hex(&c);
472 /* gcdext( B5DDAD, 6CBBC2) */
473 /* gcdext( CD319349, 9EFD76CC) */
474 /* gcdext( 1609000771, 6FAC577D72) */
476 void test_gcdext_simple(void){
477 bigint_t a, b, c, d, e;
479 uint8_t a_b[8] = {0x71, 0x07, 0x00, 0x09, 0x16, 0x00, 0x00, 0x00};
480 uint8_t b_b[8] = {0x72, 0x7D, 0x57, 0xAC, 0X6F, 0x00, 0x00, 0x00};
481 uint8_t c_b[16], d_b[16], e_b[16];
482 a.wordv=(bigint_word_t*)a_b;
486 b.wordv=(bigint_word_t*)b_b;
490 c.wordv = (bigint_word_t*)c_b;
491 d.wordv = (bigint_word_t*)d_b;
492 e.wordv = (bigint_word_t*)e_b;
493 bigint_gcdext(&c, &d, &e, &a, &b);
494 cli_putstr("\r\n test: gcd( ");
495 bigint_print_hex(&a);
497 bigint_print_hex(&b);
498 cli_putstr(") => a = ");
499 bigint_print_hex(&d);
500 cli_putstr("; b = ");
501 bigint_print_hex(&e);
502 cli_putstr("; gcd = ");
503 bigint_print_hex(&c);
506 void testrun_performance_bigint(void){
509 /*****************************************************************************
511 *****************************************************************************/
513 const char echo_test_str[] = "echo-test";
514 const char add_test_str[] = "add-test";
515 const char add_scale_test_str[] = "add-scale-test";
516 const char mul_test_str[] = "mul-test";
517 const char square_test_str[] = "square-test";
518 const char reduce_test_str[] = "reduce-test";
519 const char expmod_test_str[] = "expmod-test";
520 const char gcdext_test_str[] = "gcdext-test";
521 const char quick_test_str[] = "quick-test";
522 const char performance_str[] = "performance";
523 const char echo_str[] = "echo";
525 const cmdlist_entry_t cmdlist[] = {
526 { add_test_str, NULL, test_add_bigint },
527 { add_scale_test_str, NULL, test_add_scale_bigint },
528 { mul_test_str, NULL, test_mul_bigint },
529 { square_test_str, NULL, test_square_bigint },
530 { reduce_test_str, NULL, test_reduce_bigint },
531 { expmod_test_str, NULL, test_expmod_bigint },
532 { gcdext_test_str, NULL, test_gcdext_bigint },
533 { quick_test_str, NULL, test_gcdext_simple },
534 { echo_test_str, NULL, test_echo_bigint },
535 { performance_str, NULL, testrun_performance_bigint },
536 { echo_str, (void*)1, (void_fpt)echo_ctrl },
541 sysclk_set_freq(SYS_FREQ);
542 sysclk_mosc_verify_enable();
543 uart_init(UART_0, 115200, 8, UART_PARATY_NONE, UART_STOPBITS_ONE);
544 gptm_set_timer_32periodic(TIMER0);
550 cli_putstr("\r\n\r\nARM-Crypto-Lib VS (");
551 cli_putstr(algo_name);
553 cli_putstr(__DATE__);
555 cli_putstr(__TIME__);
556 cli_putstr(")\r\nloaded and running\r\n");
557 cmd_interface(cmdlist);