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