test_src/main-rsa-test.c

   1 /* main-dsa-test.c */
   2 /*
   3     This file is part of the ARM-Crypto-Lib.
   4     Copyright (C) 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  * DSA test-suit
  21  *
  22 */
  23 #include "main-test-common.h"
  24
  25 #include "noekeon.h"
  26 #include "noekeon_prng.h"
  27 #include "bigint.h"
  28 #include "bigint_io.h"
  29 #include "random_dummy.h"
  30 #include "rsa_basic.h"
  31 #include "rsa_pkcs15.h"
  32
  33 #include "performance_test.h"
  34
  35 const char* algo_name = "RSA";
  36
  37 /*****************************************************************************
  38  *  additional validation-functions                                                                                      *
  39  *****************************************************************************/
  40
  41 const uint8_t modulus[] = {
  42         0xa8, 0xb3, 0xb2, 0x84, 0xaf, 0x8e, 0xb5, 0x0b, 0x38, 0x70, 0x34, 0xa8, 0x60, 0xf1, 0x46, 0xc4,
  43         0x91, 0x9f, 0x31, 0x87, 0x63, 0xcd, 0x6c, 0x55, 0x98, 0xc8, 0xae, 0x48, 0x11, 0xa1, 0xe0, 0xab,
  44         0xc4, 0xc7, 0xe0, 0xb0, 0x82, 0xd6, 0x93, 0xa5, 0xe7, 0xfc, 0xed, 0x67, 0x5c, 0xf4, 0x66, 0x85,
  45         0x12, 0x77, 0x2c, 0x0c, 0xbc, 0x64, 0xa7, 0x42, 0xc6, 0xc6, 0x30, 0xf5, 0x33, 0xc8, 0xcc, 0x72,
  46         0xf6, 0x2a, 0xe8, 0x33, 0xc4, 0x0b, 0xf2, 0x58, 0x42, 0xe9, 0x84, 0xbb, 0x78, 0xbd, 0xbf, 0x97,
  47         0xc0, 0x10, 0x7d, 0x55, 0xbd, 0xb6, 0x62, 0xf5, 0xc4, 0xe0, 0xfa, 0xb9, 0x84, 0x5c, 0xb5, 0x14,
  48         0x8e, 0xf7, 0x39, 0x2d, 0xd3, 0xaa, 0xff, 0x93, 0xae, 0x1e, 0x6b, 0x66, 0x7b, 0xb3, 0xd4, 0x24,
  49         0x76, 0x16, 0xd4, 0xf5, 0xba, 0x10, 0xd4, 0xcf, 0xd2, 0x26, 0xde, 0x88, 0xd3, 0x9f, 0x16, 0xfb
  50 };
  51
  52 const uint8_t public_exponent[] = {
  53         0x00, 0x01, 0x00, 0x01
  54 };
  55
  56 const uint8_t private_exponent[] = {
  57         0x53, 0x33, 0x9c, 0xfd, 0xb7, 0x9f, 0xc8, 0x46, 0x6a, 0x65, 0x5c, 0x73, 0x16, 0xac, 0xa8, 0x5c,
  58         0x55, 0xfd, 0x8f, 0x6d, 0xd8, 0x98, 0xfd, 0xaf, 0x11, 0x95, 0x17, 0xef, 0x4f, 0x52, 0xe8, 0xfd,
  59         0x8e, 0x25, 0x8d, 0xf9, 0x3f, 0xee, 0x18, 0x0f, 0xa0, 0xe4, 0xab, 0x29, 0x69, 0x3c, 0xd8, 0x3b,
  60         0x15, 0x2a, 0x55, 0x3d, 0x4a, 0xc4, 0xd1, 0x81, 0x2b, 0x8b, 0x9f, 0xa5, 0xaf, 0x0e, 0x7f, 0x55,
  61         0xfe, 0x73, 0x04, 0xdf, 0x41, 0x57, 0x09, 0x26, 0xf3, 0x31, 0x1f, 0x15, 0xc4, 0xd6, 0x5a, 0x73,
  62         0x2c, 0x48, 0x31, 0x16, 0xee, 0x3d, 0x3d, 0x2d, 0x0a, 0xf3, 0x54, 0x9a, 0xd9, 0xbf, 0x7c, 0xbf,
  63         0xb7, 0x8a, 0xd8, 0x84, 0xf8, 0x4d, 0x5b, 0xeb, 0x04, 0x72, 0x4d, 0xc7, 0x36, 0x9b, 0x31, 0xde,
  64         0xf3, 0x7d, 0x0c, 0xf5, 0x39, 0xe9, 0xcf, 0xcd, 0xd3, 0xde, 0x65, 0x37, 0x29, 0xea, 0xd5, 0xd1
  65 };
  66
  67 const uint8_t p[] = {
  68         0xd3, 0x27, 0x37, 0xe7, 0x26, 0x7f, 0xfe, 0x13, 0x41, 0xb2, 0xd5, 0xc0, 0xd1, 0x50, 0xa8, 0x1b,
  69         0x58, 0x6f, 0xb3, 0x13, 0x2b, 0xed, 0x2f, 0x8d, 0x52, 0x62, 0x86, 0x4a, 0x9c, 0xb9, 0xf3, 0x0a,
  70         0xf3, 0x8b, 0xe4, 0x48, 0x59, 0x8d, 0x41, 0x3a, 0x17, 0x2e, 0xfb, 0x80, 0x2c, 0x21, 0xac, 0xf1,
  71         0xc1, 0x1c, 0x52, 0x0c, 0x2f, 0x26, 0xa4, 0x71, 0xdc, 0xad, 0x21, 0x2e, 0xac, 0x7c, 0xa3, 0x9d
  72 };
  73
  74 const uint8_t q[] = {
  75         0xcc, 0x88, 0x53, 0xd1, 0xd5, 0x4d, 0xa6, 0x30, 0xfa, 0xc0, 0x04, 0xf4, 0x71, 0xf2, 0x81, 0xc7,
  76         0xb8, 0x98, 0x2d, 0x82, 0x24, 0xa4, 0x90, 0xed, 0xbe, 0xb3, 0x3d, 0x3e, 0x3d, 0x5c, 0xc9, 0x3c,
  77         0x47, 0x65, 0x70, 0x3d, 0x1d, 0xd7, 0x91, 0x64, 0x2f, 0x1f, 0x11, 0x6a, 0x0d, 0xd8, 0x52, 0xbe,
  78         0x24, 0x19, 0xb2, 0xaf, 0x72, 0xbf, 0xe9, 0xa0, 0x30, 0xe8, 0x60, 0xb0, 0x28, 0x8b, 0x5d, 0x77
  79 };
  80
  81 const uint8_t dp[] = {
  82         0x0e, 0x12, 0xbf, 0x17, 0x18, 0xe9, 0xce, 0xf5, 0x59, 0x9b, 0xa1, 0xc3, 0x88, 0x2f, 0xe8, 0x04,
  83         0x6a, 0x90, 0x87, 0x4e, 0xef, 0xce, 0x8f, 0x2c, 0xcc, 0x20, 0xe4, 0xf2, 0x74, 0x1f, 0xb0, 0xa3,
  84         0x3a, 0x38, 0x48, 0xae, 0xc9, 0xc9, 0x30, 0x5f, 0xbe, 0xcb, 0xd2, 0xd7, 0x68, 0x19, 0x96, 0x7d,
  85         0x46, 0x71, 0xac, 0xc6, 0x43, 0x1e, 0x40, 0x37, 0x96, 0x8d, 0xb3, 0x78, 0x78, 0xe6, 0x95, 0xc1
  86 };
  87
  88 const uint8_t dq[] = {
  89         0x95, 0x29, 0x7b, 0x0f, 0x95, 0xa2, 0xfa, 0x67, 0xd0, 0x07, 0x07, 0xd6, 0x09, 0xdf, 0xd4, 0xfc,
  90         0x05, 0xc8, 0x9d, 0xaf, 0xc2, 0xef, 0x6d, 0x6e, 0xa5, 0x5b, 0xec, 0x77, 0x1e, 0xa3, 0x33, 0x73,
  91         0x4d, 0x92, 0x51, 0xe7, 0x90, 0x82, 0xec, 0xda, 0x86, 0x6e, 0xfe, 0xf1, 0x3c, 0x45, 0x9e, 0x1a,
  92         0x63, 0x13, 0x86, 0xb7, 0xe3, 0x54, 0xc8, 0x99, 0xf5, 0xf1, 0x12, 0xca, 0x85, 0xd7, 0x15, 0x83
  93 };
  94
  95 const uint8_t qinv[] = {
  96         0x4f, 0x45, 0x6c, 0x50, 0x24, 0x93, 0xbd, 0xc0, 0xed, 0x2a, 0xb7, 0x56, 0xa3, 0xa6, 0xed, 0x4d,
  97         0x67, 0x35, 0x2a, 0x69, 0x7d, 0x42, 0x16, 0xe9, 0x32, 0x12, 0xb1, 0x27, 0xa6, 0x3d, 0x54, 0x11,
  98         0xce, 0x6f, 0xa9, 0x8d, 0x5d, 0xbe, 0xfd, 0x73, 0x26, 0x3e, 0x37, 0x28, 0x14, 0x27, 0x43, 0x81,
  99         0x81, 0x66, 0xed, 0x7d, 0xd6, 0x36, 0x87, 0xdd, 0x2a, 0x8c, 0xa1, 0xd2, 0xf4, 0xfb, 0xd8, 0xe1,
 100 };
 101
 102 /*
 103 # PKCS#1 v1.5 encryption of 20 random messages with random seeds
 104 # ---------------------------------------------------------------------------
 105 */
 106
 107 const uint8_t message[] = {
 108         0x66, 0x28, 0x19, 0x4e, 0x12, 0x07, 0x3d, 0xb0, 0x3b, 0xa9, 0x4c, 0xda, 0x9e, 0xf9, 0x53, 0x23,
 109         0x97, 0xd5, 0x0d, 0xba, 0x79, 0xb9, 0x87, 0x00, 0x4a, 0xfe, 0xfe, 0x34
 110 };
 111
 112 const uint8_t seed[] = {
 113         0x01, 0x73, 0x41, 0xae, 0x38, 0x75, 0xd5, 0xf8, 0x71, 0x01, 0xf8, 0xcc, 0x4f, 0xa9, 0xb9, 0xbc,
 114         0x15, 0x6b, 0xb0, 0x46, 0x28, 0xfc, 0xcd, 0xb2, 0xf4, 0xf1, 0x1e, 0x90, 0x5b, 0xd3, 0xa1, 0x55,
 115         0xd3, 0x76, 0xf5, 0x93, 0xbd, 0x73, 0x04, 0x21, 0x08, 0x74, 0xeb, 0xa0, 0x8a, 0x5e, 0x22, 0xbc,
 116         0xcc, 0xb4, 0xc9, 0xd3, 0x88, 0x2a, 0x93, 0xa5, 0x4d, 0xb0, 0x22, 0xf5, 0x03, 0xd1, 0x63, 0x38,
 117         0xb6, 0xb7, 0xce, 0x16, 0xdc, 0x7f, 0x4b, 0xbf, 0x9a, 0x96, 0xb5, 0x97, 0x72, 0xd6, 0x60, 0x6e,
 118         0x97, 0x47, 0xc7, 0x64, 0x9b, 0xf9, 0xe0, 0x83, 0xdb, 0x98, 0x18, 0x84, 0xa9, 0x54, 0xab, 0x3c,
 119         0x6f
 120 };
 121
 122 const uint8_t encrypted[] = {
 123         0x50, 0xb4, 0xc1, 0x41, 0x36, 0xbd, 0x19, 0x8c, 0x2f, 0x3c, 0x3e, 0xd2, 0x43, 0xfc, 0xe0, 0x36,
 124         0xe1, 0x68, 0xd5, 0x65, 0x17, 0x98, 0x4a, 0x26, 0x3c, 0xd6, 0x64, 0x92, 0xb8, 0x08, 0x04, 0xf1,
 125         0x69, 0xd2, 0x10, 0xf2, 0xb9, 0xbd, 0xfb, 0x48, 0xb1, 0x2f, 0x9e, 0xa0, 0x50, 0x09, 0xc7, 0x7d,
 126         0xa2, 0x57, 0xcc, 0x60, 0x0c, 0xce, 0xfe, 0x3a, 0x62, 0x83, 0x78, 0x9d, 0x8e, 0xa0, 0xe6, 0x07,
 127         0xac, 0x58, 0xe2, 0x69, 0x0e, 0xc4, 0xeb, 0xc1, 0x01, 0x46, 0xe8, 0xcb, 0xaa, 0x5e, 0xd4, 0xd5,
 128         0xcc, 0xe6, 0xfe, 0x7b, 0x0f, 0xf9, 0xef, 0xc1, 0xea, 0xbb, 0x56, 0x4d, 0xbf, 0x49, 0x82, 0x85,
 129         0xf4, 0x49, 0xee, 0x61, 0xdd, 0x7b, 0x42, 0xee, 0x5b, 0x58, 0x92, 0xcb, 0x90, 0x60, 0x1f, 0x30,
 130         0xcd, 0xa0, 0x7b, 0xf2, 0x64, 0x89, 0x31, 0x0b, 0xcd, 0x23, 0xb5, 0x28, 0xce, 0xab, 0x3c, 0x31
 131 };
 132
 133 const uint8_t message1[] = {
 134         0x75, 0x0c, 0x40, 0x47, 0xf5, 0x47, 0xe8, 0xe4, 0x14, 0x11, 0x85, 0x65, 0x23, 0x29, 0x8a, 0xc9,
 135         0xba, 0xe2, 0x45, 0xef, 0xaf, 0x13, 0x97, 0xfb, 0xe5, 0x6f, 0x9d, 0xd5,
 136 };
 137
 138 const uint8_t seed1[] = {
 139         0xac, 0x47, 0x28, 0xa8, 0x42, 0x8c, 0x1e, 0x52, 0x24, 0x71, 0xa8, 0xdf, 0x73, 0x5a, 0x8e, 0x92,
 140         0x92, 0xaf, 0x0d, 0x55, 0xbc, 0xb7, 0x3a, 0x12, 0xac, 0x32, 0xc2, 0x64, 0xf3, 0x88, 0x1c, 0x7c,
 141         0x8a, 0x71, 0x0f, 0x70, 0xfe, 0xb1, 0x04, 0x85, 0xc8, 0x37, 0x0f, 0x78, 0x1f, 0xff, 0xd0, 0x21,
 142         0x81, 0x6f, 0x05, 0x87, 0x39, 0x76, 0x6d, 0xa0, 0xa9, 0xc9, 0xdb, 0x0e, 0xae, 0x7e, 0x9a, 0x25,
 143         0xb6, 0xc4, 0x33, 0x18, 0xd0, 0xca, 0xac, 0x23, 0x65, 0x22, 0xca, 0x31, 0x0f, 0x17, 0xfc, 0x52,
 144         0xad, 0x42, 0x29, 0xc8, 0x3a, 0x24, 0xe9, 0xe5, 0x45, 0xeb, 0x35, 0xe9, 0x82, 0x6d, 0x55, 0x9f,
 145         0x57
 146 };
 147
 148 const uint8_t message2[] = {
 149 0xd9, 0x4a, 0xe0, 0x83, 0x2e, 0x64, 0x45, 0xce, 0x42, 0x33, 0x1c, 0xb0, 0x6d, 0x53, 0x1a, 0x82,
 150 0xb1, 0xdb, 0x4b, 0xaa, 0xd3, 0x0f, 0x74, 0x6d, 0xc9, 0x16, 0xdf, 0x24, 0xd4, 0xe3, 0xc2, 0x45,
 151 0x1f, 0xff, 0x59, 0xa6, 0x42, 0x3e, 0xb0, 0xe1, 0xd0, 0x2d, 0x4f, 0xe6, 0x46, 0xcf, 0x69, 0x9d,
 152 0xfd, 0x81, 0x8c, 0x6e, 0x97, 0xb0, 0x51
 153 };
 154
 155 const uint8_t seed2[] = {
 156 0xdd, 0x2d, 0x60, 0xa5, 0xe0, 0x08, 0xeb, 0xe1, 0xd0, 0xbe, 0x6f, 0x60, 0xdb, 0xc4, 0x3f, 0x29,
 157 0x62, 0xef, 0x50, 0xbf, 0xde, 0x54, 0x2b, 0xbb, 0xe9, 0x8f, 0xed, 0xd1, 0xfe, 0xac, 0x05, 0x7e,
 158 0x77, 0x1c, 0xf1, 0x5f, 0xc6, 0x32, 0xc8, 0xdb, 0x27, 0x2e, 0x28, 0xd2, 0x9b, 0x57, 0x93, 0xea,
 159 0x6a, 0xb8, 0x06, 0x21, 0x8c, 0x53, 0x82, 0x39, 0xb9, 0x3a, 0x93, 0x5e, 0x65, 0xd2, 0x44, 0x16,
 160 0xec, 0x6c, 0x6e, 0x99, 0xae, 0x04
 161 };
 162
 163 const uint8_t message3[] = {
 164 0x52, 0xe6, 0x50, 0xd9, 0x8e, 0x7f, 0x2a, 0x04, 0x8b, 0x4f, 0x86, 0x85, 0x21, 0x53, 0xb9, 0x7e,
 165 0x01, 0xdd, 0x31, 0x6f, 0x34, 0x6a, 0x19, 0xf6, 0x7a, 0x85
 166 };
 167
 168 const uint8_t seed3[] = {
 169 0x26, 0x29, 0xa7, 0xaa, 0xc0, 0xc3, 0x90, 0x5e, 0x83, 0x1e, 0xb6, 0x02, 0x38, 0x8c, 0x54, 0x5a,
 170 0xf5, 0x54, 0xb9, 0x6b, 0x2a, 0xe5, 0x15, 0x32, 0xe9, 0xcc, 0xdb, 0x89, 0x72, 0xef, 0x30, 0xb6,
 171 0x4a, 0x2f, 0x98, 0xc6, 0x95, 0x29, 0x7a, 0x01, 0xc5, 0x81, 0x2a, 0x2c, 0x40, 0x15, 0x82, 0xf3,
 172 0x7b, 0x14, 0x4a, 0x3e, 0x90, 0xe5, 0x9d, 0x81, 0xb6, 0x90, 0x39, 0xc6, 0x4b, 0x84, 0x4b, 0x02,
 173 0x8c, 0x10, 0x5c, 0x8e, 0x68, 0x36, 0x15, 0xaf, 0xb6, 0x58, 0xb6, 0xc4, 0xd9, 0xf3, 0x82, 0x38,
 174 0xa7, 0x63, 0x01, 0xbb, 0x14, 0x44, 0x91, 0x13, 0xb6, 0x9d, 0xe1, 0x26, 0x04, 0x5e, 0x26, 0xf1,
 175 0x3e, 0xe6, 0xd7
 176 };
 177
 178 rsa_publickey_t pub_key;
 179 rsa_privatekey_t priv_key;
 180
 181 void load_priv_conventional(void){
 182         bigint_t *epriv;
 183         epriv = malloc(sizeof(bigint_t));
 184         if(!epriv){
 185                 cli_putstr("\r\nERROR: OOM!");
 186                 return;
 187         }
 188         epriv->length_B = (sizeof(private_exponent) + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
 189         epriv->wordv =  malloc(epriv->length_B * sizeof(bigint_word_t));
 190         if(!epriv->wordv){
 191                 cli_putstr("\r\nERROR: OOM!");
 192                 return;
 193         }
 194         memcpy(epriv->wordv, private_exponent, sizeof(private_exponent));
 195         priv_key.components = malloc(sizeof(bigint_t*));
 196         priv_key.components[0] = epriv;
 197         priv_key.n = 1;
 198         bigint_changeendianess(epriv);
 199         bigint_adjust(epriv);
 200 }
 201
 202
 203 void load_priv_crt_mono(void){
 204         bigint_t **v;
 205         const uint8_t *bv[5] = {p,q,dp,dq,qinv};
 206         uint16_t sv[5] = {sizeof(p), sizeof(q), sizeof(dp), sizeof(dq), sizeof(qinv)};
 207         uint8_t i;
 208         v = malloc(5 * sizeof(bigint_t));
 209         if(!v){
 210                 cli_putstr("\r\nERROR: OOM!");
 211                 return;
 212         }
 213         priv_key.components = malloc(5*sizeof(bigint_t*));
 214         if(!priv_key.components){
 215                 cli_putstr("\r\nERROR: OOM!");
 216                 return;
 217         }
 218         priv_key.n = 5;
 219         for(i=0; i<5; ++i){
 220                 v[i] = malloc(sizeof(bigint_t));
 221                 v[i]->info = 0;
 222                 v[i]->length_B = (sv[i] + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
 223                 v[i]->wordv = calloc(v[i]->length_B , sizeof(bigint_word_t));
 224                 if(!v[i]->wordv){
 225                         cli_putstr("\r\nERROR: OOM!");
 226                         return;
 227                 }
 228                 memcpy(v[i]->wordv, bv[i], sv[i]);
 229                 bigint_changeendianess(v[i]);
 230                 bigint_adjust(v[i]);
 231                 priv_key.components[i] = v[i];
 232         }
 233 }
 234
 235
 236 void load_fix_rsa(void){
 237         bigint_t *m, *epub;
 238         m = malloc(sizeof(bigint_t));
 239         epub = malloc(sizeof(bigint_t));
 240         if(!m || !epub){
 241                 cli_putstr("\r\nOOM!\r\n");
 242                 return;
 243         }
 244
 245         m->length_B = (sizeof(modulus) + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
 246         epub->length_B = (sizeof(public_exponent) + sizeof(bigint_word_t) - 1) / sizeof(bigint_word_t);
 247
 248         m->wordv = malloc(m->length_B * sizeof(bigint_word_t));
 249         epub->wordv = malloc(epub->length_B * sizeof(bigint_word_t));
 250
 251         if(!m->wordv || !epub->wordv){
 252                 cli_putstr("\r\nOOM!\r\n");
 253                 return;
 254         }
 255
 256         memcpy(m->wordv, modulus, sizeof(modulus));
 257         memcpy(epub->wordv, public_exponent, sizeof(public_exponent));
 258
 259         pub_key.modulus = priv_key.modulus = m;
 260         pub_key.exponent = epub;
 261
 262         bigint_changeendianess(m);
 263         bigint_adjust(m);
 264         bigint_changeendianess(epub);
 265         bigint_adjust(epub);
 266
 267 //      load_priv_conventional();
 268         load_priv_crt_mono();
 269 }
 270
 271
 272 #define MSG message3
 273 #define SEED seed3
 274
 275 void quick_test(void){
 276         uint8_t *ciphertext, *plaintext, rc;
 277         uint16_t clen, plen;
 278         ciphertext = malloc(clen = pub_key.modulus->length_B * sizeof(bigint_word_t));
 279         plaintext = malloc(pub_key.modulus->length_B * sizeof(bigint_word_t));
 280 //      memcpy(ciphertext, message1, sizeof(message1));
 281         cli_putstr("\r\nplaintext:");
 282         cli_hexdump_block(MSG, sizeof(MSG), 4, 8);
 283         rc = rsa_encrypt_pkcs15(ciphertext, &clen, MSG, sizeof(MSG), &pub_key, SEED);
 284         if(rc){
 285                 cli_putstr("\r\nERROR: rsa_encrypt_pkcs15 returned: ");
 286                 cli_hexdump_byte(rc);
 287                 return;
 288         }
 289         cli_putstr("\r\n\r\nciphertext:");
 290         cli_hexdump_block(ciphertext, clen, 4, 8);
 291         uart_flush(0);
 292         rc = rsa_decrypt_pkcs15(plaintext, &plen, ciphertext, clen, &priv_key, NULL);
 293         if(rc){
 294                 cli_putstr("\r\nERROR: rsa_encrypt_pkcs15 returned: ");
 295                 cli_hexdump_byte(rc);
 296                 return;
 297         }
 298         cli_putstr("\r\n\r\nplaintext:");
 299         cli_hexdump_block(plaintext, plen, 4, 8);
 300         free(ciphertext);
 301         free(plaintext);
 302 }
 303
 304 void reset_prng(void){
 305         uint8_t buf[16];
 306         memset(buf, 0, 16);
 307         random_seed(buf);
 308         cli_putstr("\r\nPRNG reset");
 309 }
 310
 311 void rsa_init(void){
 312         load_fix_rsa();
 313         prng_get_byte = random8;
 314 }
 315
 316 /*****************************************************************************
 317  *  main                                                                                                                                         *
 318  *****************************************************************************/
 319
 320 const char echo_test_str[]     = "echo-test";
 321 const char reset_prng_str[]    = "reset-prng";
 322 const char quick_test_str[]    = "quick-test";
 323 const char performance_str[]   = "performance";
 324 const char echo_str[]          = "echo";
 325
 326 cmdlist_entry_t cmdlist[] = {
 327         { reset_prng_str,       NULL, reset_prng                    },
 328         { quick_test_str,       NULL, quick_test                    },
 329 //      { performance_str,      NULL, testrun_performance_bigint    },
 330         { echo_str,         (void*)1, (void_fpt)echo_ctrl           },
 331         { NULL,                 NULL, NULL                          }
 332 };
 333
 334 void dump_sp(void){
 335         uint8_t x;
 336         uint8_t *xa = &x;
 337         cli_putstr("\r\nstack pointer: ~");
 338         cli_hexdump_rev(&xa, 4);
 339 }
 340
 341 int main (void){
 342         main_setup();
 343
 344         for(;;){
 345                 welcome_msg(algo_name);
 346                 rsa_init();
 347                 cmd_interface(cmdlist);
 348         }
 349 }