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