raw
ch2_truerandom          1 #include "smg_rsa.h"
eucrypt_ch3_mille... 2 #include "mpi.h"
ch2_truerandom 3
ch2_truerandom 4 #include <stdlib.h>
eucrypt_ch3_mille... 5 #include <unistd.h>
ch2_truerandom 6 #include <time.h>
eucrypt_ch4_rpng 7 #include <stdio.h>
ch2_truerandom 8
ch2_truerandom 9 void err(char *msg)
ch2_truerandom 10 {
ch2_truerandom 11 fprintf(stderr, "%s\n", msg);
ch2_truerandom 12 exit(1);
ch2_truerandom 13 }
ch2_truerandom 14
ch2_truerandom 15 void time_entropy_source(int nruns, int noctets) {
ch2_truerandom 16 unsigned char buffer[noctets];
ch2_truerandom 17 int read, i;
ch2_truerandom 18 struct timespec tstart, tend;
ch2_truerandom 19 long int diff;
ch2_truerandom 20
ch2_truerandom 21 clock_gettime(CLOCK_MONOTONIC, &tstart);
ch2_truerandom 22 for (i=0; i<nruns; i++) {
ch2_truerandom 23 read = get_random_octets(noctets,buffer);
ch2_truerandom 24 if (read != noctets)
ch2_truerandom 25 err("Failed reading from entropy source!");
ch2_truerandom 26 }
ch2_truerandom 27 clock_gettime(CLOCK_MONOTONIC, &tend);
ch2_truerandom 28
ch2_truerandom 29 diff = tend.tv_sec-tstart.tv_sec;
ch2_truerandom 30 double kbps = (nruns*noctets) / (diff*1000.0);
ch2_truerandom 31 printf("ENTROPY source timing: %d kB in %ld seconds, at an average speed of %f kB/s over %d runs of %d octets each\n", nruns*noctets, diff, kbps, nruns, noctets);
ch2_truerandom 32 }
ch2_truerandom 33
eucrypt_ch4_rpng 34 void test_entropy_output(unsigned int noctets, char * filename) {
eucrypt_ch4_rpng 35 FILE * out;
eucrypt_ch4_rpng 36 int source;
eucrypt_ch4_rpng 37 unsigned int nread, total_read, to_read;
eucrypt_ch4_rpng 38 const int buffer_length = 1000;
eucrypt_ch4_rpng 39 unsigned char buffer[buffer_length];
eucrypt_ch4_rpng 40
eucrypt_ch4_rpng 41 source = open_entropy_source(ENTROPY_SOURCE);
eucrypt_ch4_rpng 42 if (source <= 0)
eucrypt_ch4_rpng 43 err("unable to access entropy source!");
eucrypt_ch4_rpng 44
eucrypt_ch4_rpng 45 out = fopen(filename, "wb");
eucrypt_ch4_rpng 46 if ( !out )
eucrypt_ch4_rpng 47 err("unable to open output file for test_entropy_output!");
eucrypt_ch4_rpng 48
eucrypt_ch4_rpng 49 printf("TEST_ENTROPY_SOURCE: reading %u octets from %s ", noctets, ENTROPY_SOURCE);
eucrypt_ch4_rpng 50 total_read = 0;
eucrypt_ch4_rpng 51 while (total_read < noctets) {
eucrypt_ch4_rpng 52 to_read = noctets - total_read;
eucrypt_ch4_rpng 53 if (to_read > buffer_length)
eucrypt_ch4_rpng 54 to_read = buffer_length;
eucrypt_ch4_rpng 55
eucrypt_ch4_rpng 56 nread = get_random_octets_from(to_read, buffer, source);
eucrypt_ch4_rpng 57 if (nread > 0) {
eucrypt_ch4_rpng 58 total_read = total_read + nread;
eucrypt_ch4_rpng 59 fwrite(buffer, 1, nread, out);
eucrypt_ch4_rpng 60 fflush(out);
eucrypt_ch4_rpng 61 printf(".");
eucrypt_ch4_rpng 62 fflush(stdout);
eucrypt_ch4_rpng 63 }
eucrypt_ch4_rpng 64 }
eucrypt_ch4_rpng 65 printf("done.\n");
eucrypt_ch4_rpng 66
eucrypt_ch4_rpng 67 fclose(out);
eucrypt_ch4_rpng 68 close(source);
eucrypt_ch4_rpng 69 }
eucrypt_ch4_rpng 70
eucrypt_ch3_mille... 71 void test_is_composite(int nruns, char *hex_number, int expected) {
eucrypt_ch3_mille... 72 int i;
eucrypt_ch3_mille... 73 int output;
eucrypt_ch3_mille... 74 int count_ok = 0;
eucrypt_ch3_mille... 75 int source = open_entropy_source(ENTROPY_SOURCE);
eucrypt_ch3_mille... 76 MPI p = mpi_alloc(0);
eucrypt_ch3_mille... 77
eucrypt_ch3_mille... 78 mpi_fromstr(p, hex_number);
eucrypt_ch3_mille... 79 printf("TEST is_composite on MPI(hex) ");
eucrypt_ch3_mille... 80 mpi_print(stdout, p, 1);
eucrypt_ch3_mille... 81 for (i=0; i < nruns; i++) {
eucrypt_ch3_mille... 82 printf(".");
eucrypt_ch3_mille... 83 fflush(stdout);
eucrypt_ch3_mille... 84 output = is_composite(p, M_R_ITERATIONS, source);
eucrypt_ch3_mille... 85 if (output == expected)
eucrypt_ch3_mille... 86 count_ok = count_ok + 1;
eucrypt_ch3_mille... 87 }
eucrypt_ch3_mille... 88 printf("done, with %d out of %d correct runs for expected=%d: %s\n", count_ok, nruns, expected, count_ok==nruns? "PASS":"FAIL");
eucrypt_ch3_mille... 89 mpi_free(p);
eucrypt_ch3_mille... 90 close(source);
eucrypt_ch3_mille... 91 }
ch2_truerandom 92
eucrypt_ch4_rpng 93 void time_mr(int nruns) {
eucrypt_ch4_rpng 94 struct timespec tstart, tend;
eucrypt_ch4_rpng 95 long int diff;
eucrypt_ch4_rpng 96 int i;
eucrypt_ch4_rpng 97 MPI prime;
eucrypt_ch4_rpng 98 unsigned int noctets = KEY_LENGTH_OCTETS / 2;
eucrypt_ch4_rpng 99 unsigned int nlimbs = mpi_nlimb_hint_from_nbytes(noctets);
eucrypt_ch4_rpng 100
eucrypt_ch4_rpng 101 int entropy_source = open_entropy_source(ENTROPY_SOURCE);
eucrypt_ch4_rpng 102 if (entropy_source <= 0)
eucrypt_ch4_rpng 103 err("can't open entropy source!");
eucrypt_ch4_rpng 104
eucrypt_ch4_rpng 105 /* first generate a prime of half key length, to make sure M-R will run max number of iterations */
eucrypt_ch4_rpng 106 printf("Generating a prime number of %d octets length for M-R timing test\n", noctets);
eucrypt_ch4_rpng 107 prime = mpi_alloc(nlimbs);
eucrypt_ch4_rpng 108 gen_random_prime(noctets, prime);
eucrypt_ch4_rpng 109
eucrypt_ch4_rpng 110 printf("Running timing test for Miller-Rabin with %d repetitions and %d witnesses on prime number ", nruns, M_R_ITERATIONS);
eucrypt_ch4_rpng 111 mpi_print(stdout, prime, 1);
eucrypt_ch4_rpng 112 printf("\n");
eucrypt_ch4_rpng 113 /* now do the actual runs and time it all */
eucrypt_ch4_rpng 114 clock_gettime(CLOCK_MONOTONIC, &tstart);
eucrypt_ch4_rpng 115 for (i=0; i<nruns; i++) {
eucrypt_ch4_rpng 116 if (is_composite(prime, M_R_ITERATIONS, entropy_source))
eucrypt_ch4_rpng 117 printf("FAIL");
eucrypt_ch4_rpng 118 else printf(".");
eucrypt_ch4_rpng 119 fflush(stdout);
eucrypt_ch4_rpng 120 }
eucrypt_ch4_rpng 121 clock_gettime(CLOCK_MONOTONIC, &tend);
eucrypt_ch4_rpng 122
eucrypt_ch4_rpng 123 diff = tend.tv_sec-tstart.tv_sec;
eucrypt_ch4_rpng 124 printf("\nTimings on prime number %d octets long, %d runs of MR with %d iterations (witnesses checked) each\n", \
eucrypt_ch4_rpng 125 noctets, nruns, M_R_ITERATIONS);
eucrypt_ch4_rpng 126 printf("Total time: %ld seconds\nTime per MR run: %f seconds\nTime per MR iteration: %f seconds\n",\
eucrypt_ch4_rpng 127 diff, diff / (1.0*nruns), diff / (1.0*nruns * M_R_ITERATIONS));
eucrypt_ch4_rpng 128
eucrypt_ch4_rpng 129 mpi_free(prime);
eucrypt_ch4_rpng 130 close(entropy_source);
eucrypt_ch4_rpng 131 }
eucrypt_ch4_rpng 132
eucrypt_ch4_rpng 133 void test_rpng(int nruns) {
eucrypt_ch4_rpng 134 unsigned int noctets = KEY_LENGTH_OCTETS / 2;
eucrypt_ch4_rpng 135 unsigned int nlimbs = mpi_nlimb_hint_from_nbytes(noctets);
eucrypt_ch4_rpng 136 int entropy_source = open_entropy_source(ENTROPY_SOURCE);
eucrypt_ch4_rpng 137 if (entropy_source <= 0)
eucrypt_ch4_rpng 138 err("can't open entropy source!");
eucrypt_ch4_rpng 139
eucrypt_ch4_rpng 140 MPI prime = mpi_alloc(nlimbs);
eucrypt_ch4_rpng 141 int i;
eucrypt_ch4_rpng 142
eucrypt_ch4_rpng 143 printf("TEST: random prime number generator with %d runs\n", nruns);
eucrypt_ch4_rpng 144 for (i = 0;i < nruns; i++) {
eucrypt_ch4_rpng 145 gen_random_prime(noctets, prime);
eucrypt_ch4_rpng 146 printf("Run %d: ", i+1);
eucrypt_ch4_rpng 147 mpi_print(stdout, prime, 1);
eucrypt_ch4_rpng 148 if (is_composite(prime, M_R_ITERATIONS, entropy_source))
eucrypt_ch4_rpng 149 printf(" **FAIL**\n");
eucrypt_ch4_rpng 150 else
eucrypt_ch4_rpng 151 printf(" **PASS**\n");
eucrypt_ch4_rpng 152 }
eucrypt_ch4_rpng 153
eucrypt_ch4_rpng 154 mpi_free(prime);
eucrypt_ch4_rpng 155 close(entropy_source);
eucrypt_ch4_rpng 156 }
eucrypt_ch4_rpng 157
eucrypt_ch4_rpng 158 void time_rpng(int nruns) {
eucrypt_ch4_rpng 159 struct timespec tstart, tend;
eucrypt_ch4_rpng 160 long int diff;
eucrypt_ch4_rpng 161
eucrypt_ch4_rpng 162 unsigned int noctets = KEY_LENGTH_OCTETS / 2;
eucrypt_ch4_rpng 163 unsigned int nlimbs = mpi_nlimb_hint_from_nbytes(noctets);
eucrypt_ch4_rpng 164
eucrypt_ch4_rpng 165 int entropy_source = open_entropy_source(ENTROPY_SOURCE);
eucrypt_ch4_rpng 166 if (entropy_source <= 0)
eucrypt_ch4_rpng 167 err("can't open entropy source!");
eucrypt_ch4_rpng 168
eucrypt_ch4_rpng 169 MPI prime = mpi_alloc(nlimbs);
eucrypt_ch4_rpng 170 int i;
eucrypt_ch4_rpng 171
eucrypt_ch4_rpng 172 printf("TIMING: random prime number generator with %d runs\n", nruns);
eucrypt_ch4_rpng 173 clock_gettime(CLOCK_MONOTONIC, &tstart);
eucrypt_ch4_rpng 174 for (i = 0;i < nruns; i++) {
eucrypt_ch4_rpng 175 gen_random_prime(noctets, prime);
eucrypt_ch4_rpng 176 }
eucrypt_ch4_rpng 177 clock_gettime(CLOCK_MONOTONIC, &tend);
eucrypt_ch4_rpng 178
eucrypt_ch4_rpng 179 diff = tend.tv_sec-tstart.tv_sec;
eucrypt_ch4_rpng 180
eucrypt_ch4_rpng 181 printf("TOTAL: %ld seconds\n", diff);
eucrypt_ch4_rpng 182 printf("Average: %f seconds to generate one random prime of %d octets length\n", diff / (1.0*nruns), noctets);
eucrypt_ch4_rpng 183 mpi_free(prime);
eucrypt_ch4_rpng 184 close(entropy_source);
eucrypt_ch4_rpng 185 }
eucrypt_ch4_rpng 186
eucrypt_ch5_rsa_keys 187 /* Test encryption+decryption on noctets of random data, using sk
eucrypt_ch5_rsa_keys 188 * Output is written to file.
eucrypt_ch5_rsa_keys 189 */
eucrypt_ch5_rsa_keys 190 void test_rsa_keys( RSA_secret_key *sk, unsigned int noctets, FILE *file ) {
eucrypt_ch5_rsa_keys 191 RSA_public_key pk;
eucrypt_ch5_rsa_keys 192 MPI test = mpi_alloc ( mpi_nlimb_hint_from_nbytes (noctets) );
eucrypt_ch5_rsa_keys 193 MPI out1 = mpi_alloc ( mpi_nlimb_hint_from_nbytes (noctets) );
eucrypt_ch5_rsa_keys 194 MPI out2 = mpi_alloc ( mpi_nlimb_hint_from_nbytes (noctets) );
eucrypt_ch5_rsa_keys 195
eucrypt_ch5_rsa_keys 196 pk.n = mpi_copy(sk->n);
eucrypt_ch5_rsa_keys 197 pk.e = mpi_copy(sk->e);
eucrypt_ch5_rsa_keys 198 unsigned char *p;
eucrypt_ch5_rsa_keys 199 p = xmalloc(noctets);
eucrypt_ch5_rsa_keys 200
eucrypt_ch5_rsa_keys 201 fprintf(file, "TEST encrypt/decrypt on %d octets of random data\n", noctets);
eucrypt_ch5_rsa_keys 202 fflush(file);
eucrypt_ch5_rsa_keys 203 if (get_random_octets( noctets, p) == noctets) {
eucrypt_ch5_rsa_keys 204 mpi_set_buffer( test, p, noctets, 0 );
eucrypt_ch5_rsa_keys 205
eucrypt_ch5_rsa_keys 206 fprintf(file, "TEST data:\n");
eucrypt_ch5_rsa_keys 207 mpi_print(file, test, 1);
eucrypt_ch5_rsa_keys 208 fprintf(file, "\n");
eucrypt_ch5_rsa_keys 209 fflush(file);
eucrypt_ch5_rsa_keys 210
eucrypt_ch5_rsa_keys 211 public_rsa( out1, test, &pk );
eucrypt_ch5_rsa_keys 212 secret_rsa( out2, out1, sk );
eucrypt_ch5_rsa_keys 213
eucrypt_ch5_rsa_keys 214 fprintf(file, "ENCRYPTED with PUBLIC key data:\n");
eucrypt_ch5_rsa_keys 215 mpi_print(file, out1, 1);
eucrypt_ch5_rsa_keys 216 fprintf(file, "\n");
eucrypt_ch5_rsa_keys 217 fflush(file);
eucrypt_ch5_rsa_keys 218
eucrypt_ch5_rsa_keys 219 fprintf(file, "DECRYPTED with SECRET key:\n");
eucrypt_ch5_rsa_keys 220 mpi_print(file, out2, 1);
eucrypt_ch5_rsa_keys 221 fprintf(file, "\n");
eucrypt_ch5_rsa_keys 222 fflush(file);
eucrypt_ch5_rsa_keys 223
eucrypt_ch5_rsa_keys 224 if( mpi_cmp( test, out2 ) )
eucrypt_ch5_rsa_keys 225 fprintf(file, "FAILED: RSA operation: public(secret) failed\n");
eucrypt_ch5_rsa_keys 226 else
eucrypt_ch5_rsa_keys 227 fprintf(file, "PASSED: RSA operation: public(secret) passed\n");
eucrypt_ch5_rsa_keys 228 fflush(file);
eucrypt_ch5_rsa_keys 229
eucrypt_ch5_rsa_keys 230 secret_rsa( out1, test, sk );
eucrypt_ch5_rsa_keys 231 public_rsa( out2, out1, &pk );
eucrypt_ch5_rsa_keys 232 if( mpi_cmp( test, out2 ) )
eucrypt_ch5_rsa_keys 233 fprintf(file, "FAILED: RSA operation: secret(public) failed\n");
eucrypt_ch5_rsa_keys 234 else
eucrypt_ch5_rsa_keys 235 fprintf(file, "PASSED: RSA operation: secret(public) passed\n");
eucrypt_ch5_rsa_keys 236 }
eucrypt_ch5_rsa_keys 237 else
eucrypt_ch5_rsa_keys 238 fprintf(file, "FAILED: not enough bits returned from entropy source\n");
eucrypt_ch5_rsa_keys 239
eucrypt_ch5_rsa_keys 240 fflush(file);
eucrypt_ch5_rsa_keys 241 xfree(p);
eucrypt_ch5_rsa_keys 242 mpi_free( pk.n);
eucrypt_ch5_rsa_keys 243 mpi_free( pk.e);
eucrypt_ch5_rsa_keys 244
eucrypt_ch5_rsa_keys 245 mpi_free( test );
eucrypt_ch5_rsa_keys 246 mpi_free( out1 );
eucrypt_ch5_rsa_keys 247 mpi_free( out2 );
eucrypt_ch5_rsa_keys 248 }
eucrypt_ch5_rsa_keys 249
eucrypt_ch5_rsa_keys 250 void test_rsa( int nruns, FILE *fkeys, FILE *fout) {
eucrypt_ch5_rsa_keys 251 RSA_secret_key sk;
eucrypt_ch5_rsa_keys 252 int noctets = KEY_LENGTH_OCTETS;
eucrypt_ch5_rsa_keys 253 int noctets_pq = noctets / 2;
eucrypt_ch5_rsa_keys 254 int nlimbs = mpi_nlimb_hint_from_nbytes(noctets);
eucrypt_ch5_rsa_keys 255 int nlimbs_pq = mpi_nlimb_hint_from_nbytes(noctets_pq);
eucrypt_ch5_rsa_keys 256 int i;
eucrypt_ch5_rsa_keys 257
eucrypt_ch5_rsa_keys 258 sk.n = mpi_alloc(nlimbs);
eucrypt_ch5_rsa_keys 259 sk.e = mpi_alloc(nlimbs);
eucrypt_ch5_rsa_keys 260 sk.d = mpi_alloc(nlimbs);
eucrypt_ch5_rsa_keys 261 sk.p = mpi_alloc(nlimbs_pq);
eucrypt_ch5_rsa_keys 262 sk.q = mpi_alloc(nlimbs_pq);
eucrypt_ch5_rsa_keys 263 sk.u = mpi_alloc(nlimbs_pq);
eucrypt_ch5_rsa_keys 264
eucrypt_ch5_rsa_keys 265 printf("TEST RSA key generation and use with %d runs\n", nruns);
eucrypt_ch5_rsa_keys 266 fflush(stdout);
eucrypt_ch5_rsa_keys 267
eucrypt_ch5_rsa_keys 268 for (i = 0;i < nruns; i++) {
eucrypt_ch5_rsa_keys 269 gen_keypair(&sk);
eucrypt_ch5_rsa_keys 270 printf(".");
eucrypt_ch5_rsa_keys 271 fflush(stdout);
eucrypt_ch5_rsa_keys 272
eucrypt_ch5_rsa_keys 273 mpi_print(fkeys, sk.n, 1);
eucrypt_ch5_rsa_keys 274 fwrite("\n", sizeof(char), 1, fkeys);
eucrypt_ch5_rsa_keys 275
eucrypt_ch5_rsa_keys 276 mpi_print(fkeys, sk.e, 1);
eucrypt_ch5_rsa_keys 277 fwrite("\n", sizeof(char), 1, fkeys);
eucrypt_ch5_rsa_keys 278
eucrypt_ch5_rsa_keys 279 mpi_print(fkeys, sk.d, 1);
eucrypt_ch5_rsa_keys 280 fwrite("\n", sizeof(char), 1, fkeys);
eucrypt_ch5_rsa_keys 281
eucrypt_ch5_rsa_keys 282 mpi_print(fkeys, sk.p, 1);
eucrypt_ch5_rsa_keys 283 fwrite("\n", sizeof(char), 1, fkeys);
eucrypt_ch5_rsa_keys 284
eucrypt_ch5_rsa_keys 285 mpi_print(fkeys, sk.q, 1);
eucrypt_ch5_rsa_keys 286 fwrite("\n", sizeof(char), 1, fkeys);
eucrypt_ch5_rsa_keys 287
eucrypt_ch5_rsa_keys 288 mpi_print(fkeys, sk.u, 1);
eucrypt_ch5_rsa_keys 289 fwrite("\n", sizeof(char), 1, fkeys);
eucrypt_ch5_rsa_keys 290
eucrypt_ch5_rsa_keys 291 test_rsa_keys(&sk, noctets_pq, fout);
eucrypt_ch5_rsa_keys 292 printf("*");
eucrypt_ch5_rsa_keys 293 fflush(stdout);
eucrypt_ch5_rsa_keys 294 }
eucrypt_ch5_rsa_keys 295
eucrypt_ch5_rsa_keys 296 mpi_free(sk.n);
eucrypt_ch5_rsa_keys 297 mpi_free(sk.e);
eucrypt_ch5_rsa_keys 298 mpi_free(sk.d);
eucrypt_ch5_rsa_keys 299 mpi_free(sk.p);
eucrypt_ch5_rsa_keys 300 mpi_free(sk.q);
eucrypt_ch5_rsa_keys 301 mpi_free(sk.u);
eucrypt_ch5_rsa_keys 302
eucrypt_ch5_rsa_keys 303 }
eucrypt_ch5_rsa_keys 304
eucrypt_ch5_rsa_keys 305 void test_rsa_exp() {
eucrypt_ch5_rsa_keys 306 MPI msg = mpi_alloc(0);
eucrypt_ch5_rsa_keys 307 MPI expected = mpi_alloc(0);
eucrypt_ch5_rsa_keys 308 MPI result;
eucrypt_ch5_rsa_keys 309
eucrypt_ch5_rsa_keys 310 RSA_public_key pk;
eucrypt_ch5_rsa_keys 311 pk.n = mpi_alloc(0);
eucrypt_ch5_rsa_keys 312 pk.e = mpi_alloc(0);
eucrypt_ch5_rsa_keys 313
eucrypt_ch5_rsa_keys 314 printf("TEST verify of rsa exponentiation on input data: \n");
eucrypt_ch5_rsa_keys 315
eucrypt_ch5_rsa_keys 316 mpi_fromstr(msg, "0x\
eucrypt_ch5_rsa_keys 317 5B6A8A0ACF4F4DB3F82EAC2D20255E4DF3E4B7C799603210766F26EF87C8980E737579\
eucrypt_ch5_rsa_keys 318 EC08E6505A51D19654C26D806BAF1B62F9C032E0B13D02AF99F7313BFCFD68DA46836E\
eucrypt_ch5_rsa_keys 319 CA529D7360948550F982C6476C054A97FD01635AB44BFBDBE2A90BE06F7984AC8534C3\
eucrypt_ch5_rsa_keys 320 8613747F340C18176E6D5F0C10246A2FCE3A668EACB6165C2052497CA2EE483F4FD8D0\
eucrypt_ch5_rsa_keys 321 6A9911BD97E9B6720521D872BD08FF8DA11A1B8DB147F252E4E69AE6201D3B374B171D\
eucrypt_ch5_rsa_keys 322 F445EF2BF509D468FD57CEB5840349B14C6E2AAA194D9531D238B85B8F0DD352D1E596\
eucrypt_ch5_rsa_keys 323 71539B429849E5D965E438BF9EFFC338DF9AADF304C4130D5A05E006ED855F37A06242\
eucrypt_ch5_rsa_keys 324 28097EF92F6E78CAE0CB97");
eucrypt_ch5_rsa_keys 325
eucrypt_ch5_rsa_keys 326 mpi_fromstr(expected, "0x\
eucrypt_ch5_rsa_keys 327 1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\
eucrypt_ch5_rsa_keys 328 FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\
eucrypt_ch5_rsa_keys 329 FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\
eucrypt_ch5_rsa_keys 330 FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\
eucrypt_ch5_rsa_keys 331 FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF003051300\
eucrypt_ch5_rsa_keys 332 D0609608648016503040203050004406255509399A3AF322C486C770C5F7F6E05E18FC\
eucrypt_ch5_rsa_keys 333 3E2219A03CA56C7501426A597187468B2F71B4A198C807171B73D0E7DBC3EEF6EA6AFF\
eucrypt_ch5_rsa_keys 334 693DE58E18FF84395BE");
eucrypt_ch5_rsa_keys 335 result = mpi_alloc( mpi_get_nlimbs(expected) );
eucrypt_ch5_rsa_keys 336
eucrypt_ch5_rsa_keys 337 mpi_fromstr(pk.n, "0x\
eucrypt_ch5_rsa_keys 338 CDD49A674BAF76D3B73E25BC6DF66EF3ABEDDCA461D3CCB6416793E3437C7806562694\
eucrypt_ch5_rsa_keys 339 73C2212D5FD5EED17AA067FEC001D8E76EC901EDEDF960304F891BD3CAD7F9A335D1A2\
eucrypt_ch5_rsa_keys 340 EC37EABEFF3FBE6D3C726DC68E599EBFE5456EF19813398CD7D548D746A30AA47D4293\
eucrypt_ch5_rsa_keys 341 968BFBAFCBF65A90DFFC87816FEE2A01E1DC699F4DDABB84965514C0D909D54FDA7062\
eucrypt_ch5_rsa_keys 342 A2037B50B771C153D5429BA4BA335EAB840F9551E9CD9DF8BB4A6DC3ED1318FF3969F7\
eucrypt_ch5_rsa_keys 343 B99D9FB90CAB968813F8AD4F9A069C9639A74D70A659C69C29692567CE863B88E191CC\
eucrypt_ch5_rsa_keys 344 9535B91B417D0AF14BE09C78B53AF9C5F494BCF2C60349FFA93C81E817AC682F0055A6\
eucrypt_ch5_rsa_keys 345 07BB56D6A281C1A04CEFE1");
eucrypt_ch5_rsa_keys 346
eucrypt_ch5_rsa_keys 347 mpi_fromstr( pk.e, "0x10001");
eucrypt_ch5_rsa_keys 348
eucrypt_ch5_rsa_keys 349 mpi_print( stdout, msg, 1);
eucrypt_ch5_rsa_keys 350 printf("\n");
eucrypt_ch5_rsa_keys 351
eucrypt_ch5_rsa_keys 352 public_rsa( result, msg, &pk);
eucrypt_ch5_rsa_keys 353 if ( mpi_cmp( result, expected) != 0 )
eucrypt_ch5_rsa_keys 354 printf( "FAILED\n");
eucrypt_ch5_rsa_keys 355 else
eucrypt_ch5_rsa_keys 356 printf( "PASSED\n");
eucrypt_ch5_rsa_keys 357
eucrypt_ch5_rsa_keys 358 printf("Expected:\n");
eucrypt_ch5_rsa_keys 359 mpi_print( stdout, expected, 1);
eucrypt_ch5_rsa_keys 360 printf("\n");
eucrypt_ch5_rsa_keys 361
eucrypt_ch5_rsa_keys 362 printf("Obtained:\n");
eucrypt_ch5_rsa_keys 363 mpi_print( stdout, result, 1);
eucrypt_ch5_rsa_keys 364 printf("\n");
eucrypt_ch5_rsa_keys 365
eucrypt_ch5_rsa_keys 366 mpi_free( pk.n );
eucrypt_ch5_rsa_keys 367 mpi_free( pk.e );
eucrypt_ch5_rsa_keys 368 mpi_free( msg );
eucrypt_ch5_rsa_keys 369 mpi_free( expected );
eucrypt_ch5_rsa_keys 370 mpi_free( result );
eucrypt_ch5_rsa_keys 371 }
eucrypt_ch5_rsa_keys 372
eucrypt_ch5_rsa_keys 373 void time_rsa_gen( int nruns ) {
eucrypt_ch5_rsa_keys 374 struct timespec tstart, tend;
eucrypt_ch5_rsa_keys 375 long int diff;
eucrypt_ch5_rsa_keys 376 int i;
eucrypt_ch5_rsa_keys 377
eucrypt_ch5_rsa_keys 378 RSA_secret_key sk;
eucrypt_ch5_rsa_keys 379 int noctets = KEY_LENGTH_OCTETS;
eucrypt_ch5_rsa_keys 380 int noctets_pq = noctets / 2;
eucrypt_ch5_rsa_keys 381 int nlimbs = mpi_nlimb_hint_from_nbytes(noctets);
eucrypt_ch5_rsa_keys 382 int nlimbs_pq = mpi_nlimb_hint_from_nbytes(noctets_pq);
eucrypt_ch5_rsa_keys 383 sk.n = mpi_alloc(nlimbs);
eucrypt_ch5_rsa_keys 384 sk.e = mpi_alloc(nlimbs);
eucrypt_ch5_rsa_keys 385 sk.d = mpi_alloc(nlimbs);
eucrypt_ch5_rsa_keys 386 sk.p = mpi_alloc(nlimbs_pq);
eucrypt_ch5_rsa_keys 387 sk.q = mpi_alloc(nlimbs_pq);
eucrypt_ch5_rsa_keys 388 sk.u = mpi_alloc(nlimbs_pq);
eucrypt_ch5_rsa_keys 389
eucrypt_ch5_rsa_keys 390 clock_gettime(CLOCK_MONOTONIC, &tstart);
eucrypt_ch5_rsa_keys 391 for (i = 0;i < nruns; i++) {
eucrypt_ch5_rsa_keys 392 gen_keypair(&sk);
eucrypt_ch5_rsa_keys 393 }
eucrypt_ch5_rsa_keys 394 clock_gettime(CLOCK_MONOTONIC, &tend);
eucrypt_ch5_rsa_keys 395
eucrypt_ch5_rsa_keys 396 diff = tend.tv_sec-tstart.tv_sec;
eucrypt_ch5_rsa_keys 397
eucrypt_ch5_rsa_keys 398 printf("TOTAL: %ld seconds for generating %d key pairs\n", diff, nruns);
eucrypt_ch5_rsa_keys 399 printf("Average (%d runs): %f seconds per TMSR RSA key pair.\n",
eucrypt_ch5_rsa_keys 400 nruns, diff / (1.0*nruns));
eucrypt_ch5_rsa_keys 401 mpi_free(sk.n);
eucrypt_ch5_rsa_keys 402 mpi_free(sk.e);
eucrypt_ch5_rsa_keys 403 mpi_free(sk.d);
eucrypt_ch5_rsa_keys 404 mpi_free(sk.p);
eucrypt_ch5_rsa_keys 405 mpi_free(sk.q);
eucrypt_ch5_rsa_keys 406 mpi_free(sk.u);
eucrypt_ch5_rsa_keys 407 }
eucrypt_ch5_rsa_keys 408
ch2_truerandom 409 int main(int ac, char **av)
ch2_truerandom 410 {
ch2_truerandom 411 int nruns;
eucrypt_ch3_mille... 412 int id;
eucrypt_ch5_rsa_keys 413 FILE *fk;
eucrypt_ch5_rsa_keys 414 FILE *fout;
ch2_truerandom 415
ch2_truerandom 416 if (ac<2) {
eucrypt_ch4_rpng 417 printf("Usage: %s number_of_runs/octets [testID]\n", av[0]);
ch2_truerandom 418 return -1;
ch2_truerandom 419 }
ch2_truerandom 420 nruns = atoi(av[1]);
ch2_truerandom 421
eucrypt_ch3_mille... 422 if (ac < 3)
eucrypt_ch4_rpng 423 id = -1;
eucrypt_ch3_mille... 424 else
eucrypt_ch3_mille... 425 id = atoi(av[2]);
eucrypt_ch3_mille... 426
eucrypt_ch4_rpng 427 switch ( id ) {
eucrypt_ch4_rpng 428 case 0:
eucrypt_ch4_rpng 429 printf("Timing entropy source...\n");
eucrypt_ch4_rpng 430 time_entropy_source(nruns, 4096);
eucrypt_ch4_rpng 431 break;
eucrypt_ch4_rpng 432 case 1:
eucrypt_ch4_rpng 433 test_entropy_output(nruns, "entropy_source_output.txt");
eucrypt_ch4_rpng 434 break;
eucrypt_ch4_rpng 435 case 2:
eucrypt_ch4_rpng 436 /* tests on miller-rabin */
eucrypt_ch4_rpng 437 /* a few primes (decimal): 65537, 116447, 411949103, 20943302231 */
eucrypt_ch4_rpng 438 test_is_composite(nruns, "0x10001", 0);
eucrypt_ch4_rpng 439 test_is_composite(nruns, "0x1C6DF", 0);
eucrypt_ch4_rpng 440 test_is_composite(nruns, "0x188DD82F", 0);
eucrypt_ch4_rpng 441 test_is_composite(nruns, "0x4E0516E57", 0);
eucrypt_ch4_rpng 442 /* a few mersenne primes (decimal): 2^13 - 1 = 8191, 2^17 - 1 = 131071, 2^31 - 1 = 2147483647 */
eucrypt_ch4_rpng 443 test_is_composite(nruns, "0x1FFF", 0);
eucrypt_ch4_rpng 444 test_is_composite(nruns, "0x1FFFF", 0);
eucrypt_ch4_rpng 445 test_is_composite(nruns, "0x7FFFFFFF", 0);
eucrypt_ch4_rpng 446 /* a few carmichael numbers, in decimal: 561, 60977817398996785 */
eucrypt_ch4_rpng 447 test_is_composite(nruns, "0x231", 1);
eucrypt_ch4_rpng 448 test_is_composite(nruns, "0xD8A300793EEF31", 1);
eucrypt_ch4_rpng 449 /* an even number */
eucrypt_ch4_rpng 450 test_is_composite(nruns, "0x15A9E672864B1E", 1);
eucrypt_ch4_rpng 451 /* a phuctor-found non-prime public exponent: 170141183460469231731687303715884105731 */
eucrypt_ch4_rpng 452 test_is_composite(nruns, "0x80000000000000000000000000000003", 1);
eucrypt_ch4_rpng 453 break;
eucrypt_ch4_rpng 454 case 3:
eucrypt_ch4_rpng 455 time_mr(nruns);
eucrypt_ch4_rpng 456 break;
eucrypt_ch4_rpng 457 case 4:
eucrypt_ch4_rpng 458 test_rpng(nruns);
eucrypt_ch4_rpng 459 break;
eucrypt_ch4_rpng 460 case 5:
eucrypt_ch4_rpng 461 time_rpng(nruns);
eucrypt_ch4_rpng 462 break;
eucrypt_ch5_rsa_keys 463 case 6:
eucrypt_ch5_rsa_keys 464 fk = fopen("keys.asc", "a");
eucrypt_ch5_rsa_keys 465 if ( fk == NULL )
eucrypt_ch5_rsa_keys 466 err("Failed to open file keys.asc!");
eucrypt_ch5_rsa_keys 467 fout = fopen("check_keys.asc", "a");
eucrypt_ch5_rsa_keys 468 if ( fout == NULL ) {
eucrypt_ch5_rsa_keys 469 fclose(fk);
eucrypt_ch5_rsa_keys 470 err("Failed to open file keys_check.asc!");
eucrypt_ch5_rsa_keys 471 }
eucrypt_ch5_rsa_keys 472 test_rsa(nruns, fk, fout);
eucrypt_ch5_rsa_keys 473 fclose(fk);
eucrypt_ch5_rsa_keys 474 fclose(fout);
eucrypt_ch5_rsa_keys 475 break;
eucrypt_ch5_rsa_keys 476 case 7:
eucrypt_ch5_rsa_keys 477 test_rsa_exp();
eucrypt_ch5_rsa_keys 478 break;
eucrypt_ch5_rsa_keys 479 case 8:
eucrypt_ch5_rsa_keys 480 time_rsa_gen(nruns);
eucrypt_ch5_rsa_keys 481 break;
eucrypt_ch4_rpng 482 default:
eucrypt_ch4_rpng 483 printf("Current test ids:\n");
eucrypt_ch4_rpng 484 printf("0 for timing entropy source\n");
eucrypt_ch4_rpng 485 printf("1 for entropy output test\n");
eucrypt_ch4_rpng 486 printf("2 for is_composite (Miller-Rabin) test\n");
eucrypt_ch4_rpng 487 printf("3 for timing Miller-Rabin\n");
eucrypt_ch4_rpng 488 printf("4 for random prime number generator test\n");
eucrypt_ch4_rpng 489 printf("5 for timing random prime number generator\n");
eucrypt_ch5_rsa_keys 490 printf("6 for testing rsa key pair generation and use; \
eucrypt_ch5_rsa_keys 491 writes to keys.asc and check_keys.asc\n");
eucrypt_ch5_rsa_keys 492 printf("7 for testing rsa exponentiation (fixed data)\n");
eucrypt_ch5_rsa_keys 493 printf("8 for timing rsa key pair generator\n");
eucrypt_ch3_mille... 494 }
eucrypt_ch3_mille... 495
ch2_truerandom 496 return 0;
ch2_truerandom 497 }