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