test_src/main-bigint-test.c

   1 /* main-bigint-test.c */
   2 /*
   3     This file is part of the AVR-Crypto-Lib.
   4     Copyright (C) 2008, 2009, 2010  Daniel Otte (daniel.otte@rub.de)
   5
   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.
  10
  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.
  15
  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/>.
  18 */
  19 /*
  20  * bigint test-suit
  21  *
  22 */
  23
  24 #include "config.h"
  25
  26 #include "uart_i.h"
  27 #include "debug.h"
  28
  29 #include "noekeon/noekeon.h"
  30 #include "noekeon/noekeon_prng.h"
  31 #include "bigint.h"
  32 #include "bigint_io.h"
  33
  34 #include "cli.h"
  35 #include "performance_test.h"
  36
  37 #include <stdint.h>
  38 #include <string.h>
  39 #include <stdlib.h>
  40
  41 char* algo_name = "BigInt";
  42
  43 /*****************************************************************************
  44  *  additional validation-functions                                                                                      *
  45  *****************************************************************************/
  46 void test_echo_bigint(void){
  47         bigint_t a;
  48         cli_putstr_P(PSTR("\r\necho test\r\n"));
  49         for(;;){
  50                 cli_putstr_P(PSTR("\r\nenter hex number:"));
  51                 if(bigint_read_hex_echo(&a)){
  52                         cli_putstr_P(PSTR("\r\n end echo test"));
  53                         return;
  54                 }
  55                 cli_putstr_P(PSTR("\r\necho: "));
  56                 bigint_print_hex(&a);
  57                 cli_putstr_P(PSTR("\r\n"));
  58                 free(a.wordv);
  59         }
  60 }
  61
  62 void test_add_bigint(void){
  63         bigint_t a, b, c;
  64         cli_putstr_P(PSTR("\r\nadd test\r\n"));
  65         for(;;){
  66                 cli_putstr_P(PSTR("\r\nenter a:"));
  67                 if(bigint_read_hex_echo(&a)){
  68                         cli_putstr_P(PSTR("\r\n end add test"));
  69                         return;
  70                 }
  71                 cli_putstr_P(PSTR("\r\nenter b:"));
  72                 if(bigint_read_hex_echo(&b)){
  73                         free(a.wordv);
  74                         cli_putstr_P(PSTR("\r\n end add test"));
  75                         return;
  76                 }
  77                 cli_putstr_P(PSTR("\r\n "));
  78                 bigint_print_hex(&a);
  79                 cli_putstr_P(PSTR(" + "));
  80                 bigint_print_hex(&b);
  81                 cli_putstr_P(PSTR(" = "));
  82                 uint8_t *c_b;
  83                 c_b = malloc(((a.length_B>b.length_B)?a.length_B:b.length_B)+2);
  84                 if(c_b==NULL){
  85                         cli_putstr_P(PSTR("\n\rERROR: Out of memory!"));
  86                         free(a.wordv);
  87                         free(b.wordv);
  88                         continue;
  89                 }
  90                 c.wordv = c_b;
  91                 bigint_add_s(&c, &a, &b);
  92                 bigint_print_hex(&c);
  93                 cli_putstr_P(PSTR("\r\n"));
  94                 free(a.wordv);
  95                 free(b.wordv);
  96                 free(c_b);
  97         }
  98 }
  99
 100 void test_mul_bigint(void){
 101         bigint_t a, b, c;
 102         cli_putstr_P(PSTR("\r\nmul test\r\n"));
 103         for(;;){
 104                 cli_putstr_P(PSTR("\r\nenter a:"));
 105                 if(bigint_read_hex_echo(&a)){
 106                         cli_putstr_P(PSTR("\r\n end mul test"));
 107                         return;
 108                 }
 109                 cli_putstr_P(PSTR("\r\nenter b:"));
 110                 if(bigint_read_hex_echo(&b)){
 111                         free(a.wordv);
 112                         cli_putstr_P(PSTR("\r\n end mul test"));
 113                         return;
 114                 }
 115                 cli_putstr_P(PSTR("\r\n "));
 116                 bigint_print_hex(&a);
 117                 cli_putstr_P(PSTR(" * "));
 118                 bigint_print_hex(&b);
 119                 cli_putstr_P(PSTR(" = "));
 120                 uint8_t *c_b;
 121                 c_b = malloc((((a.length_B>b.length_B)?a.length_B:b.length_B)+1)*2);
 122                 if(c_b==NULL){
 123                         cli_putstr_P(PSTR("\n\rERROR: Out of memory!"));
 124                         free(a.wordv);
 125                         free(b.wordv);
 126                         continue;
 127                 }
 128                 c.wordv = c_b;
 129                 bigint_mul_s(&c, &a, &b);
 130                 bigint_print_hex(&c);
 131                 cli_putstr_P(PSTR("\r\n"));
 132                 free(a.wordv);
 133                 free(b.wordv);
 134                 free(c_b);
 135         }
 136 }
 137
 138 void test_square_bigint(void){
 139         bigint_t a, c;
 140         cli_putstr_P(PSTR("\r\nsquare test\r\n"));
 141         for(;;){
 142                 cli_putstr_P(PSTR("\r\nenter a:"));
 143                 if(bigint_read_hex_echo(&a)){
 144                         cli_putstr_P(PSTR("\r\n end square test"));
 145                         return;
 146                 }
 147                 cli_putstr_P(PSTR("\r\n "));
 148                 bigint_print_hex(&a);
 149                 cli_putstr_P(PSTR("**2 = "));
 150                 uint8_t *c_b;
 151                 c_b = malloc(a.length_B*2);
 152                 if(c_b==NULL){
 153                         cli_putstr_P(PSTR("\n\rERROR: Out of memory!"));
 154                         free(a.wordv);
 155                         continue;
 156                 }
 157                 c.wordv = c_b;
 158                 bigint_square(&c, &a);
 159                 bigint_print_hex(&c);
 160                 cli_putstr_P(PSTR("\r\n"));
 161                 free(a.wordv);
 162                 free(c_b);
 163         }
 164 }
 165
 166 void test_reduce_bigint(void){
 167         bigint_t a, b;
 168         cli_putstr_P(PSTR("\r\nreduce test\r\n"));
 169         for(;;){
 170                 cli_putstr_P(PSTR("\r\nenter a:"));
 171                 if(bigint_read_hex_echo(&a)){
 172                         cli_putstr_P(PSTR("\r\n end reduce test"));
 173                         return;
 174                 }
 175                 cli_putstr_P(PSTR("\r\nenter b:"));
 176                 if(bigint_read_hex_echo(&b)){
 177                         free(a.wordv);
 178                         cli_putstr_P(PSTR("\r\n end reduce test"));
 179                         return;
 180                 }
 181                 cli_putstr_P(PSTR("\r\n "));
 182                 bigint_print_hex(&a);
 183                 cli_putstr_P(PSTR(" % "));
 184                 bigint_print_hex(&b);
 185                 cli_putstr_P(PSTR(" = "));
 186                 bigint_reduce(&a, &b);
 187                 bigint_print_hex(&a);
 188                 cli_putstr_P(PSTR("\r\n"));
 189                 free(a.wordv);
 190                 free(b.wordv);
 191         }
 192 }
 193 /* d = a**b % c */
 194 void test_expmod_bigint(void){
 195         bigint_t a, b, c, d;
 196         uint8_t *d_b;
 197         cli_putstr_P(PSTR("\r\nreduce test\r\n"));
 198         for(;;){
 199                 cli_putstr_P(PSTR("\r\nenter a:"));
 200                 if(bigint_read_hex_echo(&a)){
 201                         cli_putstr_P(PSTR("\r\n end expmod test"));
 202                         return;
 203                 }
 204                 cli_putstr_P(PSTR("\r\nenter b:"));
 205                 if(bigint_read_hex_echo(&b)){
 206                         free(a.wordv);
 207                         cli_putstr_P(PSTR("\r\n end expmod test"));
 208                         return;
 209                 }
 210                 cli_putstr_P(PSTR("\r\nenter c:"));
 211                 if(bigint_read_hex_echo(&c)){
 212                         free(a.wordv);
 213                         free(b.wordv);
 214                         cli_putstr_P(PSTR("\r\n end expmod test"));
 215                         return;
 216                 }
 217                 d_b = malloc(c.length_B);
 218                 if(d_b==NULL){
 219                         cli_putstr_P(PSTR("\n\rERROR: Out of memory!"));
 220                         free(a.wordv);
 221                         free(b.wordv);
 222                         free(c.wordv);
 223                         continue;
 224                 }
 225                 d.wordv = d_b;
 226                 cli_putstr_P(PSTR("\r\n "));
 227                 bigint_print_hex(&a);
 228                 cli_putstr_P(PSTR("**"));
 229                 bigint_print_hex(&b);
 230                 cli_putstr_P(PSTR(" % "));
 231                 bigint_print_hex(&c);
 232                 cli_putstr_P(PSTR(" = "));
 233                 bigint_expmod_u(&d, &a, &b, &c);
 234                 bigint_print_hex(&d);
 235                 cli_putstr_P(PSTR("\r\n"));
 236                 free(a.wordv);
 237                 free(b.wordv);
 238                 free(c.wordv);
 239                 free(d.wordv);
 240
 241         }
 242 }
 243
 244 void test_gcdext_bigint(void){
 245         bigint_t a, b, c, d, e;
 246         cli_putstr_P(PSTR("\r\ngcdext test\r\n"));
 247         for(;;){
 248                 cli_putstr_P(PSTR("\r\nenter a:"));
 249                 if(bigint_read_hex_echo(&a)){
 250                         cli_putstr_P(PSTR("\r\n end gcdext test"));
 251                         return;
 252                 }
 253                 cli_putstr_P(PSTR("\r\nenter b:"));
 254                 if(bigint_read_hex_echo(&b)){
 255                         free(a.wordv);
 256                         cli_putstr_P(PSTR("\r\n end gcdext test"));
 257                         return;
 258                 }
 259                 c.wordv = malloc((a.length_B<b.length_B)?a.length_B:b.length_B);
 260                 d.wordv = malloc(1+(a.length_B>b.length_B)?a.length_B:b.length_B);
 261                 e.wordv = malloc(1+(a.length_B>b.length_B)?a.length_B:b.length_B);
 262
 263                 cli_putstr_P(PSTR("\r\n gcdext( "));
 264                 bigint_print_hex(&a);
 265                 cli_putstr_P(PSTR(", "));
 266                 bigint_print_hex(&b);
 267                 cli_putstr_P(PSTR(") => "));
 268                 bigint_gcdext(&c, &d, &e, &a, &b);
 269                 cli_putstr_P(PSTR("a = "));
 270                 bigint_print_hex(&d);
 271                 cli_putstr_P(PSTR("; b = "));
 272                 bigint_print_hex(&e);
 273                 cli_putstr_P(PSTR("; gcd = "));
 274                 bigint_print_hex(&c);
 275
 276                 cli_putstr_P(PSTR("\r\n"));
 277                 free(a.wordv);
 278                 free(b.wordv);
 279                 free(c.wordv);
 280                 free(d.wordv);
 281                 free(e.wordv);
 282         }
 283 }
 284
 285 void test_simple(void){
 286         bigint_t a, b, c;
 287         uint8_t a_b[1], b_b[1], c_b[2];
 288         a.wordv=a_b;
 289         b.wordv=b_b;
 290         c.wordv=c_b;
 291         a.length_B = 1;
 292         b.length_B = 1;
 293         a_b[0] = 1;
 294         b_b[0] = 2;
 295         bigint_add_u(&c, &a, &b);
 296         cli_putstr_P(PSTR("\r\n 1+2="));
 297         bigint_print_hex(&c);
 298 }
 299 /*
 300 void test_mul_simple(void){
 301         bigint_t a, b, c;
 302         uint8_t a_b[5] = {0x79, 0x36, 0x9e, 0x72, 0xec};
 303         uint8_t b_b[5] = {0x4a, 0x47, 0x0d, 0xec, 0xfd};
 304         uint8_t c_b[12];
 305         a.wordv=a_b;
 306         b.wordv=b_b;
 307         c.wordv=c_b;
 308         a.length_B = 5;
 309         b.length_B = 5;
 310         bigint_adjust(&a);
 311         bigint_adjust(&b);
 312         bigint_mul_s(&c, &a, &b);
 313         cli_putstr_P(PSTR("\r\n test: "));
 314         bigint_print_hex(&c);
 315 }
 316 */
 317
 318 // -3d1d 6db7 8251 f371 * -7a18 3791 d18b b7c5 = 1d25ce4fdf93390f8d6c709f4d711cf5
 319 // -20538248dece6d29068d * 400b1411b874f81394c6 = -81646b193d95136a6fedb73cee6d30c39fb950e
 320 // -BC8B 7D53 4921 853D * 0DDA 6044 00CE DDE6   =  -a33eb0c5847db8837589c22db395dce
 321 void test_mul_simple(void){
 322         bigint_t a, b, c;
 323
 324 //      uint8_t a_b[10] = {0x8d, 0x06, 0x29, 0x6d, 0xce, 0xde, 0x48, 0x82, 0x53, 0x20};
 325 //      uint8_t b_b[10] = {0xc6, 0x94, 0x13, 0xf8, 0x74, 0xb8, 0x11, 0x14, 0x0b, 0x40};
 326         uint8_t a_b[8] = {0x3d, 0x85, 0x21, 0x49, 0x53, 0x7d, 0x8b, 0xbc};
 327         uint8_t b_b[8] = {0xe6, 0xdd, 0xce, 0x00, 0x44, 0x60, 0xda, 0x0d};
 328
 329         uint8_t c_b[16];
 330         a.wordv=a_b;
 331         b.wordv=b_b;
 332         c.wordv=c_b;
 333         a.length_B = 8;
 334         b.length_B = 8;
 335         a.info=0x80;
 336         bigint_adjust(&a);
 337         bigint_adjust(&b);
 338         bigint_mul_s(&c, &a, &b);
 339         cli_putstr_P(PSTR("\r\n test: "));
 340         bigint_print_hex(&a);
 341         cli_putstr_P(PSTR(" * "));
 342         bigint_print_hex(&b);
 343         cli_putstr_P(PSTR(" = "));
 344         bigint_print_hex(&c);
 345 }
 346
 347 // f4 b86a 2220 0774 437d 70e6 **2 = e9f00f29ca1c876a7a682bd1e04f6925caffd6660ea4
 348 /*
 349 uint8_t square_test_data[] PROGMEM = {
 350         0xA0, 0x3C, 0x23, 0x9F, 0x7A, 0xFC, 0x60, 0xEB, 0x96, 0xC2, 0xA8, 0xAC, 0xC3, 0xC9, 0x9E, 0xEC,
 351         0x4A, 0xF0, 0x1C, 0xB2, 0x36, 0x68, 0xD6, 0x4D, 0x3E, 0x4F, 0x8E, 0x55, 0xEA, 0x52, 0x46, 0x68,
 352         0x6E, 0x18, 0x88, 0x37, 0x03, 0x70, 0xBD, 0x01, 0x60, 0xE2, 0xD6, 0x12, 0xA0, 0x0E, 0xD2, 0x72,
 353         0x0D, 0x9D, 0x9F, 0x03, 0xC5, 0x81, 0xCA, 0x6E, 0x88, 0x1E, 0xF5, 0xD8, 0x14, 0x15, 0x30, 0xEB,
 354         0x28, 0x7C, 0x80, 0x07, 0x34, 0x05, 0x5D, 0xAA, 0xDC, 0xA8, 0xAA, 0x88, 0xC5, 0xE5, 0xC9, 0xFE,
 355         0x9C, 0xA1, 0xCE, 0xC2, 0x09, 0x0D, 0xC4, 0xC8, 0xD3, 0xE7, 0x3A, 0xF3, 0xEF, 0xDF, 0xAE, 0x07,
 356         0xEC, 0xC7, 0x83, 0x50, 0x9F, 0x6D, 0xB9, 0x28, 0x77, 0xC0, 0xFE, 0x69, 0xB2, 0x2E, 0x55, 0x90,
 357         0x50, 0xED, 0xE0, 0xA1, 0x4D, 0x3D, 0x38, 0xC9, 0x0E, 0xCD, 0x04, 0x3B, 0x64, 0x3F, 0x56, 0xC5,
 358         0xC3, 0x9E, 0x89, 0x81, 0x44, 0x60, 0xBA, 0x8E, 0x88, 0xA4, 0xA3, 0x42, 0x7B, 0x06, 0x93, 0x1C,
 359         0x6B, 0x04, 0x29, 0xF9, 0xDD, 0xFF, 0xB0, 0x48, 0x2F, 0x6D, 0xD1, 0x0F, 0x7D, 0xA6, 0x26, 0xD8,
 360         0xEF, 0x5E, 0x04, 0x18, 0xD1, 0x61, 0x46, 0x37, 0x87, 0xE2, 0x97, 0xDF, 0x10, 0xB4, 0x9A, 0x39,
 361         0xB1, 0xD0, 0xCA, 0x91, 0x48, 0x1E, 0x5D, 0xA1, 0x38, 0x89, 0x02, 0xC1, 0x49, 0x86, 0xB7, 0xAE,
 362         0x69, 0x20, 0xFA, 0x0E, 0x39, 0xDA, 0xA5, 0xEF, 0x7F, 0xB2, 0x81, 0xB8, 0xC0, 0x3A, 0xF8, 0xDB,
 363         0xBC, 0x45, 0xF6, 0xDA, 0xCD, 0xBE, 0x27, 0xBE, 0xF6, 0x20, 0x79, 0xF3, 0xC3, 0xC8, 0xFF, 0x85,
 364         0x43, 0x9F, 0xB1, 0x9B, 0x72, 0x88, 0xDD, 0xA4, 0x0D, 0xFC, 0xC6, 0xB5, 0x74, 0x67, 0x29, 0xF5
 365 };
 366 */
 367
 368 void test_square_simple(void){
 369         bigint_t a, c;
 370
 371         uint8_t a_b[11] = {0xe6, 0x70, 0x7d, 0x43, 0x74, 0x07, 0x20, 0x22, 0x6a, 0xb8, 0xf4};
 372         uint8_t c_b[22];
 373         a.wordv=a_b;
 374         c.wordv=c_b;
 375         a.length_B = 11;
 376         a.info=0x00;
 377         bigint_adjust(&a);
 378         bigint_square(&c, &a);
 379         cli_putstr_P(PSTR("\r\n test: "));
 380         bigint_print_hex(&a);
 381         cli_putstr_P(PSTR("**2 = "));
 382         bigint_print_hex(&c);
 383 }
 384
 385 // [fail (c)]:  A862 % 2752 = 0D1A ; should a862 % 2752 = b1a
 386 void test_reduce_simple(void){
 387         bigint_t a, b, c;
 388
 389         uint8_t a_b[2] = {0x62, 0xA8};
 390         uint8_t b_b[2] = {0x52, 0x27};
 391         uint8_t c_b[2];
 392         a.wordv=a_b;
 393         a.length_B = 2;
 394         a.info=0x00;
 395         bigint_adjust(&a);
 396         b.wordv=b_b;
 397         b.length_B = 2;
 398         b.info=0x00;
 399         bigint_adjust(&b);
 400         c.wordv = c_b;
 401         bigint_copy(&c, &a);
 402         bigint_reduce(&c, &b);
 403         cli_putstr_P(PSTR("\r\n test: "));
 404         bigint_print_hex(&a);
 405         cli_putstr_P(PSTR(" % "));
 406         bigint_print_hex(&b);
 407         cli_putstr_P(PSTR(" = "));
 408         bigint_print_hex(&c);
 409 }
 410
 411 /*  gcdext( B5DDAD, 6CBBC2) */
 412 /*  gcdext( CD319349, 9EFD76CC) */
 413 /*  gcdext( 1609000771, 6FAC577D72) */
 414 /*  */
 415 void test_gcdext_simple(void){
 416         bigint_t a, b, c, d, e;
 417
 418         uint8_t a_b[5] = {0x71, 0x07, 0x00, 0x09, 0x16};
 419         uint8_t b_b[5] = {0x72, 0x7D, 0x57, 0xAC, 0X6F};
 420         uint8_t c_b[6], d_b[6], e_b[6];
 421         a.wordv=a_b;
 422         a.length_B = 5;
 423         a.info=0x00;
 424         bigint_adjust(&a);
 425         b.wordv=b_b;
 426         b.length_B = 5;
 427         b.info=0x00;
 428         bigint_adjust(&b);
 429         c.wordv = c_b;
 430         d.wordv = d_b;
 431         e.wordv = e_b;
 432         bigint_gcdext(&c, &d, &e, &a, &b);
 433         cli_putstr_P(PSTR("\r\n test: gcd( "));
 434         bigint_print_hex(&a);
 435         cli_putstr_P(PSTR(", "));
 436         bigint_print_hex(&b);
 437         cli_putstr_P(PSTR(") => a =  "));
 438         bigint_print_hex(&d);
 439         cli_putstr_P(PSTR("; b =  "));
 440         bigint_print_hex(&e);
 441         cli_putstr_P(PSTR("; gcd =  "));
 442         bigint_print_hex(&c);
 443 }
 444
 445 void testrun_performance_bigint(void){
 446
 447 }
 448 /*****************************************************************************
 449  *  main                                                                                                                                         *
 450  *****************************************************************************/
 451
 452 const char echo_test_str[]        PROGMEM = "echo-test";
 453 const char add_test_str[]         PROGMEM = "add-test";
 454 const char mul_test_str[]         PROGMEM = "mul-test";
 455 const char square_test_str[]      PROGMEM = "square-test";
 456 const char reduce_test_str[]      PROGMEM = "reduce-test";
 457 const char expmod_test_str[]      PROGMEM = "expmod-test";
 458 const char gcdext_test_str[]      PROGMEM = "gcdext-test";
 459 const char quick_test_str[]       PROGMEM = "quick-test";
 460 const char performance_str[]      PROGMEM = "performance";
 461 const char echo_str[]             PROGMEM = "echo";
 462
 463 cmdlist_entry_t cmdlist[] PROGMEM = {
 464         { add_test_str,         NULL, test_add_bigint               },
 465         { mul_test_str,         NULL, test_mul_bigint               },
 466         { square_test_str,      NULL, test_square_bigint            },
 467         { reduce_test_str,      NULL, test_reduce_bigint            },
 468         { expmod_test_str,      NULL, test_expmod_bigint            },
 469         { gcdext_test_str,      NULL, test_gcdext_bigint            },
 470         { quick_test_str,       NULL, test_gcdext_simple            },
 471         { echo_test_str,        NULL, test_echo_bigint              },
 472         { performance_str,      NULL, testrun_performance_bigint    },
 473         { echo_str,         (void*)1, (void_fpt)echo_ctrl           },
 474         { NULL,                 NULL, NULL                          }
 475 };
 476
 477 int main (void){
 478         DEBUG_INIT();
 479
 480         cli_rx = (cli_rx_fpt)uart0_getc;
 481         cli_tx = (cli_tx_fpt)uart0_putc;
 482         for(;;){
 483                 cli_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
 484                 cli_putstr(algo_name);
 485                 cli_putstr_P(PSTR(")\r\nloaded and running\r\n"));
 486                 cmd_interface(cmdlist);
 487         }
 488 }