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