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