Update pairwise consistency checks to use SHA-256.
[openssl.git] / fips / fips_test_suite.c
1 /* ====================================================================
2  * Copyright (c) 2003 The OpenSSL Project.  All rights reserved.
3  *
4  *
5  * This command is intended as a test driver for the FIPS-140 testing
6  * lab performing FIPS-140 validation.  It demonstrates the use of the
7  * OpenSSL library ito perform a variety of common cryptographic
8  * functions.  A power-up self test is demonstrated by deliberately
9  * pointing to an invalid executable hash
10  *
11  * Contributed by Steve Marquess.
12  *
13  */
14
15 #define OPENSSL_FIPSAPI
16
17 #include <stdio.h>
18 #include <assert.h>
19 #include <ctype.h>
20 #include <string.h>
21 #include <stdlib.h>
22 #include <openssl/evp.h>
23 #include <openssl/hmac.h>
24 #include <openssl/sha.h>
25 #include <openssl/err.h>
26
27 #include <openssl/bn.h>
28 #include <openssl/rand.h>
29
30 #ifndef OPENSSL_FIPS
31 int main(int argc, char *argv[])
32     {
33     printf("No FIPS support\n");
34     return(0);
35     }
36 #else
37
38 #define ERR_clear_error() while(0)
39
40 #include <openssl/rsa.h>
41 #include <openssl/dsa.h>
42 #include <openssl/dh.h>
43
44 #include <openssl/fips.h>
45 #include "fips_utl.h"
46
47 /* AES: encrypt and decrypt known plaintext, verify result matches original plaintext
48 */
49 static int FIPS_aes_test(void)
50         {
51         int ret = 0;
52         unsigned char pltmp[16];
53         unsigned char citmp[16];
54         unsigned char key[16] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
55         unsigned char plaintext[16] = "etaonrishdlcu";
56         EVP_CIPHER_CTX ctx;
57         FIPS_cipher_ctx_init(&ctx);
58         if (FIPS_cipherinit(&ctx, EVP_aes_128_ecb(), key, NULL, 1) <= 0)
59                 goto err;
60         FIPS_cipher(&ctx, citmp, plaintext, 16);
61         if (FIPS_cipherinit(&ctx, EVP_aes_128_ecb(), key, NULL, 0) <= 0)
62                 goto err;
63         FIPS_cipher(&ctx, pltmp, citmp, 16);
64         if (memcmp(pltmp, plaintext, 16))
65                 goto err;
66         ret = 1;
67         err:
68         FIPS_cipher_ctx_cleanup(&ctx);
69         return ret;
70         }
71
72 static int FIPS_des3_test(void)
73         {
74         int ret = 0;
75         unsigned char pltmp[8];
76         unsigned char citmp[8];
77         unsigned char key[] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,
78                               19,20,21,22,23,24};
79         unsigned char plaintext[] = { 'e', 't', 'a', 'o', 'n', 'r', 'i', 's' };
80         EVP_CIPHER_CTX ctx;
81         FIPS_cipher_ctx_init(&ctx);
82         if (FIPS_cipherinit(&ctx, EVP_des_ede3_ecb(), key, NULL, 1) <= 0)
83                 goto err;
84         FIPS_cipher(&ctx, citmp, plaintext, 8);
85         if (FIPS_cipherinit(&ctx, EVP_des_ede3_ecb(), key, NULL, 0) <= 0)
86                 goto err;
87         FIPS_cipher(&ctx, pltmp, citmp, 8);
88         if (memcmp(pltmp, plaintext, 8))
89                 goto err;
90         ret = 1;
91         err:
92         FIPS_cipher_ctx_cleanup(&ctx);
93         return ret;
94         }
95
96 /*
97  * DSA: generate keys and sign, verify input plaintext.
98  */
99 static int FIPS_dsa_test(int bad)
100     {
101     DSA *dsa = NULL;
102     unsigned char dgst[] = "etaonrishdlc";
103     int r = 0;
104     EVP_MD_CTX mctx;
105     DSA_SIG *sig = NULL;
106
107     ERR_clear_error();
108     FIPS_md_ctx_init(&mctx);
109     dsa = FIPS_dsa_new();
110     if (!dsa)
111         goto end;
112     if (!DSA_generate_parameters_ex(dsa, 1024,NULL,0,NULL,NULL,NULL))
113         goto end;
114     if (!DSA_generate_key(dsa))
115         goto end;
116     if (bad)
117             BN_add_word(dsa->pub_key, 1);
118
119     if (!FIPS_digestinit(&mctx, EVP_sha1()))
120         goto end;
121     if (!FIPS_digestupdate(&mctx, dgst, sizeof(dgst) - 1))
122         goto end;
123     sig = FIPS_dsa_sign_ctx(dsa, &mctx);
124     if (!sig)
125         goto end;
126
127     if (!FIPS_digestinit(&mctx, EVP_sha1()))
128         goto end;
129     if (!FIPS_digestupdate(&mctx, dgst, sizeof(dgst) - 1))
130         goto end;
131     r = FIPS_dsa_verify_ctx(dsa, &mctx, sig);
132     end:
133     if (sig)
134         FIPS_dsa_sig_free(sig);
135     FIPS_md_ctx_cleanup(&mctx);
136     if (dsa)
137           FIPS_dsa_free(dsa);
138     if (r != 1)
139         return 0;
140     return 1;
141     }
142
143 /*
144  * RSA: generate keys and sign, verify input plaintext.
145  */
146 static int FIPS_rsa_test(int bad)
147     {
148     RSA *key;
149     unsigned char input_ptext[] = "etaonrishdlc";
150     unsigned char buf[256];
151     unsigned int slen;
152     BIGNUM *bn;
153     EVP_MD_CTX mctx;
154     int r = 0;
155
156     ERR_clear_error();
157     FIPS_md_ctx_init(&mctx);
158     key = FIPS_rsa_new();
159     bn = BN_new();
160     if (!key || !bn)
161         return 0;
162     BN_set_word(bn, 65537);
163     if (!RSA_generate_key_ex(key, 1024,bn,NULL))
164         return 0;
165     BN_free(bn);
166     if (bad)
167             BN_add_word(key->n, 1);
168
169     if (!FIPS_digestinit(&mctx, EVP_sha1()))
170         goto end;
171     if (!FIPS_digestupdate(&mctx, input_ptext, sizeof(input_ptext) - 1))
172         goto end;
173     if (!FIPS_rsa_sign_ctx(key, &mctx, RSA_PKCS1_PADDING, 0, NULL, buf, &slen))
174         goto end;
175
176     if (!FIPS_digestinit(&mctx, EVP_sha1()))
177         goto end;
178     if (!FIPS_digestupdate(&mctx, input_ptext, sizeof(input_ptext) - 1))
179         goto end;
180     r = FIPS_rsa_verify_ctx(key, &mctx, RSA_PKCS1_PADDING, 0, NULL, buf, slen);
181     end:
182     FIPS_md_ctx_cleanup(&mctx);
183     if (key)
184           FIPS_rsa_free(key);
185     if (r != 1)
186         return 0;
187     return 1;
188     }
189
190 /* SHA1: generate hash of known digest value and compare to known
191    precomputed correct hash
192 */
193 static int FIPS_sha1_test()
194     {
195     unsigned char digest[SHA_DIGEST_LENGTH] =
196         { 0x11, 0xf1, 0x9a, 0x3a, 0xec, 0x1a, 0x1e, 0x8e, 0x65, 0xd4, 0x9a, 0x38, 0x0c, 0x8b, 0x1e, 0x2c, 0xe8, 0xb3, 0xc5, 0x18 };
197     unsigned char str[] = "etaonrishd";
198
199     unsigned char md[SHA_DIGEST_LENGTH];
200
201     ERR_clear_error();
202     if (!FIPS_digest(str,sizeof(str) - 1,md, NULL, EVP_sha1())) return 0;
203     if (memcmp(md,digest,sizeof(md)))
204         return 0;
205     return 1;
206     }
207
208 /* SHA256: generate hash of known digest value and compare to known
209    precomputed correct hash
210 */
211 static int FIPS_sha256_test()
212     {
213     unsigned char digest[SHA256_DIGEST_LENGTH] =
214         {0xf5, 0x53, 0xcd, 0xb8, 0xcf, 0x1, 0xee, 0x17, 0x9b, 0x93, 0xc9, 0x68, 0xc0, 0xea, 0x40, 0x91,
215          0x6, 0xec, 0x8e, 0x11, 0x96, 0xc8, 0x5d, 0x1c, 0xaf, 0x64, 0x22, 0xe6, 0x50, 0x4f, 0x47, 0x57};
216     unsigned char str[] = "etaonrishd";
217
218     unsigned char md[SHA256_DIGEST_LENGTH];
219
220     ERR_clear_error();
221     if (!FIPS_digest(str,sizeof(str) - 1,md, NULL, EVP_sha256())) return 0;
222     if (memcmp(md,digest,sizeof(md)))
223         return 0;
224     return 1;
225     }
226
227 /* SHA512: generate hash of known digest value and compare to known
228    precomputed correct hash
229 */
230 static int FIPS_sha512_test()
231     {
232     unsigned char digest[SHA512_DIGEST_LENGTH] =
233         {0x99, 0xc9, 0xe9, 0x5b, 0x88, 0xd4, 0x78, 0x88, 0xdf, 0x88, 0x5f, 0x94, 0x71, 0x64, 0x28, 0xca,
234          0x16, 0x1f, 0x3d, 0xf4, 0x1f, 0xf3, 0x0f, 0xc5, 0x03, 0x99, 0xb2, 0xd0, 0xe7, 0x0b, 0x94, 0x4a,
235          0x45, 0xd2, 0x6c, 0x4f, 0x20, 0x06, 0xef, 0x71, 0xa9, 0x25, 0x7f, 0x24, 0xb1, 0xd9, 0x40, 0x22,
236          0x49, 0x54, 0x10, 0xc2, 0x22, 0x9d, 0x27, 0xfe, 0xbd, 0xd6, 0xd6, 0xeb, 0x2d, 0x42, 0x1d, 0xa3};
237     unsigned char str[] = "etaonrishd";
238
239     unsigned char md[SHA512_DIGEST_LENGTH];
240
241     ERR_clear_error();
242     if (!FIPS_digest(str,sizeof(str) - 1,md, NULL, EVP_sha512())) return 0;
243     if (memcmp(md,digest,sizeof(md)))
244         return 0;
245     return 1;
246     }
247
248 /* HMAC-SHA1: generate hash of known digest value and compare to known
249    precomputed correct hash
250 */
251 static int FIPS_hmac_sha1_test()
252     {
253     unsigned char key[] = "etaonrishd";
254     unsigned char iv[] = "Sample text";
255     unsigned char kaval[EVP_MAX_MD_SIZE] =
256         {0x73, 0xf7, 0xa0, 0x48, 0xf8, 0x94, 0xed, 0xdd, 0x0a, 0xea, 0xea, 0x56, 0x1b, 0x61, 0x2e, 0x70,
257          0xb2, 0xfb, 0xec, 0xc6};
258
259     unsigned char out[EVP_MAX_MD_SIZE];
260     unsigned int outlen;
261
262     ERR_clear_error();
263     if (!HMAC(EVP_sha1(),key,sizeof(key)-1,iv,sizeof(iv)-1,out,&outlen)) return 0;
264     if (memcmp(out,kaval,outlen))
265         return 0;
266     return 1;
267     }
268
269 /* HMAC-SHA224: generate hash of known digest value and compare to known
270    precomputed correct hash
271 */
272 static int FIPS_hmac_sha224_test()
273     {
274     unsigned char key[] = "etaonrishd";
275     unsigned char iv[] = "Sample text";
276     unsigned char kaval[EVP_MAX_MD_SIZE] =
277         {0x75, 0x58, 0xd5, 0xbd, 0x55, 0x6d, 0x87, 0x0f, 0x75, 0xff, 0xbe, 0x1c, 0xb2, 0xf0, 0x20, 0x35,
278          0xe5, 0x62, 0x49, 0xb6, 0x94, 0xb9, 0xfc, 0x65, 0x34, 0x33, 0x3a, 0x19};
279
280     unsigned char out[EVP_MAX_MD_SIZE];
281     unsigned int outlen;
282
283     ERR_clear_error();
284     if (!HMAC(EVP_sha224(),key,sizeof(key)-1,iv,sizeof(iv)-1,out,&outlen)) return 0;
285     if (memcmp(out,kaval,outlen))
286         return 0;
287     return 1;
288     }
289
290 /* HMAC-SHA256: generate hash of known digest value and compare to known
291    precomputed correct hash
292 */
293 static int FIPS_hmac_sha256_test()
294     {
295     unsigned char key[] = "etaonrishd";
296     unsigned char iv[] = "Sample text";
297     unsigned char kaval[EVP_MAX_MD_SIZE] =
298         {0xe9, 0x17, 0xc1, 0x7b, 0x4c, 0x6b, 0x77, 0xda, 0xd2, 0x30, 0x36, 0x02, 0xf5, 0x72, 0x33, 0x87,
299          0x9f, 0xc6, 0x6e, 0x7b, 0x7e, 0xa8, 0xea, 0xaa, 0x9f, 0xba, 0xee, 0x51, 0xff, 0xda, 0x24, 0xf4};
300
301     unsigned char out[EVP_MAX_MD_SIZE];
302     unsigned int outlen;
303
304     ERR_clear_error();
305     if (!HMAC(EVP_sha256(),key,sizeof(key)-1,iv,sizeof(iv)-1,out,&outlen)) return 0;
306     if (memcmp(out,kaval,outlen))
307         return 0;
308     return 1;
309     }
310
311 /* HMAC-SHA384: generate hash of known digest value and compare to known
312    precomputed correct hash
313 */
314 static int FIPS_hmac_sha384_test()
315     {
316     unsigned char key[] = "etaonrishd";
317     unsigned char iv[] = "Sample text";
318     unsigned char kaval[EVP_MAX_MD_SIZE] =
319         {0xb2, 0x9d, 0x40, 0x58, 0x32, 0xc4, 0xe3, 0x31, 0xb6, 0x63, 0x08, 0x26, 0x99, 0xef, 0x3b, 0x10,
320          0xe2, 0xdf, 0xf8, 0xff, 0xc6, 0xe1, 0x03, 0x29, 0x81, 0x2a, 0x1b, 0xac, 0xb0, 0x07, 0x39, 0x08,
321          0xf3, 0x91, 0x35, 0x11, 0x76, 0xd6, 0x4c, 0x20, 0xfb, 0x4d, 0xc3, 0xf3, 0xb8, 0x9b, 0x88, 0x1c};
322
323     unsigned char out[EVP_MAX_MD_SIZE];
324     unsigned int outlen;
325
326     ERR_clear_error();
327     if (!HMAC(EVP_sha384(),key,sizeof(key)-1,iv,sizeof(iv)-1,out,&outlen)) return 0;
328     if (memcmp(out,kaval,outlen))
329         return 0;
330     return 1;
331     }
332
333 /* HMAC-SHA512: generate hash of known digest value and compare to known
334    precomputed correct hash
335 */
336 static int FIPS_hmac_sha512_test()
337     {
338     unsigned char key[] = "etaonrishd";
339     unsigned char iv[] = "Sample text";
340     unsigned char kaval[EVP_MAX_MD_SIZE] =
341         {0xcd, 0x3e, 0xb9, 0x51, 0xb8, 0xbc, 0x7f, 0x9a, 0x23, 0xaf, 0xf3, 0x77, 0x59, 0x85, 0xa9, 0xe6,
342          0xf7, 0xd1, 0x51, 0x96, 0x17, 0xe0, 0x92, 0xd8, 0xa6, 0x3b, 0xc1, 0xad, 0x7e, 0x24, 0xca, 0xb1,
343          0xd7, 0x79, 0x0a, 0xa5, 0xea, 0x2c, 0x02, 0x58, 0x0b, 0xa6, 0x52, 0x6b, 0x61, 0x7f, 0xeb, 0x9c,
344          0x47, 0x86, 0x5d, 0x74, 0x2b, 0x88, 0xdf, 0xee, 0x46, 0x69, 0x96, 0x3d, 0xa6, 0xd9, 0x2a, 0x53};
345
346     unsigned char out[EVP_MAX_MD_SIZE];
347     unsigned int outlen;
348
349     ERR_clear_error();
350     if (!HMAC(EVP_sha512(),key,sizeof(key)-1,iv,sizeof(iv)-1,out,&outlen)) return 0;
351     if (memcmp(out,kaval,outlen))
352         return 0;
353     return 1;
354     }
355
356
357 /* DH: generate shared parameters
358 */
359 static int dh_test()
360     {
361     DH *dh;
362     ERR_clear_error();
363     dh = FIPS_dh_new();
364     if (!dh)
365         return 0;
366     if (!DH_generate_parameters_ex(dh, 1024, 2, NULL))
367         return 0;
368     FIPS_dh_free(dh);
369     return 1;
370     }
371
372 /* Zeroize
373 */
374 static int Zeroize()
375     {
376     RSA *key;
377     BIGNUM *bn;
378     unsigned char userkey[16] = 
379         { 0x48, 0x50, 0xf0, 0xa3, 0x3a, 0xed, 0xd3, 0xaf, 0x6e, 0x47, 0x7f, 0x83, 0x02, 0xb1, 0x09, 0x68 };
380     size_t i;
381     int n;
382
383     key = FIPS_rsa_new();
384     bn = BN_new();
385     if (!key || !bn)
386         return 0;
387     BN_set_word(bn, 65537);
388     if (!RSA_generate_key_ex(key, 1024,bn,NULL))
389         return 0;
390     BN_free(bn);
391     
392     n = BN_num_bytes(key->d);
393     printf(" Generated %d byte RSA private key\n", n);
394     printf("\tBN key before overwriting:\n");
395     do_bn_print(stdout, key->d);
396     BN_rand(key->d,n*8,-1,0);
397     printf("\tBN key after overwriting:\n");
398     do_bn_print(stdout, key->d);
399
400     printf("\tchar buffer key before overwriting: \n\t\t");
401     for(i = 0; i < sizeof(userkey); i++) printf("%02x", userkey[i]);
402         printf("\n");
403     RAND_bytes(userkey, sizeof userkey);
404     printf("\tchar buffer key after overwriting: \n\t\t");
405     for(i = 0; i < sizeof(userkey); i++) printf("%02x", userkey[i]);
406         printf("\n");
407
408     return 1;
409     }
410
411 static int Error;
412 static const char * Fail(const char *msg)
413     {
414     Error++;
415     return msg; 
416     }
417
418 static void test_msg(const char *msg, int result)
419         {
420         printf("%s...%s\n", msg, result ? "successful" : Fail("Failed!"));
421         }
422
423 int main(int argc,char **argv)
424     {
425
426     int do_corrupt_rsa_keygen = 0, do_corrupt_dsa_keygen = 0;
427     int bad_rsa = 0, bad_dsa = 0;
428     int do_rng_stick = 0;
429     int no_exit = 0;
430
431     fips_set_error_print();
432
433     printf("\tFIPS-mode test application\n\n");
434
435     /* Load entropy from external file, if any */
436     RAND_load_file(".rnd", 1024);
437
438     if (argv[1]) {
439         /* Corrupted KAT tests */
440         if (!strcmp(argv[1], "aes")) {
441             FIPS_corrupt_aes();
442             printf("AES encryption/decryption with corrupted KAT...\n");
443         } else if (!strcmp(argv[1], "des")) {
444             FIPS_corrupt_des();
445             printf("DES3-ECB encryption/decryption with corrupted KAT...\n");
446         } else if (!strcmp(argv[1], "dsa")) {
447             FIPS_corrupt_dsa();
448             printf("DSA key generation and signature validation with corrupted KAT...\n");
449         } else if (!strcmp(argv[1], "rsa")) {
450             FIPS_corrupt_rsa();
451             printf("RSA key generation and signature validation with corrupted KAT...\n");
452         } else if (!strcmp(argv[1], "rsakey")) {
453             printf("RSA key generation and signature validation with corrupted key...\n");
454             bad_rsa = 1;
455             no_exit = 1;
456         } else if (!strcmp(argv[1], "rsakeygen")) {
457             do_corrupt_rsa_keygen = 1;
458             no_exit = 1;
459             printf("RSA key generation and signature validation with corrupted keygen...\n");
460         } else if (!strcmp(argv[1], "dsakey")) {
461             printf("DSA key generation and signature validation with corrupted key...\n");
462             bad_dsa = 1;
463             no_exit = 1;
464         } else if (!strcmp(argv[1], "dsakeygen")) {
465             do_corrupt_dsa_keygen = 1;
466             no_exit = 1;
467             printf("DSA key generation and signature validation with corrupted keygen...\n");
468         } else if (!strcmp(argv[1], "sha1")) {
469             FIPS_corrupt_sha1();
470             printf("SHA-1 hash with corrupted KAT...\n");
471         } else if (!strcmp(argv[1], "rng")) {
472             FIPS_corrupt_rng();
473         } else if (!strcmp(argv[1], "rngstick")) {
474             do_rng_stick = 1;
475             no_exit = 1;
476             printf("RNG test with stuck continuous test...\n");
477         } else {
478             printf("Bad argument \"%s\"\n", argv[1]);
479             exit(1);
480         }
481         if (!no_exit) {
482                 if (!FIPS_mode_set(1)) {
483                     printf("Power-up self test failed\n");
484                     exit(1);
485                 }
486                 printf("Power-up self test successful\n");
487                 exit(0);
488         }
489     }
490
491     /* Non-Approved cryptographic operation
492     */
493     printf("1. Non-Approved cryptographic operation test...\n");
494     test_msg("\ta. Included algorithm (D-H)...", dh_test());
495
496     /* Power-up self test
497     */
498     ERR_clear_error();
499     test_msg("2. Automatic power-up self test", FIPS_mode_set(1));
500     if (!FIPS_mode())
501         exit(1);
502     if (do_corrupt_dsa_keygen)
503             FIPS_corrupt_dsa_keygen();
504     if (do_corrupt_rsa_keygen)
505             FIPS_corrupt_rsa_keygen();
506     if (do_rng_stick)
507             FIPS_rng_stick();
508
509     /* AES encryption/decryption
510     */
511     test_msg("3. AES encryption/decryption", FIPS_aes_test());
512
513     /* RSA key generation and encryption/decryption
514     */
515     test_msg("4. RSA key generation and encryption/decryption",
516                                                 FIPS_rsa_test(bad_rsa));
517
518     /* DES-CBC encryption/decryption
519     */
520     test_msg("5. DES-ECB encryption/decryption", FIPS_des3_test());
521
522     /* DSA key generation and signature validation
523     */
524     test_msg("6. DSA key generation and signature validation",
525                                                 FIPS_dsa_test(bad_dsa));
526
527     /* SHA-1 hash
528     */
529     test_msg("7a. SHA-1 hash", FIPS_sha1_test());
530
531     /* SHA-256 hash
532     */
533     test_msg("7b. SHA-256 hash", FIPS_sha256_test());
534
535     /* SHA-512 hash
536     */
537     test_msg("7c. SHA-512 hash", FIPS_sha512_test());
538
539     /* HMAC-SHA-1 hash
540     */
541     test_msg("7d. HMAC-SHA-1 hash", FIPS_hmac_sha1_test());
542
543     /* HMAC-SHA-224 hash
544     */
545     test_msg("7e. HMAC-SHA-224 hash", FIPS_hmac_sha224_test());
546
547     /* HMAC-SHA-256 hash
548     */
549     test_msg("7f. HMAC-SHA-256 hash", FIPS_hmac_sha256_test());
550
551     /* HMAC-SHA-384 hash
552     */
553     test_msg("7g. HMAC-SHA-384 hash", FIPS_hmac_sha384_test());
554
555     /* HMAC-SHA-512 hash
556     */
557     test_msg("7h. HMAC-SHA-512 hash", FIPS_hmac_sha512_test());
558
559     /* Non-Approved cryptographic operation
560     */
561     printf("8. Non-Approved cryptographic operation test...\n");
562     printf("\ta. Included algorithm (D-H)...%s\n",
563                 dh_test() ? "successful as expected"
564                                                 : Fail("failed INCORRECTLY!") );
565
566     /* Zeroization
567     */
568     printf("9. Zero-ization...\n\t%s\n",
569                 Zeroize() ? "successful as expected"
570                                         : Fail("failed INCORRECTLY!") );
571
572     printf("\nAll tests completed with %d errors\n", Error);
573     return Error ? 1 : 0;
574     }
575
576 #endif