test_src/main-bigint-test.c

   1 /* main-bigint-test.c */
   2 /*
   3     This file is part of the ARM-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 #include "main-test-common.h"
  24
  25 #include "noekeon.h"
  26 #include "noekeon_prng.h"
  27 #include "bigint.h"
  28 #include "bigint_io.h"
  29
  30 #include "performance_test.h"
  31
  32 char* algo_name = "BigInt";
  33
  34 /*****************************************************************************
  35  *  additional validation-functions                                                                                      *
  36  *****************************************************************************/
  37 void test_echo_bigint(void){
  38         bigint_t a;
  39         cli_putstr("\r\necho test\r\n");
  40         for(;;){
  41                 cli_putstr("\r\nenter hex number:");
  42                 if(bigint_read_hex_echo(&a)){
  43                         cli_putstr("\r\n end echo test");
  44                         return;
  45                 }
  46                 cli_putstr("\r\necho: ");
  47                 bigint_print_hex(&a);
  48                 cli_putstr("\r\n");
  49                 free(a.wordv);
  50         }
  51 }
  52
  53 void test_add_bigint(void){
  54         bigint_t a, b, c;
  55         cli_putstr("\r\nadd test\r\n");
  56         for(;;){
  57                 cli_putstr("\r\nenter a:");
  58                 if(bigint_read_hex_echo(&a)){
  59                         cli_putstr("\r\n end add test");
  60                         return;
  61                 }
  62                 cli_putstr("\r\nenter b:");
  63                 if(bigint_read_hex_echo(&b)){
  64                         free(a.wordv);
  65                         cli_putstr("\r\n end add test");
  66                         return;
  67                 }
  68                 cli_putstr("\r\n ");
  69                 bigint_print_hex(&a);
  70                 cli_putstr(" + ");
  71                 bigint_print_hex(&b);
  72                 cli_putstr(" = ");
  73                 bigint_word_t *c_b;
  74                 c_b = malloc(((a.length_B>b.length_B)?a.length_B:b.length_B)*sizeof(bigint_word_t)+8);
  75                 if(c_b==NULL){
  76                         cli_putstr("\n\rERROR: Out of memory!");
  77                         free(a.wordv);
  78                         free(b.wordv);
  79                         continue;
  80                 }
  81                 c.wordv = c_b;
  82                 bigint_add_s(&c, &a, &b);
  83                 bigint_print_hex(&c);
  84                 cli_putstr("\r\n");
  85                 free(a.wordv);
  86                 free(b.wordv);
  87                 free(c_b);
  88         }
  89 }
  90
  91 void test_add_scale_bigint(void){
  92         bigint_t a, b, c;
  93         uint16_t scale;
  94         cli_putstr("\r\nadd-scale test\r\n");
  95         for(;;){
  96                 cli_putstr("\r\nenter a:");
  97                 if(bigint_read_hex_echo(&a)){
  98                         cli_putstr("\r\n end add test");
  99                         return;
 100                 }
 101                 cli_putstr("\r\nenter b:");
 102                 if(bigint_read_hex_echo(&b)){
 103                         cli_putstr("\r\n end add test");
 104                         return;
 105                 }
 106                 cli_putstr("\r\nenter scale:");
 107                 {
 108                         char str[8];
 109                         cli_getsn(str, 7);
 110                         scale = atoi(str);
 111                 }
 112         /*
 113                 if(bigint_read_hex_echo(&scale)){
 114                         free(scale.wordv);
 115                         cli_putstr("\r\n end add test");
 116                         return;
 117                 }
 118         */
 119                 cli_putstr("\r\n ");
 120                 bigint_print_hex(&a);
 121                 cli_putstr(" + ");
 122                 bigint_print_hex(&b);
 123                 cli_putstr("<<8*");
 124                 cli_hexdump_rev(&scale, 2);
 125                 cli_putstr(" = ");
 126                 bigint_word_t *c_b;
 127                 c_b = malloc((((a.length_B>(b.length_B+scale))?a.length_B:(b.length_B+scale))+1)*sizeof(bigint_word_t));
 128                 if(c_b==NULL){
 129                         cli_putstr("\n\rERROR: Out of memory!");
 130                         free(a.wordv);
 131                         free(b.wordv);
 132                         continue;
 133                 }
 134                 c.wordv = c_b;
 135                 bigint_copy(&c, &a);
 136                 bigint_add_scale_u(&c, &b, scale);
 137                 bigint_print_hex(&c);
 138                 cli_putstr("\r\n");
 139                 free(a.wordv);
 140                 free(b.wordv);
 141                 free(c_b);
 142         }
 143 }
 144
 145 void test_mul_bigint(void){
 146         bigint_t a, b, c;
 147         cli_putstr("\r\nmul test\r\n");
 148         for(;;){
 149                 cli_putstr("\r\nenter a:");
 150                 if(bigint_read_hex_echo(&a)){
 151                         cli_putstr("\r\n end mul test");
 152                         return;
 153                 }
 154                 cli_putstr("\r\nenter b:");
 155                 if(bigint_read_hex_echo(&b)){
 156                         free(a.wordv);
 157                         cli_putstr("\r\n end mul test");
 158                         return;
 159                 }
 160                 cli_putstr("\r\n ");
 161                 bigint_print_hex(&a);
 162                 cli_putstr(" * ");
 163                 bigint_print_hex(&b);
 164                 cli_putstr(" = ");
 165                 bigint_word_t *c_b;
 166                 c_b = malloc((((a.length_B>b.length_B)?a.length_B:b.length_B)+1)*2*sizeof(bigint_word_t));
 167                 if(c_b==NULL){
 168                         cli_putstr("\n\rERROR: Out of memory!");
 169                         free(a.wordv);
 170                         free(b.wordv);
 171                         continue;
 172                 }
 173                 c.wordv = c_b;
 174                 bigint_mul_s(&c, &a, &b);
 175                 bigint_print_hex(&c);
 176                 cli_putstr("\r\n");
 177                 free(a.wordv);
 178                 free(b.wordv);
 179                 free(c_b);
 180         }
 181 }
 182
 183 void test_square_bigint(void){
 184         bigint_t a, c;
 185         cli_putstr("\r\nsquare test\r\n");
 186         for(;;){
 187                 cli_putstr("\r\nenter a:");
 188                 if(bigint_read_hex_echo(&a)){
 189                         cli_putstr("\r\n end square test");
 190                         return;
 191                 }
 192                 cli_putstr("\r\n ");
 193                 bigint_print_hex(&a);
 194                 cli_putstr("**2 = ");
 195                 bigint_word_t *c_b;
 196                 c_b = malloc(a.length_B*2*sizeof(bigint_word_t));
 197                 if(c_b==NULL){
 198                         cli_putstr("\n\rERROR: Out of memory!");
 199                         free(a.wordv);
 200                         continue;
 201                 }
 202                 c.wordv = c_b;
 203                 bigint_square(&c, &a);
 204                 bigint_print_hex(&c);
 205                 cli_putstr("\r\n");
 206                 free(a.wordv);
 207                 free(c_b);
 208         }
 209 }
 210
 211 void test_reduce_bigint(void){
 212         bigint_t a, b;
 213         cli_putstr("\r\nreduce test\r\n");
 214         for(;;){
 215                 cli_putstr("\r\nenter a:");
 216                 if(bigint_read_hex_echo(&a)){
 217                         cli_putstr("\r\n end reduce test");
 218                         return;
 219                 }
 220                 cli_putstr("\r\nenter b:");
 221                 if(bigint_read_hex_echo(&b)){
 222                         free(a.wordv);
 223                         cli_putstr("\r\n end reduce test");
 224                         return;
 225                 }
 226                 cli_putstr("\r\n ");
 227                 bigint_print_hex(&a);
 228                 cli_putstr(" % ");
 229                 bigint_print_hex(&b);
 230                 cli_putstr(" = ");
 231                 bigint_reduce(&a, &b);
 232                 bigint_print_hex(&a);
 233                 cli_putstr("\r\n");
 234                 free(a.wordv);
 235                 free(b.wordv);
 236         }
 237 }
 238 /* d = a**b % c */
 239 void test_expmod_bigint(void){
 240         bigint_t a, b, c, d;
 241         bigint_word_t *d_b;
 242         cli_putstr("\r\nreduce test\r\n");
 243         for(;;){
 244                 cli_putstr("\r\nenter a:");
 245                 if(bigint_read_hex_echo(&a)){
 246                         cli_putstr("\r\n end expmod test");
 247                         return;
 248                 }
 249                 cli_putstr("\r\nenter b:");
 250                 if(bigint_read_hex_echo(&b)){
 251                         free(a.wordv);
 252                         cli_putstr("\r\n end expmod test");
 253                         return;
 254                 }
 255                 cli_putstr("\r\nenter c:");
 256                 if(bigint_read_hex_echo(&c)){
 257                         free(a.wordv);
 258                         free(b.wordv);
 259                         cli_putstr("\r\n end expmod test");
 260                         return;
 261                 }
 262                 d_b = malloc(c.length_B*sizeof(bigint_word_t));
 263                 if(d_b==NULL){
 264                         cli_putstr("\n\rERROR: Out of memory!");
 265                         free(a.wordv);
 266                         free(b.wordv);
 267                         free(c.wordv);
 268                         continue;
 269                 }
 270                 d.wordv = d_b;
 271                 cli_putstr("\r\n ");
 272                 bigint_print_hex(&a);
 273                 cli_putstr("**");
 274                 bigint_print_hex(&b);
 275                 cli_putstr(" % ");
 276                 bigint_print_hex(&c);
 277                 cli_putstr(" = ");
 278                 bigint_expmod_u(&d, &a, &b, &c);
 279                 bigint_print_hex(&d);
 280                 cli_putstr("\r\n");
 281                 free(a.wordv);
 282                 free(b.wordv);
 283                 free(c.wordv);
 284                 free(d.wordv);
 285
 286         }
 287 }
 288
 289 void test_gcdext_bigint(void){
 290         bigint_t a, b, c, d, e;
 291         cli_putstr("\r\ngcdext test\r\n");
 292         for(;;){
 293                 cli_putstr("\r\nenter a:");
 294                 if(bigint_read_hex_echo(&a)){
 295                         cli_putstr("\r\n end gcdext test");
 296                         return;
 297                 }
 298                 cli_putstr("\r\nenter b:");
 299                 if(bigint_read_hex_echo(&b)){
 300                         free(a.wordv);
 301                         cli_putstr("\r\n end gcdext test");
 302                         return;
 303                 }
 304                 c.wordv = malloc(((a.length_B<b.length_B)?a.length_B:b.length_B)*sizeof(bigint_word_t));
 305                 d.wordv = malloc((1+(a.length_B>b.length_B)?a.length_B:b.length_B)*sizeof(bigint_word_t));
 306                 e.wordv = malloc((1+(a.length_B>b.length_B)?a.length_B:b.length_B)*sizeof(bigint_word_t));
 307
 308                 cli_putstr("\r\n gcdext( ");
 309                 bigint_print_hex(&a);
 310                 cli_putstr(", ");
 311                 bigint_print_hex(&b);
 312                 cli_putstr(") => ");
 313                 bigint_gcdext(&c, &d, &e, &a, &b);
 314                 cli_putstr("a = ");
 315                 bigint_print_hex(&d);
 316                 cli_putstr("; b = ");
 317                 bigint_print_hex(&e);
 318                 cli_putstr("; gcd = ");
 319                 bigint_print_hex(&c);
 320
 321                 cli_putstr("\r\n");
 322                 free(a.wordv);
 323                 free(b.wordv);
 324                 free(c.wordv);
 325                 free(d.wordv);
 326                 free(e.wordv);
 327         }
 328 }
 329
 330 void test_simple(void){
 331         bigint_t a, b, c;
 332         bigint_word_t a_b[1], b_b[1], c_b[2];
 333         a.wordv=a_b;
 334         b.wordv=b_b;
 335         c.wordv=c_b;
 336         a.length_B = 1;
 337         b.length_B = 1;
 338         a_b[0] = 1;
 339         b_b[0] = 2;
 340         bigint_add_u(&c, &a, &b);
 341         cli_putstr("\r\n 1+2=");
 342         bigint_print_hex(&c);
 343 }
 344 /*
 345 void test_mul_simple(void){
 346         bigint_t a, b, c;
 347         uint8_t a_b[5] = {0x79, 0x36, 0x9e, 0x72, 0xec};
 348         uint8_t b_b[5] = {0x4a, 0x47, 0x0d, 0xec, 0xfd};
 349         uint8_t c_b[12];
 350         a.wordv=a_b;
 351         b.wordv=b_b;
 352         c.wordv=c_b;
 353         a.length_B = 5;
 354         b.length_B = 5;
 355         bigint_adjust(&a);
 356         bigint_adjust(&b);
 357         bigint_mul_s(&c, &a, &b);
 358         cli_putstr("\r\n test: ");
 359         bigint_print_hex(&c);
 360 }
 361 */
 362
 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){
 367         bigint_t a, b, c;
 368
 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};
 373
 374         uint8_t c_b[16];
 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_B = 8/sizeof(bigint_word_t);
 379         b.length_B = 8/sizeof(bigint_word_t);
 380         a.info=0x80;
 381         bigint_adjust(&a);
 382         bigint_adjust(&b);
 383         bigint_mul_s(&c, &a, &b);
 384         cli_putstr("\r\n test: ");
 385         bigint_print_hex(&a);
 386         cli_putstr(" * ");
 387         bigint_print_hex(&b);
 388         cli_putstr(" = ");
 389         bigint_print_hex(&c);
 390 }
 391
 392 // f4 b86a 2220 0774 437d 70e6 **2 = e9f00f29ca1c876a7a682bd1e04f6925caffd6660ea4
 393 /*
 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
 410 };
 411 */
 412
 413 void test_square_simple(void){
 414         bigint_t a, c;
 415
 416         uint8_t a_b[12] = {0xe6, 0x70, 0x7d, 0x43, 0x74, 0x07, 0x20, 0x22, 0x6a, 0xb8, 0xf4, 0x00};
 417         uint8_t c_b[24];
 418         a.wordv=(bigint_word_t*)a_b;
 419         c.wordv=(bigint_word_t*)c_b;
 420         a.length_B = 12/sizeof(bigint_word_t);
 421         a.info=0x00;
 422         bigint_adjust(&a);
 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);
 428 }
 429
 430 // [fail (c)]:  A862 % 2752 = 0D1A ; should a862 % 2752 = b1a
 431 void test_reduce_simple(void){
 432         bigint_t a, b, c;
 433
 434         uint8_t a_b[4] = {0x62, 0xA8, 0x00, 0x00};
 435         uint8_t b_b[4] = {0x52, 0x27, 0x00, 0x00};
 436         uint8_t c_b[4];
 437         a.wordv=(bigint_word_t*)a_b;
 438         a.length_B = 1;
 439         a.info=0x00;
 440         bigint_adjust(&a);
 441         b.wordv=(bigint_word_t*)b_b;
 442         b.length_B = 1;
 443         b.info=0x00;
 444         bigint_adjust(&b);
 445         c.wordv = (bigint_word_t*)c_b;
 446         bigint_copy(&c, &a);
 447         bigint_reduce(&c, &b);
 448         cli_putstr("\r\n test: ");
 449         bigint_print_hex(&a);
 450         cli_putstr(" % ");
 451         bigint_print_hex(&b);
 452         cli_putstr(" = ");
 453         bigint_print_hex(&c);
 454 }
 455
 456 /*  gcdext( B5DDAD, 6CBBC2) */
 457 /*  gcdext( CD319349, 9EFD76CC) */
 458 /*  gcdext( 1609000771, 6FAC577D72) */
 459 /*  */
 460 void test_gcdext_simple(void){
 461         bigint_t a, b, c, d, e;
 462
 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;
 467         a.length_B = 2;
 468         a.info=0x00;
 469         bigint_adjust(&a);
 470         b.wordv=(bigint_word_t*)b_b;
 471         b.length_B = 2;
 472         b.info=0x00;
 473         bigint_adjust(&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);
 480         cli_putstr(", ");
 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);
 488 }
 489
 490 void testrun_performance_bigint(void){
 491
 492 }
 493 /*****************************************************************************
 494  *  main                                                                                                                                         *
 495  *****************************************************************************/
 496
 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";
 508
 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           },
 521         { NULL,                 NULL, NULL                          }
 522 };
 523
 524 int main (void){
 525         main_setup();
 526         for(;;){
 527                 welcome_msg(algo_name);
 528                 cmd_interface(cmdlist);
 529         }
 530 }