Mercurial > dropbear

comparison demos/test.c @ 3:7faae8f46238 libtomcrypt-orig

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Branch renaming
author Matt Johnston <matt@ucc.asn.au>
date Mon, 31 May 2004 18:25:41 +0000
parents
children 6362d3854bb4
comparison
equal deleted inserted replaced
-1:000000000000 3:7faae8f46238
1 /* This is the worst code you have ever seen written on purpose.... this code is just a big hack to test
2 out the functionality of the library */
3
4 #ifdef SONY_PS2
5 #include <eetypes.h>
6 #include <eeregs.h>
7 #include "timer.h"
8 #endif
9
10 #include <mycrypt.h>
11
12 int errnum;
13
14
15 int
16 null_setup (const unsigned char *key, int keylen, int num_rounds,
17 symmetric_key * skey)
18 {
19 return CRYPT_OK;
20 }
21
22 void
23 null_ecb_encrypt (const unsigned char *pt, unsigned char *ct,
24 symmetric_key * key)
25 {
26 memcpy (ct, pt, 8);
27 }
28
29 void
30 null_ecb_decrypt (const unsigned char *ct, unsigned char *pt,
31 symmetric_key * key)
32 {
33 memcpy (pt, ct, 8);
34 }
35
36 int
37 null_test (void)
38 {
39 return CRYPT_OK;
40 }
41
42 int
43 null_keysize (int *desired_keysize)
44 {
45 return CRYPT_OK;
46 }
47
48 const struct _cipher_descriptor null_desc = {
49 "memcpy()",
50 255,
51 8, 8, 8, 1,
52 &null_setup,
53 &null_ecb_encrypt,
54 &null_ecb_decrypt,
55 &null_test,
56 &null_keysize
57 };
58
59
60 prng_state prng;
61
62 void
63 store_tests (void)
64 {
65 unsigned char buf[8];
66 unsigned long L;
67 ulong64 LL;
68
69 printf ("LOAD32/STORE32 tests\n");
70 L = 0x12345678UL;
71 STORE32L (L, &buf[0]);
72 L = 0;
73 LOAD32L (L, &buf[0]);
74 if (L != 0x12345678UL) {
75 printf ("LOAD/STORE32 Little don't work\n");
76 exit (-1);
77 }
78 LL = CONST64 (0x01020304050607);
79 STORE64L (LL, &buf[0]);
80 LL = 0;
81 LOAD64L (LL, &buf[0])
82 if (LL != CONST64 (0x01020304050607)) {
83 printf ("LOAD/STORE64 Little don't work\n");
84 exit (-1);
85 }
86
87 L = 0x12345678UL;
88 STORE32H (L, &buf[0]);
89 L = 0;
90 LOAD32H (L, &buf[0]);
91 if (L != 0x12345678UL) {
92 printf ("LOAD/STORE32 High don't work, %08lx\n", L);
93 exit (-1);
94 }
95 LL = CONST64 (0x01020304050607);
96 STORE64H (LL, &buf[0]);
97 LL = 0;
98 LOAD64H (LL, &buf[0])
99 if (LL != CONST64 (0x01020304050607)) {
100 printf ("LOAD/STORE64 High don't work\n");
101 exit (-1);
102 }
103 }
104
105 void
106 cipher_tests (void)
107 {
108 int x;
109
110 printf ("Ciphers compiled in\n");
111 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
112 printf
113 (" %12s (%2d) Key Size: %4d to %4d, Block Size: %3d, Default # of rounds: %2d\n",
114 cipher_descriptor[x].name, cipher_descriptor[x].ID,
115 cipher_descriptor[x].min_key_length * 8,
116 cipher_descriptor[x].max_key_length * 8,
117 cipher_descriptor[x].block_length * 8,
118 cipher_descriptor[x].default_rounds);
119 }
120
121 }
122
123 void
124 ecb_tests (void)
125 {
126 int x;
127
128 printf ("ECB tests\n");
129 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
130 printf (" %12s: ", cipher_descriptor[x].name);
131 if ((errnum = cipher_descriptor[x].test ()) != CRYPT_OK) {
132 printf (" **failed** Reason: %s\n", error_to_string (errnum));
133 exit (-1);
134 } else {
135 printf ("passed\n");
136 }
137 }
138 }
139
140 #ifdef CBC
141 void
142 cbc_tests (void)
143 {
144 symmetric_CBC cbc;
145 int x, y;
146 unsigned char blk[32], ct[32], key[32], IV[32];
147 const unsigned char test[] =
148 { 0XFF, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
149
150 printf ("CBC tests\n");
151 /* ---- CBC ENCODING ---- */
152 /* make up a block and IV */
153 for (x = 0; x < 32; x++)
154 blk[x] = IV[x] = x;
155
156 /* now lets start a cbc session */
157 if ((errnum =
158 cbc_start (find_cipher ("blowfish"), IV, key, 16, 0,
159 &cbc)) != CRYPT_OK) {
160 printf ("CBC Setup: %s\n", error_to_string (errnum));
161 exit (-1);
162 }
163
164 /* now lets encode 32 bytes */
165 for (x = 0; x < 4; x++) {
166 if ((errnum = cbc_encrypt (blk + 8 * x, ct + 8 * x, &cbc)) != CRYPT_OK) {
167 printf ("CBC encrypt: %s\n", error_to_string (errnum));
168 exit (-1);
169 }
170 }
171
172 zeromem (blk, sizeof (blk));
173
174 /* ---- CBC DECODING ---- */
175 /* make up a IV */
176 for (x = 0; x < 32; x++)
177 IV[x] = x;
178
179 /* now lets start a cbc session */
180 if ((errnum =
181 cbc_start (find_cipher ("blowfish"), IV, key, 16, 0,
182 &cbc)) != CRYPT_OK) {
183 printf ("CBC Setup: %s\n", error_to_string (errnum));
184 exit (-1);
185 }
186
187 /* now lets decode 32 bytes */
188 for (x = 0; x < 4; x++) {
189 if ((errnum = cbc_decrypt (ct + 8 * x, blk + 8 * x, &cbc)) != CRYPT_OK) {
190 printf ("CBC decrypt: %s\n", error_to_string (errnum));
191 exit (-1);
192 }
193 }
194
195
196 /* print output */
197 for (x = y = 0; x < 32; x++)
198 if (blk[x] != x)
199 y = 1;
200 printf (" %s\n", y ? "failed" : "passed");
201
202 /* lets actually check the bytes */
203 memset (IV, 0, 8);
204 IV[0] = 0xFF; /* IV = FF 00 00 00 00 00 00 00 */
205 memset (blk, 0, 32);
206 blk[8] = 0xFF; /* BLK = 00 00 00 00 00 00 00 00 FF 00 00 00 00 00 00 00 */
207 cbc_start (find_cipher ("memcpy()"), IV, key, 8, 0, &cbc);
208 cbc_encrypt (blk, ct, &cbc); /* expect: FF 00 00 00 00 00 00 00 */
209 cbc_encrypt (blk + 8, ct + 8, &cbc); /* expect: 00 00 00 00 00 00 00 00 */
210 if (memcmp (ct, test, 16)) {
211 printf ("CBC failed logical testing.\n");
212 for (x = 0; x < 16; x++)
213 printf ("%02x ", ct[x]);
214 printf ("\n");
215 exit (-1);
216 } else {
217 printf ("CBC passed logical testing.\n");
218 }
219 }
220 #else
221 void
222 cbc_tests (void)
223 {
224 printf ("CBC not compiled in\n");
225 }
226 #endif
227
228 #ifdef OFB
229 void
230 ofb_tests (void)
231 {
232 symmetric_OFB ofb;
233 int x, y;
234 unsigned char blk[32], ct[32], key[32], IV[32];
235
236 printf ("OFB tests\n");
237 /* ---- ofb ENCODING ---- */
238 /* make up a block and IV */
239 for (x = 0; x < 32; x++)
240 blk[x] = IV[x] = x;
241
242 /* now lets start a ofb session */
243 if ((errnum =
244 ofb_start (find_cipher ("cast5"), IV, key, 16, 0, &ofb)) != CRYPT_OK) {
245 printf ("OFB Setup: %s\n", error_to_string (errnum));
246 exit (-1);
247 }
248
249 /* now lets encode 32 bytes */
250 for (x = 0; x < 4; x++) {
251 if ((errnum = ofb_encrypt (blk + 8 * x, ct + 8 * x, 8, &ofb)) != CRYPT_OK) {
252 printf ("OFB encrypt: %s\n", error_to_string (errnum));
253 exit (-1);
254 }
255 }
256
257 zeromem (blk, sizeof (blk));
258
259 /* ---- ofb DECODING ---- */
260 /* make up a IV */
261 for (x = 0; x < 32; x++)
262 IV[x] = x;
263
264 /* now lets start a ofb session */
265 if ((errnum =
266 ofb_start (find_cipher ("cast5"), IV, key, 16, 0, &ofb)) != CRYPT_OK) {
267 printf ("OFB setup: %s\n", error_to_string (errnum));
268 exit (-1);
269 }
270
271 /* now lets decode 32 bytes */
272 for (x = 0; x < 4; x++) {
273 if ((errnum = ofb_decrypt (ct + 8 * x, blk + 8 * x, 8, &ofb)) != CRYPT_OK) {
274 printf ("OFB decrypt: %s\n", error_to_string (errnum));
275 exit (-1);
276 }
277 }
278
279 /* print output */
280 for (x = y = 0; x < 32; x++)
281 if (blk[x] != x)
282 y = 1;
283 printf (" %s\n", y ? "failed" : "passed");
284 if (y)
285 exit (-1);
286 }
287 #else
288 void
289 ofb_tests (void)
290 {
291 printf ("OFB not compiled in\n");
292 }
293 #endif
294
295 #ifdef CFB
296 void
297 cfb_tests (void)
298 {
299 symmetric_CFB cfb;
300 int x, y;
301 unsigned char blk[32], ct[32], key[32], IV[32];
302
303 printf ("CFB tests\n");
304 /* ---- cfb ENCODING ---- */
305 /* make up a block and IV */
306 for (x = 0; x < 32; x++)
307 blk[x] = IV[x] = x;
308
309 /* now lets start a cfb session */
310 if ((errnum =
311 cfb_start (find_cipher ("blowfish"), IV, key, 16, 0,
312 &cfb)) != CRYPT_OK) {
313 printf ("CFB setup: %s\n", error_to_string (errnum));
314 exit (-1);
315 }
316
317 /* now lets encode 32 bytes */
318 for (x = 0; x < 4; x++) {
319 if ((errnum = cfb_encrypt (blk + 8 * x, ct + 8 * x, 8, &cfb)) != CRYPT_OK) {
320 printf ("CFB encrypt: %s\n", error_to_string (errnum));
321 exit (-1);
322 }
323 }
324
325 zeromem (blk, sizeof (blk));
326
327 /* ---- cfb DECODING ---- */
328 /* make up ahash_descriptor[prng->yarrow.hash].hashsize IV */
329 for (x = 0; x < 32; x++)
330 IV[x] = x;
331
332 /* now lets start a cfb session */
333 if ((errnum =
334 cfb_start (find_cipher ("blowfish"), IV, key, 16, 0,
335 &cfb)) != CRYPT_OK) {
336 printf ("CFB Setup: %s\n", error_to_string (errnum));
337 exit (-1);
338 }
339
340 /* now lets decode 32 bytes */
341 for (x = 0; x < 4; x++) {
342 if ((errnum = cfb_decrypt (ct + 8 * x, blk + 8 * x, 8, &cfb)) != CRYPT_OK) {
343 printf ("CFB decrypt: %s\n", error_to_string (errnum));
344 exit (-1);
345 }
346 }
347
348 /* print output */
349 for (x = y = 0; x < 32; x++)
350 if (blk[x] != x)
351 y = 1;
352 printf (" %s\n", y ? "failed" : "passed");
353 if (y)
354 exit (-1);
355 }
356 #else
357 void
358 cfb_tests (void)
359 {
360 printf ("CFB not compiled in\n");
361 }
362 #endif
363
364 #ifdef CTR
365 void
366 ctr_tests (void)
367 {
368 symmetric_CTR ctr;
369 int x, y;
370 unsigned char blk[32], ct[32], key[32], count[32];
371 const unsigned char test[] =
372 { 0xFF, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0 };
373
374 printf ("CTR tests\n");
375 /* ---- CTR ENCODING ---- */
376 /* make up a block and IV */
377 for (x = 0; x < 32; x++)
378 blk[x] = count[x] = x;
379
380 /* now lets start a ctr session */
381 if ((errnum =
382 ctr_start (find_cipher ("xtea"), count, key, 16, 0,
383 &ctr)) != CRYPT_OK) {
384 printf ("CTR Setup: %s\n", error_to_string (errnum));
385 exit (-1);
386 }
387
388 /* now lets encode 32 bytes */
389 for (x = 0; x < 4; x++) {
390 if ((errnum = ctr_encrypt (blk + 8 * x, ct + 8 * x, 8, &ctr)) != CRYPT_OK) {
391 printf ("CTR encrypt: %s\n", error_to_string (errnum));
392 exit (-1);
393 }
394 }
395
396 zeromem (blk, sizeof (blk));
397
398 /* ---- CTR DECODING ---- */
399 /* make up a IV */
400 for (x = 0; x < 32; x++)
401 count[x] = x;
402
403 /* now lets start a cbc session */
404 if ((errnum =
405 ctr_start (find_cipher ("xtea"), count, key, 16, 0,
406 &ctr)) != CRYPT_OK) {
407 printf ("CTR Setup: %s\n", error_to_string (errnum));
408 exit (-1);
409 }
410
411 /* now lets decode 32 bytes */
412 for (x = 0; x < 4; x++) {
413 if ((errnum = ctr_decrypt (ct + 8 * x, blk + 8 * x, 8, &ctr)) != CRYPT_OK) {
414 printf ("CTR decrypt: %s\n", error_to_string (errnum));
415 exit (-1);
416 }
417 }
418
419 /* print output */
420 for (x = y = 0; x < 32; x++)
421 if (blk[x] != x)
422 y = 1;
423 printf (" %s\n", y ? "failed" : "passed");
424 if (y)
425 exit (-1);
426
427 /* lets actually check the bytes */
428 memset (count, 0, 8);
429 count[0] = 0xFF; /* IV = FF 00 00 00 00 00 00 00 */
430 memset (blk, 0, 32);
431 blk[9] = 2; /* BLK = 00 00 00 00 00 00 00 00 00 02 00 00 00 00 00 00 */
432 ctr_start (find_cipher ("memcpy()"), count, key, 8, 0, &ctr);
433 ctr_encrypt (blk, ct, 8, &ctr); /* expect: FF 00 00 00 00 00 00 00 */
434 ctr_encrypt (blk + 8, ct + 8, 8, &ctr); /* expect: 00 03 00 00 00 00 00 00 */
435 if (memcmp (ct, test, 16)) {
436 printf ("CTR failed logical testing.\n");
437 for (x = 0; x < 16; x++)
438 printf ("%02x ", ct[x]);
439 printf ("\n");
440 } else {
441 printf ("CTR passed logical testing.\n");
442 }
443
444 }
445 #else
446 void
447 ctr_tests (void)
448 {
449 printf ("CTR not compiled in\n");
450 }
451 #endif
452
453 void
454 hash_tests (void)
455 {
456 int x;
457 printf ("Hash tests\n");
458 for (x = 0; hash_descriptor[x].name != NULL; x++) {
459 printf (" %10s (%2d) ", hash_descriptor[x].name, hash_descriptor[x].ID);
460 if ((errnum = hash_descriptor[x].test ()) != CRYPT_OK) {
461 printf ("**failed** Reason: %s\n", error_to_string (errnum));
462 exit(-1);
463 } else {
464 printf ("passed\n");
465 }
466 }
467 }
468
469 #ifdef MRSA
470 void
471 pad_test (void)
472 {
473 unsigned char in[100], out[100];
474 unsigned long x, y;
475
476 /* make a dummy message */
477 for (x = 0; x < 16; x++)
478 in[x] = (unsigned char) x;
479
480 /* pad the message so that random filler is placed before and after it */
481 y = 100;
482 if ((errnum =
483 rsa_pad (in, 16, out, &y, find_prng ("yarrow"), &prng)) != CRYPT_OK) {
484 printf ("Error: %s\n", error_to_string (errnum));
485 exit (-1);
486 }
487
488 /* depad the message to get the original content */
489 memset (in, 0, sizeof (in));
490 x = 100;
491 if ((errnum = rsa_depad (out, y, in, &x)) != CRYPT_OK) {
492 printf ("Error: %s\n", error_to_string (errnum));
493 exit (-1);
494 }
495
496 /* check outcome */
497 printf ("rsa_pad: ");
498 if (x != 16) {
499 printf ("Failed. Wrong size.\n");
500 exit (-1);
501 }
502 for (x = 0; x < 16; x++)
503 if (in[x] != x) {
504 printf ("Failed. Expected %02lx and got %02x.\n", x, in[x]);
505 exit (-1);
506 }
507 printf ("passed.\n");
508 }
509 void
510 rsa_test (void)
511 {
512 unsigned char in[520], out[520];
513 unsigned long x, y, z, limit;
514 int stat;
515 rsa_key key;
516 clock_t t;
517
518 /* ---- SINGLE ENCRYPT ---- */
519 /* encrypt a short 8 byte string */
520 if ((errnum =
521 rsa_make_key (&prng, find_prng ("yarrow"), 1024 / 8, 65537,
522 &key)) != CRYPT_OK) {
523 printf ("Error: %s\n", error_to_string (errnum));
524 exit (-1);
525 }
526 for (x = 0; x < 8; x++)
527 in[x] = (unsigned char) (x + 1);
528 y = sizeof (in);
529 if ((errnum = rsa_exptmod (in, 8, out, &y, PK_PUBLIC, &key)) != CRYPT_OK) {
530 printf ("Error: %s\n", error_to_string (errnum));
531 exit (-1);
532 }
533
534 /* decrypt it */
535 zeromem (in, sizeof (in));
536 x = sizeof (out);
537 if ((errnum = rsa_exptmod (out, y, in, &x, PK_PRIVATE, &key)) != CRYPT_OK) {
538 printf ("Error: %s\n", error_to_string (errnum));
539 exit (-1);
540 }
541
542 /* compare */
543 printf ("RSA : ");
544 for (x = 0; x < 8; x++)
545 if (in[x] != (x + 1)) {
546 printf ("Failed. x==%02lx, in[%ld]==%02x\n", x, x, in[x]);
547 exit (-1);
548 }
549 printf ("passed.\n");
550
551 /* test the rsa_encrypt_key functions */
552 for (x = 0; x < 16; x++)
553 in[x] = x;
554 y = sizeof (out);
555 if ((errnum =
556 rsa_encrypt_key (in, 16, out, &y, &prng, find_prng ("yarrow"),
557 &key)) != CRYPT_OK) {
558 printf ("Error: %s\n", error_to_string (errnum));
559 exit (-1);
560 }
561 zeromem (in, sizeof (in));
562 x = sizeof (in);
563 if ((errnum = rsa_decrypt_key (out, y, in, &x, &key)) != CRYPT_OK) {
564 printf ("Error: %s\n", error_to_string (errnum));
565 exit (-1);
566 }
567 printf ("RSA en/de crypt key routines: ");
568 if (x != 16) {
569 printf ("Failed (length)\n");
570 exit (-1);
571 }
572 for (x = 0; x < 16; x++)
573 if (in[x] != x) {
574 printf ("Failed (contents)\n");
575 exit (-1);
576 }
577 printf ("Passed\n");
578
579 /* test sign_hash functions */
580 for (x = 0; x < 16; x++)
581 in[x] = x;
582 x = sizeof (in);
583 if ((errnum = rsa_sign_hash (in, 16, out, &x, &key)) != CRYPT_OK) {
584 printf ("Error: %s\n", error_to_string (errnum));
585 exit (-1);
586 }
587 printf ("RSA signed hash: %lu bytes\n", x);
588 if ((errnum = rsa_verify_hash (out, x, in, &stat, &key)) != CRYPT_OK) {
589 printf ("Error: %s\n", error_to_string (errnum));
590 exit (-1);
591 }
592 printf ("Verify hash: %s, ", stat ? "passed" : "failed");
593 in[0] ^= 1;
594 if ((errnum = rsa_verify_hash (out, x, in, &stat, &key)) != CRYPT_OK) {
595 printf ("Error: %s\n", error_to_string (errnum));
596 exit (-1);
597 }
598 printf ("%s\n", (!stat) ? "passed" : "failed");
599 if (stat)
600 exit (-1);
601 rsa_free (&key);
602
603 /* make a RSA key */
604 #ifdef SONY_PS2_NOPE
605 limit = 1024;
606 #else
607 limit = 2048;
608 #endif
609
610 {
611 int tt;
612
613 for (z = 1024; z <= limit; z += 512) {
614 t = XCLOCK ();
615 for (tt = 0; tt < 3; tt++) {
616 if ((errnum = rsa_make_key (&prng, find_prng ("yarrow"), z / 8, 65537, &key)) != CRYPT_OK) {
617 printf ("Error: %s\n", error_to_string (errnum));
618 exit (-1);
619 }
620
621 /* check modulus size */
622 if (mp_unsigned_bin_size(&key.N) != (int)(z/8)) {
623 printf("\nRSA key supposed to be %lu bits but was %d bits\n", z, mp_count_bits(&key.N));
624 exit(EXIT_FAILURE);
625 }
626
627 if (tt < 2) {
628 rsa_free (&key);
629 }
630 }
631 t = XCLOCK () - t;
632 printf ("Took %.0f ms to make a %ld-bit RSA key.\n", 1000.0 * (((double) t / 3.0) / (double) XCLOCKS_PER_SEC), z);
633
634 /* time encryption */
635 t = XCLOCK ();
636
637 for (tt = 0; tt < 20; tt++) {
638 y = sizeof (in);
639 if ((errnum = rsa_exptmod (in, 8, out, &y, PK_PUBLIC, &key)) != CRYPT_OK) {
640 printf ("Error: %s\n", error_to_string (errnum));
641 exit (-1);
642 }
643 }
644 t = XCLOCK () - t;
645 printf ("Took %.0f ms to encrypt with a %ld-bit RSA key.\n",
646 1000.0 * (((double) t / 20.0) / (double) XCLOCKS_PER_SEC), z);
647
648 /* time decryption */
649 t = XCLOCK ();
650 for (tt = 0; tt < 20; tt++) {
651 x = sizeof (out);
652 if ((errnum = rsa_exptmod (out, y, in, &x, PK_PRIVATE, &key)) != CRYPT_OK) {
653 printf ("Error: %s\n", error_to_string (errnum));
654 exit (-1);
655 }
656 }
657 t = XCLOCK () - t;
658 printf ("Took %.0f ms to decrypt with a %ld-bit RSA key.\n",
659 1000.0 * (((double) t / 20.0) / (double) XCLOCKS_PER_SEC), z);
660 rsa_free (&key);
661 }
662 }
663 }
664 #else
665 void
666 pad_test (void)
667 {
668 printf ("MRSA not compiled in\n");
669 }
670
671 void
672 rsa_test (void)
673 {
674 printf ("MRSA not compiled in\n");
675 }
676 #endif
677
678 #ifdef BASE64
679 void
680 base64_test (void)
681 {
682 unsigned char buf[2][100];
683 unsigned long x, y;
684
685 printf ("Base64 tests\n");
686 zeromem (buf, sizeof (buf));
687 for (x = 0; x < 16; x++)
688 buf[0][x] = (unsigned char) x;
689
690 x = 100;
691 if (base64_encode (buf[0], 16, buf[1], &x) != CRYPT_OK) {
692 printf (" error: %s\n", error_to_string (errnum));
693 exit (-1);
694 }
695 printf (" encoded 16 bytes to %ld bytes...[%s]\n", x, buf[1]);
696 memset (buf[0], 0, 100);
697 y = 100;
698 if (base64_decode (buf[1], x, buf[0], &y) != CRYPT_OK) {
699 printf (" error: %s\n", error_to_string (errnum));
700 exit (-1);
701 }
702 printf (" decoded %ld bytes to %ld bytes\n", x, y);
703 for (x = 0; x < 16; x++)
704 if (buf[0][x] != x) {
705 printf (" **failed**\n");
706 exit (-1);
707 }
708 printf (" passed\n");
709 }
710 #else
711 void
712 base64_test (void)
713 {
714 printf ("Base64 not compiled in\n");
715 }
716 #endif
717
718 void
719 time_hash (void)
720 {
721 clock_t t1;
722 int x, y;
723 unsigned long z;
724 unsigned char input[4096], out[MAXBLOCKSIZE];
725 printf ("Hash Time Trials (4KB blocks):\n");
726 for (x = 0; hash_descriptor[x].name != NULL; x++) {
727 t1 = XCLOCK ();
728 z = sizeof (out);
729 y = 0;
730 while (XCLOCK () - t1 < (5 * XCLOCKS_PER_SEC)) {
731 hash_memory (x, input, 4096, out, &z);
732 hash_memory (x, input, 4096, out, &z);
733 hash_memory (x, input, 4096, out, &z);
734 hash_memory (x, input, 4096, out, &z);
735 hash_memory (x, input, 4096, out, &z);
736 hash_memory (x, input, 4096, out, &z);
737 hash_memory (x, input, 4096, out, &z);
738 hash_memory (x, input, 4096, out, &z);
739 hash_memory (x, input, 4096, out, &z);
740 hash_memory (x, input, 4096, out, &z);
741 hash_memory (x, input, 4096, out, &z);
742 hash_memory (x, input, 4096, out, &z);
743 hash_memory (x, input, 4096, out, &z);
744 hash_memory (x, input, 4096, out, &z);
745 hash_memory (x, input, 4096, out, &z);
746 hash_memory (x, input, 4096, out, &z);
747 hash_memory (x, input, 4096, out, &z);
748 hash_memory (x, input, 4096, out, &z);
749 hash_memory (x, input, 4096, out, &z);
750 hash_memory (x, input, 4096, out, &z);
751 hash_memory (x, input, 4096, out, &z);
752 hash_memory (x, input, 4096, out, &z);
753 hash_memory (x, input, 4096, out, &z);
754 hash_memory (x, input, 4096, out, &z);
755 hash_memory (x, input, 4096, out, &z);
756 hash_memory (x, input, 4096, out, &z);
757 hash_memory (x, input, 4096, out, &z);
758 hash_memory (x, input, 4096, out, &z);
759 hash_memory (x, input, 4096, out, &z);
760 hash_memory (x, input, 4096, out, &z);
761 hash_memory (x, input, 4096, out, &z);
762 hash_memory (x, input, 4096, out, &z);
763 y += 32;
764 }
765 t1 = XCLOCK () - t1;
766 printf ("%-20s: Hash at %5.2f Mbit/sec\n", hash_descriptor[x].name,
767 ((8.0 * 4096.0) *
768 ((double) y / ((double) t1 / (double) XCLOCKS_PER_SEC))) /
769 1000000.0);
770 }
771 }
772
773 void
774 time_ecb (void)
775 {
776 clock_t t1, t2;
777 long x, y1, y2;
778 unsigned char pt[32], key[32];
779 symmetric_key skey;
780 void (*func) (const unsigned char *, unsigned char *, symmetric_key *);
781
782 printf ("ECB Time Trials for the Symmetric Ciphers:\n");
783 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
784 cipher_descriptor[x].setup (key, cipher_descriptor[x].min_key_length, 0,
785 &skey);
786
787 #define DO1 func(pt,pt,&skey);
788 #define DO2 DO1 DO1
789 #define DO4 DO2 DO2
790 #define DO8 DO4 DO4
791 #define DO16 DO8 DO8
792 #define DO32 DO16 DO16
793 #define DO64 DO32 DO32
794 #define DO128 DO64 DO64
795 #define DO256 DO128 DO128
796
797 func = cipher_descriptor[x].ecb_encrypt;
798 y1 = 0;
799 t1 = XCLOCK ();
800 while (XCLOCK () - t1 < 3 * XCLOCKS_PER_SEC) {
801 DO256;
802 y1 += 256;
803 }
804 t1 = XCLOCK () - t1;
805
806 func = cipher_descriptor[x].ecb_decrypt;
807 y2 = 0;
808 t2 = XCLOCK ();
809 while (XCLOCK () - t2 < 3 * XCLOCKS_PER_SEC) {
810 DO256;
811 y2 += 256;
812 }
813 t2 = XCLOCK () - t2;
814 printf
815 ("%-20s: Encrypt at %5.2f Mbit/sec and Decrypt at %5.2f Mbit/sec\n",
816 cipher_descriptor[x].name,
817 ((8.0 * (double) cipher_descriptor[x].block_length) *
818 ((double) y1 / ((double) t1 / (double) XCLOCKS_PER_SEC))) / 1000000.0,
819 ((8.0 * (double) cipher_descriptor[x].block_length) *
820 ((double) y2 / ((double) t2 / (double) XCLOCKS_PER_SEC))) /
821 1000000.0);
822
823 #undef DO256
824 #undef DO128
825 #undef DO64
826 #undef DO32
827 #undef DO16
828 #undef DO8
829 #undef DO4
830 #undef DO2
831 #undef DO1
832 }
833 }
834
835 #ifdef MDH
836 void
837 dh_tests (void)
838 {
839 unsigned char buf[3][4096];
840 unsigned long x, y, z;
841 int low, high, stat, stat2;
842 dh_key usera, userb;
843 clock_t t1;
844
845 printf("Testing builting DH parameters...."); fflush(stdout);
846 if ((errnum = dh_test()) != CRYPT_OK) {
847 printf("DH Error: %s\n", error_to_string(errnum));
848 exit(-1);
849 }
850 printf("Passed.\n");
851
852 dh_sizes (&low, &high);
853 printf ("DH Keys from %d to %d supported.\n", low * 8, high * 8);
854
855 /* make up two keys */
856 if ((errnum =
857 dh_make_key (&prng, find_prng ("yarrow"), 96, &usera)) != CRYPT_OK) {
858 printf ("Error: %s\n", error_to_string (errnum));
859 exit (-1);
860 }
861 if ((errnum =
862 dh_make_key (&prng, find_prng ("yarrow"), 96, &userb)) != CRYPT_OK) {
863 printf ("Error: %s\n", error_to_string (errnum));
864 exit (-1);
865 }
866
867 /* make the shared secret */
868 x = 4096;
869 if ((errnum = dh_shared_secret (&usera, &userb, buf[0], &x)) != CRYPT_OK) {
870 printf ("Error: %s\n", error_to_string (errnum));
871 exit (-1);
872 }
873
874 y = 4096;
875 if ((errnum = dh_shared_secret (&userb, &usera, buf[1], &y)) != CRYPT_OK) {
876 printf ("Error: %s\n", error_to_string (errnum));
877 exit (-1);
878 }
879 if (y != x) {
880 printf ("DH Shared keys are not same size.\n");
881 exit (-1);
882 }
883 if (memcmp (buf[0], buf[1], x)) {
884 printf ("DH Shared keys not same contents.\n");
885 exit (-1);
886 }
887
888 /* now export userb */
889 y = 4096;
890 if ((errnum = dh_export (buf[1], &y, PK_PUBLIC, &userb)) != CRYPT_OK) {
891 printf ("Error: %s\n", error_to_string (errnum));
892 exit (-1);
893 }
894 dh_free (&userb);
895
896 /* import and make the shared secret again */
897 if ((errnum = dh_import (buf[1], y, &userb)) != CRYPT_OK) {
898 printf ("Error: %s\n", error_to_string (errnum));
899 exit (-1);
900 }
901 z = 4096;
902 if ((errnum = dh_shared_secret (&usera, &userb, buf[2], &z)) != CRYPT_OK) {
903 printf ("Error: %s\n", error_to_string (errnum));
904 exit (-1);
905 }
906
907 printf ("DH routines: ");
908 if (z != x) {
909 printf ("failed. Size don't match?\n");
910 exit (-1);
911 }
912 if (memcmp (buf[0], buf[2], x)) {
913 printf ("Failed. Content didn't match.\n");
914 exit (-1);
915 }
916 printf ("Passed\n");
917 dh_free (&usera);
918 dh_free (&userb);
919
920 /* time stuff */
921 {
922 static int sizes[] = { 96, 128, 160, 192, 224, 256, 320, 384, 512 };
923 int ii, tt;
924
925 for (ii = 0; ii < (int) (sizeof (sizes) / sizeof (sizes[0])); ii++) {
926 t1 = XCLOCK ();
927 for (tt = 0; tt < 25; tt++) {
928 dh_make_key (&prng, find_prng ("yarrow"), sizes[ii], &usera);
929 dh_free (&usera);
930 }
931 t1 = XCLOCK () - t1;
932 printf ("Make dh-%d key took %f msec\n", sizes[ii] * 8,
933 1000.0 * (((double) t1 / 25.0) / (double) XCLOCKS_PER_SEC));
934 }
935 }
936
937 /* test encrypt_key */
938 dh_make_key (&prng, find_prng ("yarrow"), 128, &usera);
939 for (x = 0; x < 16; x++)
940 buf[0][x] = x;
941 y = sizeof (buf[1]);
942 if ((errnum =
943 dh_encrypt_key (buf[0], 16, buf[1], &y, &prng, find_prng ("yarrow"),
944 find_hash ("md5"), &usera)) != CRYPT_OK) {
945 printf ("Error: %s\n", error_to_string (errnum));
946 exit (-1);
947 }
948 zeromem (buf[0], sizeof (buf[0]));
949 x = sizeof (buf[0]);
950 if ((errnum = dh_decrypt_key (buf[1], y, buf[0], &x, &usera)) != CRYPT_OK) {
951 printf ("Error: %s\n", error_to_string (errnum));
952 exit (-1);
953 }
954 printf ("DH en/de crypt key routines: ");
955 if (x != 16) {
956 printf ("Failed (length)\n");
957 exit (-1);
958 }
959 for (x = 0; x < 16; x++)
960 if (buf[0][x] != x) {
961 printf ("Failed (contents)\n");
962 exit (-1);
963 }
964 printf ("Passed (size %lu)\n", y);
965
966 /* test sign_hash */
967 for (x = 0; x < 16; x++)
968 buf[0][x] = x;
969 x = sizeof (buf[1]);
970 if ((errnum =
971 dh_sign_hash (buf[0], 16, buf[1], &x, &prng, find_prng ("yarrow"),
972 &usera)) != CRYPT_OK) {
973 printf ("Error: %s\n", error_to_string (errnum));
974 exit (-1);
975 }
976 if ((errnum = dh_verify_hash (buf[1], x, buf[0], 16, &stat, &usera)) != CRYPT_OK) {
977 printf ("Error: %s\n", error_to_string (errnum));
978 exit (-1);
979 }
980 buf[0][0] ^= 1;
981 if ((errnum = dh_verify_hash (buf[1], x, buf[0], 16, &stat2, &usera)) != CRYPT_OK) {
982 printf ("Error: %s\n", error_to_string (errnum));
983 exit (-1);
984 }
985 printf ("dh_sign/verify_hash: %s (%d,%d), %lu\n",
986 ((stat == 1)
987 && (stat2 == 0)) ? "passed" : "failed", stat, stat2, x);
988 dh_free (&usera);
989 }
990 #else
991 void
992 dh_tests (void)
993 {
994 printf ("MDH not compiled in\n");
995 }
996 #endif
997
998 int callback_x = 0;
999 void
1000 callback (void)
1001 {
1002 printf ("%c\x08", "-\\|/"[++callback_x & 3]);
1003 #ifndef SONY_PS2
1004 fflush (stdout);
1005 #endif
1006 }
1007
1008 void
1009 rng_tests (void)
1010 {
1011 unsigned char buf[16];
1012 clock_t t1;
1013 int x, y;
1014
1015 printf ("RNG tests\n");
1016 t1 = XCLOCK ();
1017 x = rng_get_bytes (buf, sizeof (buf), &callback);
1018 t1 = XCLOCK () - t1;
1019 printf (" %f bytes per second...",
1020 (double) x / ((double) t1 / (double) XCLOCKS_PER_SEC));
1021 printf ("read %d bytes.\n ", x);
1022 for (y = 0; y < x; y++)
1023 printf ("%02x ", buf[y]);
1024 printf ("\n");
1025
1026 #ifdef YARROW
1027 if ((errnum =
1028 rng_make_prng (128, find_prng ("yarrow"), &prng,
1029 &callback)) != CRYPT_OK) {
1030 printf (" starting yarrow error: %s\n", error_to_string (errnum));
1031 exit (-1);
1032 }
1033 #endif
1034 }
1035
1036 #ifdef MECC
1037 void
1038 ecc_tests (void)
1039 {
1040 unsigned char buf[4][4096];
1041 unsigned long x, y, z;
1042 int stat, stat2, low, high;
1043 ecc_key usera, userb;
1044 clock_t t1;
1045
1046 if ((errnum = ecc_test ()) != CRYPT_OK) {
1047 printf ("ecc Error: %s\n", error_to_string (errnum));
1048 exit (-1);
1049 }
1050
1051 ecc_sizes (&low, &high);
1052 printf ("ecc Keys from %d to %d supported.\n", low * 8, high * 8);
1053
1054 /* make up two keys */
1055 if ((errnum =
1056 ecc_make_key (&prng, find_prng ("yarrow"), 24, &usera)) != CRYPT_OK) {
1057 printf ("Error: %s\n", error_to_string (errnum));
1058 exit (-1);
1059 }
1060 if ((errnum =
1061 ecc_make_key (&prng, find_prng ("yarrow"), 24, &userb)) != CRYPT_OK) {
1062 printf ("Error: %s\n", error_to_string (errnum));
1063 exit (-1);
1064 }
1065
1066 /* make the shared secret */
1067 x = 4096;
1068 if ((errnum = ecc_shared_secret (&usera, &userb, buf[0], &x)) != CRYPT_OK) {
1069 printf ("Error: %s\n", error_to_string (errnum));
1070 exit (-1);
1071 }
1072
1073 y = 4096;
1074 if ((errnum = ecc_shared_secret (&userb, &usera, buf[1], &y)) != CRYPT_OK) {
1075 printf ("Error: %s\n", error_to_string (errnum));
1076 exit (-1);
1077 }
1078
1079 if (y != x) {
1080 printf ("ecc Shared keys are not same size.\n");
1081 exit (-1);
1082 }
1083
1084 if (memcmp (buf[0], buf[1], x)) {
1085 printf ("ecc Shared keys not same contents.\n");
1086 exit (-1);
1087 }
1088
1089 /* now export userb */
1090 y = 4096;
1091 if ((errnum = ecc_export (buf[1], &y, PK_PUBLIC, &userb)) != CRYPT_OK) {
1092 printf ("Error: %s\n", error_to_string (errnum));
1093 exit (-1);
1094 }
1095 ecc_free (&userb);
1096 printf ("ECC-192 export took %ld bytes\n", y);
1097
1098 /* import and make the shared secret again */
1099 if ((errnum = ecc_import (buf[1], y, &userb)) != CRYPT_OK) {
1100 printf ("Error: %s\n", error_to_string (errnum));
1101 exit (-1);
1102 }
1103
1104 z = 4096;
1105 if ((errnum = ecc_shared_secret (&usera, &userb, buf[2], &z)) != CRYPT_OK) {
1106 printf ("Error: %s\n", error_to_string (errnum));
1107 exit (-1);
1108 }
1109
1110 printf ("ecc routines: ");
1111 if (z != x) {
1112 printf ("failed. Size don't match?\n");
1113 exit (-1);
1114 }
1115 if (memcmp (buf[0], buf[2], x)) {
1116 printf ("Failed. Content didn't match.\n");
1117 exit (-1);
1118 }
1119 printf ("Passed\n");
1120 ecc_free (&usera);
1121 ecc_free (&userb);
1122
1123 /* time stuff */
1124 {
1125 static int sizes[] = { 20, 24, 28, 32, 48, 65 };
1126 int ii, tt;
1127
1128 for (ii = 0; ii < (int) (sizeof (sizes) / sizeof (sizes[0])); ii++) {
1129 t1 = XCLOCK ();
1130 for (tt = 0; tt < 10; tt++) {
1131 if ((errnum =
1132 ecc_make_key (&prng, find_prng ("yarrow"), sizes[ii],
1133 &usera)) != CRYPT_OK) {
1134 printf ("Error: %s\n", error_to_string (errnum));
1135 exit (-1);
1136 }
1137 ecc_free (&usera);
1138 }
1139 t1 = XCLOCK () - t1;
1140 printf ("Make ECC-%d key took %f msec\n", sizes[ii] * 8,
1141 1000.0 * (((double) t1 / 10.0) / (double) XCLOCKS_PER_SEC));
1142 }
1143 }
1144
1145 /* test encrypt_key */
1146 ecc_make_key (&prng, find_prng ("yarrow"), 20, &usera);
1147 for (x = 0; x < 32; x++)
1148 buf[0][x] = x;
1149 y = sizeof (buf[1]);
1150 if ((errnum =
1151 ecc_encrypt_key (buf[0], 32, buf[1], &y, &prng, find_prng ("yarrow"),
1152 find_hash ("sha256"), &usera)) != CRYPT_OK) {
1153 printf ("Error: %s\n", error_to_string (errnum));
1154 exit (-1);
1155 }
1156 zeromem (buf[0], sizeof (buf[0]));
1157 x = sizeof (buf[0]);
1158 if ((errnum = ecc_decrypt_key (buf[1], y, buf[0], &x, &usera)) != CRYPT_OK) {
1159 printf ("Error: %s\n", error_to_string (errnum));
1160 exit (-1);
1161 }
1162 printf ("ECC en/de crypt key routines: ");
1163 if (x != 32) {
1164 printf ("Failed (length)\n");
1165 exit (-1);
1166 }
1167 for (x = 0; x < 32; x++)
1168 if (buf[0][x] != x) {
1169 printf ("Failed (contents)\n");
1170 exit (-1);
1171 }
1172 printf ("Passed (size: %lu)\n", y);
1173 /* test sign_hash */
1174 for (x = 0; x < 16; x++)
1175 buf[0][x] = x;
1176 x = sizeof (buf[1]);
1177 if ((errnum =
1178 ecc_sign_hash (buf[0], 16, buf[1], &x, &prng, find_prng ("yarrow"),
1179 &usera)) != CRYPT_OK) {
1180 printf ("Error: %s\n", error_to_string (errnum));
1181 exit (-1);
1182 }
1183 printf("Signature size: %lu\n", x);
1184 if (ecc_verify_hash (buf[1], x, buf[0], 16, &stat, &usera)) {
1185 printf ("Error: %s\n", error_to_string (errnum));
1186 exit (-1);
1187 }
1188 buf[0][0] ^= 1;
1189 if (ecc_verify_hash (buf[1], x, buf[0], 16, &stat2, &usera)) {
1190 printf ("Error: %s\n", error_to_string (errnum));
1191 exit (-1);
1192 }
1193 printf ("ecc_sign/verify_hash: %s (%d,%d)\n",
1194 ((stat == 1) && (stat2 == 0)) ? "passed" : "failed", stat, stat2);
1195 ecc_free (&usera);
1196 }
1197 #else
1198 void
1199 ecc_tests (void)
1200 {
1201 printf ("MECC not compiled in\n");
1202 }
1203 #endif
1204
1205 #ifdef GF
1206 void
1207 gf_tests (void)
1208 {
1209 gf_int a, b, c, d;
1210 int n;
1211 unsigned char buf[1024];
1212
1213 printf ("GF tests\n");
1214 gf_zero (a);
1215 gf_zero (b);
1216 gf_zero (c);
1217 gf_zero (d);
1218
1219 /* a == 0x18000000b */
1220 a[1] = 1;
1221 a[0] = 0x8000000bUL;
1222
1223 /* b == 0x012345678 */
1224 b[0] = 0x012345678UL;
1225
1226 /* find 1/b mod a */
1227 gf_invmod (b, a, c);
1228
1229 /* find 1/1/b mod a */
1230 gf_invmod (c, a, d);
1231
1232 /* display them */
1233 printf (" %08lx %08lx\n", c[0], d[0]);
1234
1235 /* store as binary string */
1236 n = gf_size (a);
1237 printf (" a takes %d bytes\n", n);
1238 gf_toraw (a, buf);
1239 gf_readraw (a, buf, n);
1240 printf (" a == %08lx%08lx\n", a[1], a[0]);
1241
1242 /* primality testing */
1243 gf_zero (a);
1244 a[0] = 0x169;
1245 printf (" GF prime: %s, ", gf_is_prime (a) ? "passed" : "failed");
1246 a[0] = 0x168;
1247 printf (" %s\n", gf_is_prime (a) ? "failed" : "passed");
1248
1249 /* test sqrt code */
1250 gf_zero (a);
1251 a[1] = 0x00000001;
1252 a[0] = 0x8000000bUL;
1253 gf_zero (b);
1254 b[0] = 0x12345678UL;
1255
1256 gf_sqrt (b, a, c);
1257 gf_mulmod (c, c, a, b);
1258 printf (" (%08lx)^2 = %08lx (mod %08lx%08lx) \n", c[0], b[0], a[1], a[0]);
1259 }
1260 #else
1261 void
1262 gf_tests (void)
1263 {
1264 printf ("GF not compiled in\n");
1265 }
1266 #endif
1267
1268 #ifdef MPI
1269 void
1270 test_prime (void)
1271 {
1272 char buf[1024];
1273 mp_int a;
1274 int x;
1275
1276 /* make a 1024 bit prime */
1277 mp_init (&a);
1278 rand_prime (&a, 128*8, &prng, find_prng ("yarrow"));
1279
1280 /* dump it */
1281 mp_todecimal (&a, buf);
1282 printf ("1024-bit prime:\n");
1283 for (x = 0; x < (int) strlen (buf);) {
1284 printf ("%c", buf[x]);
1285 if (!(++x % 60))
1286 printf ("\\ \n");
1287 }
1288 printf ("\n\n");
1289
1290 mp_clear (&a);
1291 }
1292 #else
1293 void
1294 test_prime (void)
1295 {
1296 printf ("MPI not compiled in\n");
1297 }
1298 #endif
1299
1300 void
1301 register_all_algs (void)
1302 {
1303 #ifdef RIJNDAEL
1304 register_cipher (&aes_desc);
1305 #endif
1306 #ifdef BLOWFISH
1307 register_cipher (&blowfish_desc);
1308 #endif
1309 #ifdef XTEA
1310 register_cipher (&xtea_desc);
1311 #endif
1312 #ifdef RC5
1313 register_cipher (&rc5_desc);
1314 #endif
1315 #ifdef RC6
1316 register_cipher (&rc6_desc);
1317 #endif
1318 #ifdef SAFERP
1319 register_cipher (&saferp_desc);
1320 #endif
1321 #ifdef TWOFISH
1322 register_cipher (&twofish_desc);
1323 #endif
1324 #ifdef SAFER
1325 register_cipher (&safer_k64_desc);
1326 register_cipher (&safer_sk64_desc);
1327 register_cipher (&safer_k128_desc);
1328 register_cipher (&safer_sk128_desc);
1329 #endif
1330 #ifdef RC2
1331 register_cipher (&rc2_desc);
1332 #endif
1333 #ifdef DES
1334 register_cipher (&des_desc);
1335 register_cipher (&des3_desc);
1336 #endif
1337 #ifdef CAST5
1338 register_cipher (&cast5_desc);
1339 #endif
1340 #ifdef NOEKEON
1341 register_cipher (&noekeon_desc);
1342 #endif
1343 #ifdef SKIPJACK
1344 register_cipher (&skipjack_desc);
1345 #endif
1346 register_cipher (&null_desc);
1347
1348 #ifdef TIGER
1349 register_hash (&tiger_desc);
1350 #endif
1351 #ifdef MD2
1352 register_hash (&md2_desc);
1353 #endif
1354 #ifdef MD4
1355 register_hash (&md4_desc);
1356 #endif
1357 #ifdef MD5
1358 register_hash (&md5_desc);
1359 #endif
1360 #ifdef SHA1
1361 register_hash (&sha1_desc);
1362 #endif
1363 #ifdef SHA256
1364 register_hash (&sha256_desc);
1365 #endif
1366 #ifdef SHA224
1367 register_hash (&sha224_desc);
1368 #endif
1369 #ifdef SHA384
1370 register_hash (&sha384_desc);
1371 #endif
1372 #ifdef SHA512
1373 register_hash (&sha512_desc);
1374 #endif
1375 #ifdef RIPEMD128
1376 register_hash (&rmd128_desc);
1377 #endif
1378 #ifdef RIPEMD160
1379 register_hash (&rmd160_desc);
1380 #endif
1381 #ifdef WHIRLPOOL
1382 register_hash (&whirlpool_desc);
1383 #endif
1384
1385 #ifdef YARROW
1386 register_prng (&yarrow_desc);
1387 #endif
1388 #ifdef SPRNG
1389 register_prng (&sprng_desc);
1390 #endif
1391 }
1392
1393 #ifdef KR
1394 void
1395 kr_display (pk_key * kr)
1396 {
1397 static const char *sys[] = { "NON-KEY", "RSA", "DH", "ECC" };
1398 static const char *type[] = { "PRIVATE", "PUBLIC", "PRIVATE_OPTIMIZED" };
1399
1400 while (kr->system != NON_KEY) {
1401 printf ("CRC [%08lx], System [%10s], Type [%20s], %s, %s, %s\n", kr->ID,
1402 sys[kr->system], type[kr->key_type], kr->name, kr->email,
1403 kr->description);
1404 kr = kr->next;
1405 }
1406 printf ("\n");
1407 }
1408
1409 void
1410 kr_test_makekeys (pk_key ** kr)
1411 {
1412 if ((errnum = kr_init (kr)) != CRYPT_OK) {
1413 printf ("KR init error %s\n", error_to_string (errnum));
1414 exit (-1);
1415 }
1416
1417 /* make a DH key */
1418 printf ("KR: Making DH key...\n");
1419 if ((errnum =
1420 kr_make_key (*kr, &prng, find_prng ("yarrow"), DH_KEY, 128, "dhkey",
1421 "[email protected]", "dhkey one")) != CRYPT_OK) {
1422 printf ("Make key error: %s\n", error_to_string (errnum));
1423 exit (-1);
1424 }
1425
1426 /* make a ECC key */
1427 printf ("KR: Making ECC key...\n");
1428 if ((errnum =
1429 kr_make_key (*kr, &prng, find_prng ("yarrow"), ECC_KEY, 20, "ecckey",
1430 "[email protected]", "ecckey one")) != CRYPT_OK) {
1431 printf ("Make key error: %s\n", error_to_string (errnum));
1432 exit (-1);
1433 }
1434
1435 /* make a RSA key */
1436 printf ("KR: Making RSA key...\n");
1437 if ((errnum =
1438 kr_make_key (*kr, &prng, find_prng ("yarrow"), RSA_KEY, 128, "rsakey",
1439 "[email protected]", "rsakey one")) != CRYPT_OK) {
1440 printf ("Make key error: %s\n", error_to_string (errnum));
1441 exit (-1);
1442 }
1443
1444 }
1445
1446 void
1447 kr_test (void)
1448 {
1449 pk_key *kr, *_kr;
1450 unsigned char buf[8192], buf2[8192], buf3[8192];
1451 unsigned long len;
1452 int i, j, stat;
1453 #ifndef NO_FILE
1454 FILE *f;
1455 #endif
1456
1457 kr_test_makekeys (&kr);
1458
1459 printf ("The original list:\n");
1460 kr_display (kr);
1461
1462 for (i = 0; i < 3; i++) {
1463 len = sizeof (buf);
1464 if ((errnum = kr_export (kr, kr->ID, kr->key_type, buf, &len)) != CRYPT_OK) {
1465 printf ("Error exporting key %d, %s\n", i, error_to_string (errnum));
1466 exit (-1);
1467 }
1468 printf ("Exported key was: %lu bytes\n", len);
1469 if ((errnum = kr_del (&kr, kr->ID)) != CRYPT_OK) {
1470 printf ("Error deleting key %d, %s\n", i, error_to_string (errnum));
1471 exit (-1);
1472 }
1473 kr_display (kr);
1474 if ((errnum = kr_import (kr, buf, len)) != CRYPT_OK) {
1475 printf ("Error importing key %d, %s\n", i, error_to_string (errnum));
1476 exit (-1);
1477 }
1478 kr_display (kr);
1479 }
1480
1481 for (i = 0; i < 3; i++) {
1482 len = sizeof (buf);
1483 if ((errnum = kr_export (kr, kr->ID, PK_PUBLIC, buf, &len)) != CRYPT_OK) {
1484 printf ("Error exporting key %d, %s\n", i, error_to_string (errnum));
1485 exit (-1);
1486 }
1487 printf ("Exported key was: %lu bytes\n", len);
1488 if ((errnum = kr_del (&kr, kr->ID)) != CRYPT_OK) {
1489 printf ("Error deleting key %d, %s\n", i, error_to_string (errnum));
1490 exit (-1);
1491 }
1492 kr_display (kr);
1493 if ((errnum = kr_import (kr, buf, len)) != CRYPT_OK) {
1494 printf ("Error importing key %d, %s\n", i, error_to_string (errnum));
1495 exit (-1);
1496 }
1497 kr_display (kr);
1498 }
1499
1500 if ((errnum = kr_clear (&kr)) != CRYPT_OK) {
1501 printf ("Error clearing ring: %s\n", error_to_string (errnum));
1502 exit (-1);
1503 }
1504
1505
1506 /* TEST output to file */
1507 #ifndef NO_FILE
1508
1509 if ((errnum = kr_init (&kr)) != CRYPT_OK) {
1510 printf ("KR init error %s\n", error_to_string (errnum));
1511 exit (-1);
1512 }
1513 kr_test_makekeys (&kr);
1514
1515 /* save to file */
1516 f = fopen ("ring.dat", "wb");
1517 if ((errnum = kr_save (kr, f, NULL)) != CRYPT_OK) {
1518 printf ("kr_save error %s\n", error_to_string (errnum));
1519 exit (-1);
1520 }
1521 fclose (f);
1522
1523 /* delete and load */
1524 if ((errnum = kr_clear (&kr)) != CRYPT_OK) {
1525 printf ("clear error: %s\n", error_to_string (errnum));
1526 exit (-1);
1527 }
1528
1529 f = fopen ("ring.dat", "rb");
1530 if ((errnum = kr_load (&kr, f, NULL)) != CRYPT_OK) {
1531 printf ("kr_load error %s\n", error_to_string (errnum));
1532 exit (-1);
1533 }
1534 fclose (f);
1535 remove ("ring.dat");
1536 printf ("After load and save...\n");
1537 kr_display (kr);
1538
1539 if ((errnum = kr_clear (&kr)) != CRYPT_OK) {
1540 printf ("clear error: %s\n", error_to_string (errnum));
1541 exit (-1);
1542 }
1543 #endif
1544
1545 /* test the packet encryption/sign stuff */
1546 for (i = 0; i < 32; i++)
1547 buf[i] = i;
1548 kr_test_makekeys (&kr);
1549 _kr = kr;
1550 for (i = 0; i < 3; i++) {
1551 printf ("Testing a key with system %d, type %d:\t", _kr->system,
1552 _kr->key_type);
1553 len = sizeof (buf2);
1554 if ((errnum =
1555 kr_encrypt_key (kr, _kr->ID, buf, 16, buf2, &len, &prng,
1556 find_prng ("yarrow"),
1557 find_hash ("md5"))) != CRYPT_OK) {
1558 printf ("Encrypt error, %d, %s\n", i, error_to_string (errnum));
1559 exit (-1);
1560 }
1561 len = sizeof (buf3);
1562 if ((errnum = kr_decrypt_key (kr, buf2, buf3, &len)) != CRYPT_OK) {
1563 printf ("decrypt error, %d, %s\n", i, error_to_string (errnum));
1564 exit (-1);
1565 }
1566 if (len != 16 || memcmp (buf3, buf, 16)) {
1567 printf ("kr_decrypt_key failed, %i, %lu\n", i, len);
1568 exit (-1);
1569 }
1570 printf ("kr_encrypt_key passed, ");
1571
1572 len = sizeof (buf2);
1573 if ((errnum =
1574 kr_sign_hash (kr, _kr->ID, buf, 32, buf2, &len, &prng,
1575 find_prng ("yarrow"))) != CRYPT_OK) {
1576 printf ("kr_sign_hash failed, %i, %s\n", i, error_to_string (errnum));
1577 exit (-1);
1578 }
1579 printf ("kr_sign_hash: ");
1580 if ((errnum = kr_verify_hash (kr, buf2, buf, 32, &stat)) != CRYPT_OK) {
1581 printf ("kr_sign_hash failed, %i, %s\n", i, error_to_string (errnum));
1582 exit (-1);
1583 }
1584 printf ("%s, ", stat ? "passed" : "failed");
1585 buf[15] ^= 1;
1586 if ((errnum = kr_verify_hash (kr, buf2, buf, 32, &stat)) != CRYPT_OK) {
1587 printf ("kr_sign_hash failed, %i, %s\n", i, error_to_string (errnum));
1588 exit (-1);
1589 }
1590 printf ("%s\n", (!stat) ? "passed" : "failed");
1591 buf[15] ^= 1;
1592
1593 len = sizeof (buf);
1594 if ((errnum =
1595 kr_fingerprint (kr, _kr->ID, find_hash ("sha1"), buf,
1596 &len)) != CRYPT_OK) {
1597 printf ("kr_fingerprint failed, %i, %lu\n", i, len);
1598 exit (-1);
1599 }
1600 printf ("Fingerprint: ");
1601 for (j = 0; j < 20; j++) {
1602 printf ("%02x", buf[j]);
1603 if (j < 19)
1604 printf (":");
1605 }
1606 printf ("\n\n");
1607
1608 _kr = _kr->next;
1609 }
1610
1611 /* Test encrypting/decrypting to a public key */
1612 /* first dump the other two keys */
1613 kr_del (&kr, kr->ID);
1614 kr_del (&kr, kr->ID);
1615 kr_display (kr);
1616
1617 /* now export it as public and private */
1618 len = sizeof (buf);
1619 if ((errnum = kr_export (kr, kr->ID, PK_PUBLIC, buf, &len)) != CRYPT_OK) {
1620 printf ("Error exporting key %d, %s\n", i, error_to_string (errnum));
1621 exit (-1);
1622 }
1623
1624 /* check boundaries */
1625 memset (buf + len, 0, sizeof (buf) - len);
1626
1627 len = sizeof (buf2);
1628 if ((errnum = kr_export (kr, kr->ID, PK_PRIVATE, buf2, &len)) != CRYPT_OK) {
1629 printf ("Error exporting key %s\n", error_to_string (errnum));
1630 exit (-1);
1631 }
1632
1633 /* check boundaries */
1634 memset (buf2 + len, 0, sizeof (buf2) - len);
1635
1636 /* delete the key and import the public */
1637 kr_clear (&kr);
1638 kr_init (&kr);
1639 kr_display (kr);
1640 if ((errnum = kr_import (kr, buf, len)) != CRYPT_OK) {
1641 printf ("Error importing key %s\n", error_to_string (errnum));
1642 exit (-1);
1643 }
1644 kr_display (kr);
1645
1646 /* now encrypt a buffer */
1647 for (i = 0; i < 16; i++)
1648 buf[i] = i;
1649 len = sizeof (buf3);
1650 if ((errnum =
1651 kr_encrypt_key (kr, kr->ID, buf, 16, buf3, &len, &prng,
1652 find_prng ("yarrow"),
1653 find_hash ("md5"))) != CRYPT_OK) {
1654 printf ("Encrypt error, %d, %s\n", i, error_to_string (errnum));
1655 exit (-1);
1656 }
1657
1658 /* now delete the key and import the private one */
1659 kr_clear (&kr);
1660 kr_init (&kr);
1661 kr_display (kr);
1662 if ((errnum = kr_import (kr, buf2, len)) != CRYPT_OK) {
1663 printf ("Error importing key %s\n", error_to_string (errnum));
1664 exit (-1);
1665 }
1666 kr_display (kr);
1667
1668 /* now decrypt */
1669 len = sizeof (buf2);
1670 if ((errnum = kr_decrypt_key (kr, buf3, buf2, &len)) != CRYPT_OK) {
1671 printf ("decrypt error, %s\n", error_to_string (errnum));
1672 exit (-1);
1673 }
1674
1675 printf ("KR encrypt to public, decrypt with private: ");
1676 if (len == 16 && !memcmp (buf2, buf, 16)) {
1677 printf ("passed\n");
1678 } else {
1679 printf ("failed\n");
1680 }
1681
1682 kr_clear (&kr);
1683 }
1684 #endif
1685
1686 void
1687 test_errs (void)
1688 {
1689 #define ERR(x) printf("%25s => %s\n", #x, error_to_string(x));
1690
1691 ERR (CRYPT_OK);
1692 ERR (CRYPT_ERROR);
1693
1694 ERR (CRYPT_INVALID_KEYSIZE);
1695 ERR (CRYPT_INVALID_ROUNDS);
1696 ERR (CRYPT_FAIL_TESTVECTOR);
1697
1698 ERR (CRYPT_BUFFER_OVERFLOW);
1699 ERR (CRYPT_INVALID_PACKET);
1700
1701 ERR (CRYPT_INVALID_PRNGSIZE);
1702 ERR (CRYPT_ERROR_READPRNG);
1703
1704 ERR (CRYPT_INVALID_CIPHER);
1705 ERR (CRYPT_INVALID_HASH);
1706 ERR (CRYPT_INVALID_PRNG);
1707
1708 ERR (CRYPT_MEM);
1709
1710 ERR (CRYPT_PK_TYPE_MISMATCH);
1711 ERR (CRYPT_PK_NOT_PRIVATE);
1712
1713 ERR (CRYPT_INVALID_ARG);
1714 ERR (CRYPT_FILE_NOTFOUND);
1715
1716 ERR (CRYPT_PK_INVALID_TYPE);
1717 ERR (CRYPT_PK_INVALID_SYSTEM);
1718 ERR (CRYPT_PK_DUP);
1719 ERR (CRYPT_PK_NOT_FOUND);
1720 ERR (CRYPT_PK_INVALID_SIZE);
1721
1722 ERR (CRYPT_INVALID_PRIME_SIZE);
1723 }
1724
1725
1726 void dsa_tests(void)
1727 {
1728 unsigned char msg[16], out[1024], out2[1024];
1729 unsigned long x, y;
1730 int err, stat1, stat2;
1731 dsa_key key, key2;
1732
1733 /* make a random key */
1734 if ((err = dsa_make_key(&prng, find_prng("yarrow"), 20, 128, &key)) != CRYPT_OK) {
1735 printf("Error making DSA key: %s\n", error_to_string(err));
1736 exit(-1);
1737 }
1738 printf("DSA Key Made\n");
1739
1740 /* verify it */
1741 if ((err = dsa_verify_key(&key, &stat1)) != CRYPT_OK) {
1742 printf("Error verifying DSA key: %s\n", error_to_string(err));
1743 exit(-1);
1744 }
1745 printf("DSA key verification: %s\n", stat1 == 1 ? "passed" : "failed");
1746 if (stat1 == 0) exit(-1);
1747
1748 /* sign the message */
1749 x = sizeof(out);
1750 if ((err = dsa_sign_hash(msg, sizeof(msg), out, &x, &prng, find_prng("yarrow"), &key)) != CRYPT_OK) {
1751 printf("Error signing with DSA key: %s\n", error_to_string(err));
1752 exit(-1);
1753 }
1754 printf("DSA 160/1024 signature is %lu bytes long\n", x);
1755
1756 /* verify it once */
1757 if ((err = dsa_verify_hash(out, x, msg, sizeof(msg), &stat1, &key)) != CRYPT_OK) {
1758 printf("Error verifying with DSA key 1: %s\n", error_to_string(err));
1759 exit(-1);
1760 }
1761
1762 /* Modify and verify again */
1763 msg[0] ^= 1;
1764 if ((err = dsa_verify_hash(out, x, msg, sizeof(msg), &stat2, &key)) != CRYPT_OK) {
1765 printf("Error verifying with DSA key 2: %s\n", error_to_string(err));
1766 exit(-1);
1767 }
1768 msg[0] ^= 1;
1769 printf("DSA Verification: %d, %d, %s\n", stat1, stat2, (stat1 == 1 && stat2 == 0) ? "passed" : "failed");
1770 if (!(stat1 == 1 && stat2 == 0)) exit(-1);
1771
1772 /* test exporting it */
1773 x = sizeof(out2);
1774 if ((err = dsa_export(out2, &x, PK_PRIVATE, &key)) != CRYPT_OK) {
1775 printf("Error export PK_PRIVATE DSA key: %s\n", error_to_string(err));
1776 exit(-1);
1777 }
1778 printf("Exported PK_PRIVATE DSA key in %lu bytes\n", x);
1779 if ((err = dsa_import(out2, x, &key2)) != CRYPT_OK) {
1780 printf("Error importing PK_PRIVATE DSA key: %s\n", error_to_string(err));
1781 exit(-1);
1782 }
1783 /* verify a signature with it */
1784 if ((err = dsa_verify_hash(out, x, msg, sizeof(msg), &stat1, &key2)) != CRYPT_OK) {
1785 printf("Error verifying with DSA key 3: %s\n", error_to_string(err));
1786 exit(-1);
1787 }
1788 printf("PRIVATE Import Test: %s\n", stat1 == 1 ? "passed" : "failed");
1789 if (stat1 == 0) exit(-1);
1790 dsa_free(&key2);
1791
1792 /* export as public now */
1793 x = sizeof(out2);
1794 if ((err = dsa_export(out2, &x, PK_PUBLIC, &key)) != CRYPT_OK) {
1795 printf("Error export PK_PUBLIC DSA key: %s\n", error_to_string(err));
1796 exit(-1);
1797 }
1798 printf("Exported PK_PUBLIC DSA key in %lu bytes\n", x);
1799 if ((err = dsa_import(out2, x, &key2)) != CRYPT_OK) {
1800 printf("Error importing PK_PUBLIC DSA key: %s\n", error_to_string(err));
1801 exit(-1);
1802 }
1803 /* verify a signature with it */
1804 if ((err = dsa_verify_hash(out, x, msg, sizeof(msg), &stat1, &key2)) != CRYPT_OK) {
1805 printf("Error verifying with DSA key 4: %s\n", error_to_string(err));
1806 exit(-1);
1807 }
1808 printf("PUBLIC Import Test: %s\n", stat1 == 1 ? "passed" : "failed");
1809 if (stat1 == 0) exit(-1);
1810
1811 dsa_free(&key2);
1812 dsa_free(&key);
1813 }
1814
1815 #ifdef PKCS_1
1816 void pkcs1_test(void)
1817 {
1818 unsigned char buf[3][128];
1819 int err, res1, res2, res3, prng_idx, hash_idx;
1820 unsigned long x, y, l1, l2, l3, i1, i2;
1821
1822 /* get hash/prng */
1823 hash_idx = find_hash("sha1");
1824 prng_idx = find_prng("yarrow");
1825
1826 /* do many tests */
1827 for (x = 0; x < 10000; x++) {
1828 zeromem(buf, sizeof(buf));
1829
1830 /* make a dummy message (of random length) */
1831 l3 = (rand() & 31) + 8;
1832 for (y = 0; y < l3; y++) buf[0][y] = rand() & 255;
1833
1834 /* encode it */
1835 l1 = sizeof(buf[1]);
1836 if ((err = pkcs_1_oaep_encode(buf[0], l3, NULL, 0, 1024, hash_idx, prng_idx, &prng, buf[1], &l1)) != CRYPT_OK) {
1837 printf("OAEP encode: %s\n", error_to_string(err));
1838 exit(-1);
1839 }
1840
1841 /* decode it */
1842 l2 = sizeof(buf[2]);
1843 if ((err = pkcs_1_oaep_decode(buf[1], l1, NULL, 0, 1024, hash_idx, buf[2], &l2)) != CRYPT_OK) {
1844 printf("OAEP decode: %s\n", error_to_string(err));
1845 exit(-1);
1846 }
1847
1848 if (l2 != l3 || memcmp(buf[2], buf[0], l3) != 0) {
1849 printf("Outsize == %lu, should have been %lu, msg contents follow.\n", l2, l3);
1850 printf("ORIGINAL:\n");
1851 for (x = 0; x < l3; x++) {
1852 printf("%02x ", buf[0][x]);
1853 }
1854 printf("\nRESULT:\n");
1855 for (x = 0; x < l2; x++) {
1856 printf("%02x ", buf[2][x]);
1857 }
1858 printf("\n\n");
1859 exit(-1);
1860 }
1861
1862 /* test PSS */
1863 l1 = sizeof(buf[1]);
1864 if ((err = pkcs_1_pss_encode(buf[0], l3, l3>>2, hash_idx, prng_idx, &prng, 1024, buf[1], &l1)) != CRYPT_OK) {
1865 printf("PSS encode: %s\n", error_to_string(err));
1866 exit(-1);
1867 }
1868
1869 if ((err = pkcs_1_pss_decode(buf[0], l3, buf[1], l1, l3>>2, hash_idx, 1024, &res1)) != CRYPT_OK) {
1870 printf("PSS decode1: %s\n", error_to_string(err));
1871 exit(-1);
1872 }
1873
1874 buf[0][i1 = abs(rand()) % l3] ^= 1;
1875 if ((err = pkcs_1_pss_decode(buf[0], l3, buf[1], l1, l3>>2, hash_idx, 1024, &res2)) != CRYPT_OK) {
1876 printf("PSS decode2: %s\n", error_to_string(err));
1877 exit(-1);
1878 }
1879
1880 buf[0][i1] ^= 1;
1881 buf[1][i2 = abs(rand()) % l1] ^= 1;
1882 if ((err = pkcs_1_pss_decode(buf[0], l3, buf[1], l1, l3>>2, hash_idx, 1024, &res3)) != CRYPT_OK) {
1883 printf("PSS decode3: %s\n", error_to_string(err));
1884 exit(-1);
1885 }
1886
1887 if (!(res1 == 1 && res2 == 0 && res3 == 0)) {
1888 printf("PSS failed: %d, %d, %d, %lu\n", res1, res2, res3, l3);
1889 exit(-1);
1890 }
1891 }
1892 printf("PKCS #1: Passed\n");
1893 }
1894
1895 #endif /* PKCS_1 */
1896
1897 int
1898 main (void)
1899 {
1900 #ifdef SONY_PS2
1901 TIMER_Init ();
1902 #endif
1903 srand(time(NULL));
1904
1905 register_all_algs ();
1906
1907 if ((errnum = yarrow_start (&prng)) != CRYPT_OK) {
1908 printf ("yarrow_start: %s\n", error_to_string (errnum));
1909 }
1910 if ((errnum = yarrow_add_entropy ((unsigned char *)"hello", 5, &prng)) != CRYPT_OK) {
1911 printf ("yarrow_add_entropy: %s\n", error_to_string (errnum));
1912 }
1913 if ((errnum = yarrow_ready (&prng)) != CRYPT_OK) {
1914 printf ("yarrow_ready: %s\n", error_to_string (errnum));
1915 }
1916
1917 printf (crypt_build_settings);
1918 test_errs ();
1919
1920 #ifdef HMAC
1921 printf ("HMAC: %s\n", hmac_test () == CRYPT_OK ? "passed" : "failed");
1922 if (hmac_test() != CRYPT_OK) exit(EXIT_FAILURE);
1923 #endif
1924
1925 #ifdef OMAC
1926 printf ("OMAC: %s\n", omac_test () == CRYPT_OK ? "passed" : "failed");
1927 if (omac_test() != CRYPT_OK) exit(EXIT_FAILURE);
1928 #endif
1929
1930 #ifdef PMAC
1931 printf ("PMAC: %s\n", pmac_test () == CRYPT_OK ? "passed" : "failed");
1932 if (pmac_test() != CRYPT_OK) exit(EXIT_FAILURE);
1933 #endif
1934
1935 #ifdef EAX_MODE
1936 printf ("EAX : %s\n", eax_test () == CRYPT_OK ? "passed" : "failed");
1937 if (eax_test() != CRYPT_OK) exit(EXIT_FAILURE);
1938 #endif
1939
1940 #ifdef OCB_MODE
1941 printf ("OCB : %s\n", ocb_test () == CRYPT_OK ? "passed" : "failed");
1942 if (ocb_test() != CRYPT_OK) exit(EXIT_FAILURE);
1943 #endif
1944
1945 store_tests ();
1946 cipher_tests ();
1947 hash_tests ();
1948
1949 #ifdef PKCS_1
1950 pkcs1_test();
1951 #endif
1952
1953 ecb_tests ();
1954 cbc_tests ();
1955 ctr_tests ();
1956 ofb_tests ();
1957 cfb_tests ();
1958
1959 rng_tests ();
1960 test_prime();
1961
1962 #ifdef KR
1963 kr_test ();
1964 #endif
1965 dsa_tests();
1966 rsa_test ();
1967 pad_test ();
1968 ecc_tests ();
1969 dh_tests ();
1970
1971 gf_tests ();
1972 base64_test ();
1973
1974 time_ecb ();
1975 time_hash ();
1976
1977 #ifdef SONY_PS2
1978 TIMER_Shutdown ();
1979 #endif
1980
1981 return 0;
1982 }