1 /* main-bigint-test.c */
3 This file is part of the ARM-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/>.
23 #include "main-test-common.h"
26 #include "noekeon_prng.h"
28 #include "bigint_io.h"
30 #include "performance_test.h"
32 char* algo_name = "BigInt";
34 /*****************************************************************************
35 * additional validation-functions *
36 *****************************************************************************/
37 void test_echo_bigint(void){
39 cli_putstr("\r\necho test\r\n");
41 cli_putstr("\r\nenter hex number:");
42 if(bigint_read_hex_echo(&a)){
43 cli_putstr("\r\n end echo test");
46 cli_putstr("\r\necho: ");
53 void test_add_bigint(void){
55 cli_putstr("\r\nadd test\r\n");
57 cli_putstr("\r\nenter a:");
58 if(bigint_read_hex_echo(&a)){
59 cli_putstr("\r\n end add test");
62 cli_putstr("\r\nenter b:");
63 if(bigint_read_hex_echo(&b)){
65 cli_putstr("\r\n end add test");
74 c_b = malloc(((a.length_W>b.length_W)?a.length_W:b.length_W)*sizeof(bigint_word_t)+8);
76 cli_putstr("\n\rERROR: Out of memory!");
82 bigint_add_s(&c, &a, &b);
91 void test_add_scale_bigint(void){
94 cli_putstr("\r\nadd-scale test\r\n");
96 cli_putstr("\r\nenter a:");
97 if(bigint_read_hex_echo(&a)){
98 cli_putstr("\r\n end add test");
101 cli_putstr("\r\nenter b:");
102 if(bigint_read_hex_echo(&b)){
103 cli_putstr("\r\n end add test");
106 cli_putstr("\r\nenter scale:");
113 if(bigint_read_hex_echo(&scale)){
115 cli_putstr("\r\n end add test");
120 bigint_print_hex(&a);
122 bigint_print_hex(&b);
124 cli_hexdump_rev(&scale, 2);
127 c_b = malloc((((a.length_W>(b.length_W+scale))?a.length_W:(b.length_W+scale))+1)*sizeof(bigint_word_t));
129 cli_putstr("\n\rERROR: Out of memory!");
136 bigint_add_scale_u(&c, &b, scale);
137 bigint_print_hex(&c);
145 void test_mul_bigint(void){
147 cli_putstr("\r\nmul test\r\n");
149 cli_putstr("\r\nenter a:");
150 if(bigint_read_hex_echo(&a)){
151 cli_putstr("\r\n end mul test");
154 cli_putstr("\r\nenter b:");
155 if(bigint_read_hex_echo(&b)){
157 cli_putstr("\r\n end mul test");
161 bigint_print_hex(&a);
163 bigint_print_hex(&b);
166 c_b = malloc((((a.length_W>b.length_W)?a.length_W:b.length_W)+1)*2*sizeof(bigint_word_t));
168 cli_putstr("\n\rERROR: Out of memory!");
174 bigint_mul_s(&c, &a, &b);
175 bigint_print_hex(&c);
183 void test_square_bigint(void){
185 cli_putstr("\r\nsquare test\r\n");
187 cli_putstr("\r\nenter a:");
188 if(bigint_read_hex_echo(&a)){
189 cli_putstr("\r\n end square test");
193 bigint_print_hex(&a);
194 cli_putstr("**2 = ");
196 c_b = malloc(a.length_W*2*sizeof(bigint_word_t));
198 cli_putstr("\n\rERROR: Out of memory!");
203 bigint_square(&c, &a);
204 bigint_print_hex(&c);
211 void test_reduce_bigint(void){
213 cli_putstr("\r\nreduce test\r\n");
215 cli_putstr("\r\nenter a:");
216 if(bigint_read_hex_echo(&a)){
217 cli_putstr("\r\n end reduce test");
220 cli_putstr("\r\nenter b:");
221 if(bigint_read_hex_echo(&b)){
223 cli_putstr("\r\n end reduce test");
227 bigint_print_hex(&a);
229 bigint_print_hex(&b);
231 bigint_reduce(&a, &b);
232 bigint_print_hex(&a);
239 void test_expmod_bigint(void){
242 cli_putstr("\r\nreduce test\r\n");
244 cli_putstr("\r\nenter a:");
245 if(bigint_read_hex_echo(&a)){
246 cli_putstr("\r\n end expmod test");
249 cli_putstr("\r\nenter b:");
250 if(bigint_read_hex_echo(&b)){
252 cli_putstr("\r\n end expmod test");
255 cli_putstr("\r\nenter c:");
256 if(bigint_read_hex_echo(&c)){
259 cli_putstr("\r\n end expmod test");
262 d_b = malloc(c.length_W*sizeof(bigint_word_t));
264 cli_putstr("\n\rERROR: Out of memory!");
272 bigint_print_hex(&a);
274 bigint_print_hex(&b);
276 bigint_print_hex(&c);
278 bigint_expmod_u(&d, &a, &b, &c);
279 bigint_print_hex(&d);
289 void test_gcdext_bigint(void){
290 bigint_t a, b, c, d, e;
291 cli_putstr("\r\ngcdext test\r\n");
293 cli_putstr("\r\nenter a:");
294 if(bigint_read_hex_echo(&a)){
295 cli_putstr("\r\n end gcdext test");
298 cli_putstr("\r\nenter b:");
299 if(bigint_read_hex_echo(&b)){
301 cli_putstr("\r\n end gcdext test");
304 c.wordv = malloc(((a.length_W<b.length_W)?a.length_W:b.length_W)*sizeof(bigint_word_t));
305 d.wordv = malloc((1+(a.length_W>b.length_W)?a.length_W:b.length_W)*sizeof(bigint_word_t));
306 e.wordv = malloc((1+(a.length_W>b.length_W)?a.length_W:b.length_W)*sizeof(bigint_word_t));
308 cli_putstr("\r\n gcdext( ");
309 bigint_print_hex(&a);
311 bigint_print_hex(&b);
313 bigint_gcdext(&c, &d, &e, &a, &b);
315 bigint_print_hex(&d);
316 cli_putstr("; b = ");
317 bigint_print_hex(&e);
318 cli_putstr("; gcd = ");
319 bigint_print_hex(&c);
330 void test_simple(void){
332 bigint_word_t a_b[1], b_b[1], c_b[2];
340 bigint_add_u(&c, &a, &b);
341 cli_putstr("\r\n 1+2=");
342 bigint_print_hex(&c);
345 void test_mul_simple(void){
347 uint8_t a_b[5] = {0x79, 0x36, 0x9e, 0x72, 0xec};
348 uint8_t b_b[5] = {0x4a, 0x47, 0x0d, 0xec, 0xfd};
357 bigint_mul_s(&c, &a, &b);
358 cli_putstr("\r\n test: ");
359 bigint_print_hex(&c);
363 // -3d1d 6db7 8251 f371 * -7a18 3791 d18b b7c5 = 1d25ce4fdf93390f8d6c709f4d711cf5
364 // -20538248dece6d29068d * 400b1411b874f81394c6 = -81646b193d95136a6fedb73cee6d30c39fb950e
365 // -BC8B 7D53 4921 853D * 0DDA 6044 00CE DDE6 = -a33eb0c5847db8837589c22db395dce
366 void test_mul_simple(void){
369 // uint8_t a_b[10] = {0x8d, 0x06, 0x29, 0x6d, 0xce, 0xde, 0x48, 0x82, 0x53, 0x20};
370 // uint8_t b_b[10] = {0xc6, 0x94, 0x13, 0xf8, 0x74, 0xb8, 0x11, 0x14, 0x0b, 0x40};
371 uint8_t a_b[8] = {0x3d, 0x85, 0x21, 0x49, 0x53, 0x7d, 0x8b, 0xbc};
372 uint8_t b_b[8] = {0xe6, 0xdd, 0xce, 0x00, 0x44, 0x60, 0xda, 0x0d};
375 a.wordv=(bigint_word_t*)a_b;
376 b.wordv=(bigint_word_t*)b_b;
377 c.wordv=(bigint_word_t*)c_b;
378 a.length_W = 8/sizeof(bigint_word_t);
379 b.length_W = 8/sizeof(bigint_word_t);
383 bigint_mul_s(&c, &a, &b);
384 cli_putstr("\r\n test: ");
385 bigint_print_hex(&a);
387 bigint_print_hex(&b);
389 bigint_print_hex(&c);
392 // f4 b86a 2220 0774 437d 70e6 **2 = e9f00f29ca1c876a7a682bd1e04f6925caffd6660ea4
394 uint8_t square_test_data[] PROGMEM = {
395 0xA0, 0x3C, 0x23, 0x9F, 0x7A, 0xFC, 0x60, 0xEB, 0x96, 0xC2, 0xA8, 0xAC, 0xC3, 0xC9, 0x9E, 0xEC,
396 0x4A, 0xF0, 0x1C, 0xB2, 0x36, 0x68, 0xD6, 0x4D, 0x3E, 0x4F, 0x8E, 0x55, 0xEA, 0x52, 0x46, 0x68,
397 0x6E, 0x18, 0x88, 0x37, 0x03, 0x70, 0xBD, 0x01, 0x60, 0xE2, 0xD6, 0x12, 0xA0, 0x0E, 0xD2, 0x72,
398 0x0D, 0x9D, 0x9F, 0x03, 0xC5, 0x81, 0xCA, 0x6E, 0x88, 0x1E, 0xF5, 0xD8, 0x14, 0x15, 0x30, 0xEB,
399 0x28, 0x7C, 0x80, 0x07, 0x34, 0x05, 0x5D, 0xAA, 0xDC, 0xA8, 0xAA, 0x88, 0xC5, 0xE5, 0xC9, 0xFE,
400 0x9C, 0xA1, 0xCE, 0xC2, 0x09, 0x0D, 0xC4, 0xC8, 0xD3, 0xE7, 0x3A, 0xF3, 0xEF, 0xDF, 0xAE, 0x07,
401 0xEC, 0xC7, 0x83, 0x50, 0x9F, 0x6D, 0xB9, 0x28, 0x77, 0xC0, 0xFE, 0x69, 0xB2, 0x2E, 0x55, 0x90,
402 0x50, 0xED, 0xE0, 0xA1, 0x4D, 0x3D, 0x38, 0xC9, 0x0E, 0xCD, 0x04, 0x3B, 0x64, 0x3F, 0x56, 0xC5,
403 0xC3, 0x9E, 0x89, 0x81, 0x44, 0x60, 0xBA, 0x8E, 0x88, 0xA4, 0xA3, 0x42, 0x7B, 0x06, 0x93, 0x1C,
404 0x6B, 0x04, 0x29, 0xF9, 0xDD, 0xFF, 0xB0, 0x48, 0x2F, 0x6D, 0xD1, 0x0F, 0x7D, 0xA6, 0x26, 0xD8,
405 0xEF, 0x5E, 0x04, 0x18, 0xD1, 0x61, 0x46, 0x37, 0x87, 0xE2, 0x97, 0xDF, 0x10, 0xB4, 0x9A, 0x39,
406 0xB1, 0xD0, 0xCA, 0x91, 0x48, 0x1E, 0x5D, 0xA1, 0x38, 0x89, 0x02, 0xC1, 0x49, 0x86, 0xB7, 0xAE,
407 0x69, 0x20, 0xFA, 0x0E, 0x39, 0xDA, 0xA5, 0xEF, 0x7F, 0xB2, 0x81, 0xB8, 0xC0, 0x3A, 0xF8, 0xDB,
408 0xBC, 0x45, 0xF6, 0xDA, 0xCD, 0xBE, 0x27, 0xBE, 0xF6, 0x20, 0x79, 0xF3, 0xC3, 0xC8, 0xFF, 0x85,
409 0x43, 0x9F, 0xB1, 0x9B, 0x72, 0x88, 0xDD, 0xA4, 0x0D, 0xFC, 0xC6, 0xB5, 0x74, 0x67, 0x29, 0xF5
413 void test_square_simple(void){
416 uint8_t a_b[12] = {0xe6, 0x70, 0x7d, 0x43, 0x74, 0x07, 0x20, 0x22, 0x6a, 0xb8, 0xf4, 0x00};
418 a.wordv=(bigint_word_t*)a_b;
419 c.wordv=(bigint_word_t*)c_b;
420 a.length_W = 12/sizeof(bigint_word_t);
423 bigint_square(&c, &a);
424 cli_putstr("\r\n test: ");
425 bigint_print_hex(&a);
426 cli_putstr("**2 = ");
427 bigint_print_hex(&c);
430 // [fail (c)]: A862 % 2752 = 0D1A ; should a862 % 2752 = b1a
431 void test_reduce_simple(void){
434 uint8_t a_b[4] = {0x62, 0xA8, 0x00, 0x00};
435 uint8_t b_b[4] = {0x52, 0x27, 0x00, 0x00};
437 a.wordv=(bigint_word_t*)a_b;
441 b.wordv=(bigint_word_t*)b_b;
445 c.wordv = (bigint_word_t*)c_b;
447 bigint_reduce(&c, &b);
448 cli_putstr("\r\n test: ");
449 bigint_print_hex(&a);
451 bigint_print_hex(&b);
453 bigint_print_hex(&c);
456 /* gcdext( B5DDAD, 6CBBC2) */
457 /* gcdext( CD319349, 9EFD76CC) */
458 /* gcdext( 1609000771, 6FAC577D72) */
460 void test_gcdext_simple(void){
461 bigint_t a, b, c, d, e;
463 uint8_t a_b[8] = {0x71, 0x07, 0x00, 0x09, 0x16, 0x00, 0x00, 0x00};
464 uint8_t b_b[8] = {0x72, 0x7D, 0x57, 0xAC, 0X6F, 0x00, 0x00, 0x00};
465 uint8_t c_b[16], d_b[16], e_b[16];
466 a.wordv=(bigint_word_t*)a_b;
470 b.wordv=(bigint_word_t*)b_b;
474 c.wordv = (bigint_word_t*)c_b;
475 d.wordv = (bigint_word_t*)d_b;
476 e.wordv = (bigint_word_t*)e_b;
477 bigint_gcdext(&c, &d, &e, &a, &b);
478 cli_putstr("\r\n test: gcd( ");
479 bigint_print_hex(&a);
481 bigint_print_hex(&b);
482 cli_putstr(") => a = ");
483 bigint_print_hex(&d);
484 cli_putstr("; b = ");
485 bigint_print_hex(&e);
486 cli_putstr("; gcd = ");
487 bigint_print_hex(&c);
490 void testrun_performance_bigint(void){
493 /*****************************************************************************
495 *****************************************************************************/
497 const char echo_test_str[] = "echo-test";
498 const char add_test_str[] = "add-test";
499 const char add_scale_test_str[] = "add-scale-test";
500 const char mul_test_str[] = "mul-test";
501 const char square_test_str[] = "square-test";
502 const char reduce_test_str[] = "reduce-test";
503 const char expmod_test_str[] = "expmod-test";
504 const char gcdext_test_str[] = "gcdext-test";
505 const char quick_test_str[] = "quick-test";
506 const char performance_str[] = "performance";
507 const char echo_str[] = "echo";
509 const cmdlist_entry_t cmdlist[] = {
510 { add_test_str, NULL, test_add_bigint },
511 { add_scale_test_str, NULL, test_add_scale_bigint },
512 { mul_test_str, NULL, test_mul_bigint },
513 { square_test_str, NULL, test_square_bigint },
514 { reduce_test_str, NULL, test_reduce_bigint },
515 { expmod_test_str, NULL, test_expmod_bigint },
516 { gcdext_test_str, NULL, test_gcdext_bigint },
517 { quick_test_str, NULL, test_gcdext_simple },
518 { echo_test_str, NULL, test_echo_bigint },
519 { performance_str, NULL, testrun_performance_bigint },
520 { echo_str, (void*)1, (void_fpt)echo_ctrl },
527 welcome_msg(algo_name);
528 cmd_interface(cmdlist);