test_src/main-bigint-test.c

   1 /* main-base64-test.c */
   2 /*
   3     This file is part of the AVR-Crypto-Lib.
   4     Copyright (C) 2008, 2009  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  * base64 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_mul_bigint(void){
 101         bigint_t a, b, c;
 102         cli_putstr_P(PSTR("\r\nmul test\r\n"));
 103         for(;;){
 104                 cli_putstr_P(PSTR("\r\nenter a:"));
 105                 if(bigint_read_hex_echo(&a)){
 106                         cli_putstr_P(PSTR("\r\n end mul test"));
 107                         return;
 108                 }
 109                 cli_putstr_P(PSTR("\r\nenter b:"));
 110                 if(bigint_read_hex_echo(&b)){
 111                         free(a.wordv);
 112                         cli_putstr_P(PSTR("\r\n end mul test"));
 113                         return;
 114                 }
 115                 cli_putstr_P(PSTR("\r\n "));
 116                 bigint_print_hex(&a);
 117                 cli_putstr_P(PSTR(" * "));
 118                 bigint_print_hex(&b);
 119                 cli_putstr_P(PSTR(" = "));
 120                 uint8_t *c_b;
 121                 c_b = malloc((((a.length_B>b.length_B)?a.length_B:b.length_B)+1)*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_mul_s(&c, &a, &b);
 130                 bigint_print_hex(&c);
 131                 cli_putstr_P(PSTR("\r\n"));
 132                 free(a.wordv);
 133                 free(b.wordv);
 134                 free(c_b);
 135         }
 136 }
 137
 138 void test_square_bigint(void){
 139         bigint_t a, c;
 140         cli_putstr_P(PSTR("\r\nsquare test\r\n"));
 141         for(;;){
 142                 cli_putstr_P(PSTR("\r\nenter a:"));
 143                 if(bigint_read_hex_echo(&a)){
 144                         cli_putstr_P(PSTR("\r\n end square test"));
 145                         return;
 146                 }
 147                 cli_putstr_P(PSTR("\r\n "));
 148                 bigint_print_hex(&a);
 149                 cli_putstr_P(PSTR("**2 = "));
 150                 uint8_t *c_b;
 151                 c_b = malloc(a.length_B*2);
 152                 if(c_b==NULL){
 153                         cli_putstr_P(PSTR("\n\rERROR: Out of memory!"));
 154                         free(a.wordv);
 155                         continue;
 156                 }
 157                 c.wordv = c_b;
 158                 bigint_square(&c, &a);
 159                 bigint_print_hex(&c);
 160                 cli_putstr_P(PSTR("\r\n"));
 161                 free(a.wordv);
 162                 free(c_b);
 163         }
 164 }
 165
 166 void test_reduce_bigint(void){
 167         bigint_t a, b, c;
 168         cli_putstr_P(PSTR("\r\nreduce test\r\n"));
 169         for(;;){
 170                 cli_putstr_P(PSTR("\r\nenter a:"));
 171                 if(bigint_read_hex_echo(&a)){
 172                         cli_putstr_P(PSTR("\r\n end reduce test"));
 173                         return;
 174                 }
 175                 cli_putstr_P(PSTR("\r\nenter b:"));
 176                 if(bigint_read_hex_echo(&b)){
 177                         free(a.wordv);
 178                         cli_putstr_P(PSTR("\r\n end reduce test"));
 179                         return;
 180                 }
 181                 cli_putstr_P(PSTR("\r\n "));
 182                 bigint_print_hex(&a);
 183                 cli_putstr_P(PSTR(" % "));
 184                 bigint_print_hex(&b);
 185                 cli_putstr_P(PSTR(" = "));
 186                 bigint_reduce(&a, &b);
 187                 bigint_print_hex(&a);
 188                 cli_putstr_P(PSTR("\r\n"));
 189                 free(a.wordv);
 190                 free(b.wordv);
 191         }
 192 }
 193
 194 void test_simple(void){
 195         bigint_t a, b, c;
 196         uint8_t a_b[1], b_b[1], c_b[2];
 197         a.wordv=a_b;
 198         b.wordv=b_b;
 199         c.wordv=c_b;
 200         a.length_B = 1;
 201         b.length_B = 1;
 202         a_b[0] = 1;
 203         b_b[0] = 2;
 204         bigint_add_u(&c, &a, &b);
 205         cli_putstr_P(PSTR("\r\n 1+2="));
 206         bigint_print_hex(&c);
 207 }
 208 /*
 209 void test_mul_simple(void){
 210         bigint_t a, b, c;
 211         uint8_t a_b[5] = {0x79, 0x36, 0x9e, 0x72, 0xec};
 212         uint8_t b_b[5] = {0x4a, 0x47, 0x0d, 0xec, 0xfd};
 213         uint8_t c_b[12];
 214         a.wordv=a_b;
 215         b.wordv=b_b;
 216         c.wordv=c_b;
 217         a.length_B = 5;
 218         b.length_B = 5;
 219         bigint_adjust(&a);
 220         bigint_adjust(&b);
 221         bigint_mul_s(&c, &a, &b);
 222         cli_putstr_P(PSTR("\r\n test: "));
 223         bigint_print_hex(&c);
 224 }
 225 */
 226
 227 // -3d1d 6db7 8251 f371 * -7a18 3791 d18b b7c5 = 1d25ce4fdf93390f8d6c709f4d711cf5
 228 // -20538248dece6d29068d * 400b1411b874f81394c6 = -81646b193d95136a6fedb73cee6d30c39fb950e
 229 // -BC8B 7D53 4921 853D * 0DDA 6044 00CE DDE6   =  -a33eb0c5847db8837589c22db395dce
 230 void test_mul_simple(void){
 231         bigint_t a, b, c;
 232
 233 //      uint8_t a_b[10] = {0x8d, 0x06, 0x29, 0x6d, 0xce, 0xde, 0x48, 0x82, 0x53, 0x20};
 234 //      uint8_t b_b[10] = {0xc6, 0x94, 0x13, 0xf8, 0x74, 0xb8, 0x11, 0x14, 0x0b, 0x40};
 235         uint8_t a_b[8] = {0x3d, 0x85, 0x21, 0x49, 0x53, 0x7d, 0x8b, 0xbc};
 236         uint8_t b_b[8] = {0xe6, 0xdd, 0xce, 0x00, 0x44, 0x60, 0xda, 0x0d};
 237
 238         uint8_t c_b[16];
 239         a.wordv=a_b;
 240         b.wordv=b_b;
 241         c.wordv=c_b;
 242         a.length_B = 8;
 243         b.length_B = 8;
 244         a.info=0x80;
 245         bigint_adjust(&a);
 246         bigint_adjust(&b);
 247         bigint_mul_s(&c, &a, &b);
 248         cli_putstr_P(PSTR("\r\n test: "));
 249         bigint_print_hex(&a);
 250         cli_putstr_P(PSTR(" * "));
 251         bigint_print_hex(&b);
 252         cli_putstr_P(PSTR(" = "));
 253         bigint_print_hex(&c);
 254 }
 255
 256 // f4 b86a 2220 0774 437d 70e6 **2 = e9f00f29ca1c876a7a682bd1e04f6925caffd6660ea4
 257 /*
 258 uint8_t square_test_data[] PROGMEM = {
 259         0xA0, 0x3C, 0x23, 0x9F, 0x7A, 0xFC, 0x60, 0xEB, 0x96, 0xC2, 0xA8, 0xAC, 0xC3, 0xC9, 0x9E, 0xEC,
 260         0x4A, 0xF0, 0x1C, 0xB2, 0x36, 0x68, 0xD6, 0x4D, 0x3E, 0x4F, 0x8E, 0x55, 0xEA, 0x52, 0x46, 0x68,
 261         0x6E, 0x18, 0x88, 0x37, 0x03, 0x70, 0xBD, 0x01, 0x60, 0xE2, 0xD6, 0x12, 0xA0, 0x0E, 0xD2, 0x72,
 262         0x0D, 0x9D, 0x9F, 0x03, 0xC5, 0x81, 0xCA, 0x6E, 0x88, 0x1E, 0xF5, 0xD8, 0x14, 0x15, 0x30, 0xEB,
 263         0x28, 0x7C, 0x80, 0x07, 0x34, 0x05, 0x5D, 0xAA, 0xDC, 0xA8, 0xAA, 0x88, 0xC5, 0xE5, 0xC9, 0xFE,
 264         0x9C, 0xA1, 0xCE, 0xC2, 0x09, 0x0D, 0xC4, 0xC8, 0xD3, 0xE7, 0x3A, 0xF3, 0xEF, 0xDF, 0xAE, 0x07,
 265         0xEC, 0xC7, 0x83, 0x50, 0x9F, 0x6D, 0xB9, 0x28, 0x77, 0xC0, 0xFE, 0x69, 0xB2, 0x2E, 0x55, 0x90,
 266         0x50, 0xED, 0xE0, 0xA1, 0x4D, 0x3D, 0x38, 0xC9, 0x0E, 0xCD, 0x04, 0x3B, 0x64, 0x3F, 0x56, 0xC5,
 267         0xC3, 0x9E, 0x89, 0x81, 0x44, 0x60, 0xBA, 0x8E, 0x88, 0xA4, 0xA3, 0x42, 0x7B, 0x06, 0x93, 0x1C,
 268         0x6B, 0x04, 0x29, 0xF9, 0xDD, 0xFF, 0xB0, 0x48, 0x2F, 0x6D, 0xD1, 0x0F, 0x7D, 0xA6, 0x26, 0xD8,
 269         0xEF, 0x5E, 0x04, 0x18, 0xD1, 0x61, 0x46, 0x37, 0x87, 0xE2, 0x97, 0xDF, 0x10, 0xB4, 0x9A, 0x39,
 270         0xB1, 0xD0, 0xCA, 0x91, 0x48, 0x1E, 0x5D, 0xA1, 0x38, 0x89, 0x02, 0xC1, 0x49, 0x86, 0xB7, 0xAE,
 271         0x69, 0x20, 0xFA, 0x0E, 0x39, 0xDA, 0xA5, 0xEF, 0x7F, 0xB2, 0x81, 0xB8, 0xC0, 0x3A, 0xF8, 0xDB,
 272         0xBC, 0x45, 0xF6, 0xDA, 0xCD, 0xBE, 0x27, 0xBE, 0xF6, 0x20, 0x79, 0xF3, 0xC3, 0xC8, 0xFF, 0x85,
 273         0x43, 0x9F, 0xB1, 0x9B, 0x72, 0x88, 0xDD, 0xA4, 0x0D, 0xFC, 0xC6, 0xB5, 0x74, 0x67, 0x29, 0xF5
 274 };
 275 */
 276
 277 void test_square_simple(void){
 278         bigint_t a, c;
 279
 280         uint8_t a_b[11] = {0xe6, 0x70, 0x7d, 0x43, 0x74, 0x07, 0x20, 0x22, 0x6a, 0xb8, 0xf4};
 281         uint8_t c_b[22];
 282         a.wordv=a_b;
 283         c.wordv=c_b;
 284         a.length_B = 11;
 285         a.info=0x00;
 286         bigint_adjust(&a);
 287         bigint_square(&c, &a);
 288         cli_putstr_P(PSTR("\r\n test: "));
 289         bigint_print_hex(&a);
 290         cli_putstr_P(PSTR("**2 = "));
 291         bigint_print_hex(&c);
 292 }
 293
 294 // [fail (c)]:  A862 % 2752 = 0D1A ; should a862 % 2752 = b1a
 295 void test_reduce_simple(void){
 296         bigint_t a, b, c;
 297
 298         uint8_t a_b[2] = {0x62, 0xA8};
 299         uint8_t b_b[2] = {0x52, 0x27};
 300         uint8_t c_b[2];
 301         a.wordv=a_b;
 302         a.length_B = 2;
 303         a.info=0x00;
 304         bigint_adjust(&a);
 305         b.wordv=b_b;
 306         b.length_B = 2;
 307         b.info=0x00;
 308         bigint_adjust(&b);
 309         c.wordv = c_b;
 310         bigint_copy(&c, &a);
 311         bigint_reduce(&c, &b);
 312         cli_putstr_P(PSTR("\r\n test: "));
 313         bigint_print_hex(&a);
 314         cli_putstr_P(PSTR(" % "));
 315         bigint_print_hex(&b);
 316         cli_putstr_P(PSTR(" = "));
 317         bigint_print_hex(&c);
 318 }
 319
 320
 321 void testrun_performance_bigint(void){
 322
 323 }
 324 /*****************************************************************************
 325  *  main                                                                                                                                         *
 326  *****************************************************************************/
 327
 328 const char echo_test_str[]        PROGMEM = "echo-test";
 329 const char add_test_str[]         PROGMEM = "add-test";
 330 const char mul_test_str[]         PROGMEM = "mul-test";
 331 const char square_test_str[]      PROGMEM = "square-test";
 332 const char reduce_test_str[]      PROGMEM = "reduce-test";
 333 const char quick_test_str[]       PROGMEM = "quick-test";
 334 const char performance_str[]      PROGMEM = "performance";
 335 const char echo_str[]             PROGMEM = "echo";
 336
 337 cmdlist_entry_t cmdlist[] PROGMEM = {
 338         { add_test_str,         NULL, test_add_bigint               },
 339         { mul_test_str,         NULL, test_mul_bigint               },
 340         { square_test_str,      NULL, test_square_bigint            },
 341         { reduce_test_str,      NULL, test_reduce_bigint            },
 342         { quick_test_str,       NULL, test_reduce_simple            },
 343         { echo_test_str,        NULL, test_echo_bigint              },
 344         { performance_str,      NULL, testrun_performance_bigint    },
 345         { echo_str,         (void*)1, (void_fpt)echo_ctrl           },
 346         { NULL,                 NULL, NULL                          }
 347 };
 348
 349 int main (void){
 350         DEBUG_INIT();
 351
 352         cli_rx = (cli_rx_fpt)uart0_getc;
 353         cli_tx = (cli_tx_fpt)uart0_putc;
 354         for(;;){
 355                 cli_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
 356                 cli_putstr(algo_name);
 357                 cli_putstr_P(PSTR(")\r\nloaded and running\r\n"));
 358                 cmd_interface(cmdlist);
 359         }
 360 }