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