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 #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(void)
  44         {
  45         int ret = 0;
  46         unsigned char pltmp[16];
  47         unsigned char citmp[16];
  48         unsigned char key[16] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
  49         unsigned char plaintext[16] = "etaonrishdlcu";
  50         EVP_CIPHER_CTX ctx;
  51         EVP_CIPHER_CTX_init(&ctx);
  52         if (EVP_CipherInit_ex(&ctx, EVP_aes_128_ecb(),NULL, key, NULL, 1) <= 0)
  53                 goto err;
  54         EVP_Cipher(&ctx, citmp, plaintext, 16);
  55         if (EVP_CipherInit_ex(&ctx, EVP_aes_128_ecb(),NULL, key, NULL, 0) <= 0)
  56                 goto err;
  57         EVP_Cipher(&ctx, pltmp, citmp, 16);
  58         if (memcmp(pltmp, plaintext, 16))
  59                 goto err;
  60         ret = 1;
  61         err:
  62         EVP_CIPHER_CTX_cleanup(&ctx);
  63         return ret;
  64         }
  65
  66 static int FIPS_des3_test(void)
  67         {
  68         int ret = 0;
  69         unsigned char pltmp[8];
  70         unsigned char citmp[8];
  71         unsigned char key[] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,
  72                               19,20,21,22,23,24};
  73         unsigned char plaintext[] = { 'e', 't', 'a', 'o', 'n', 'r', 'i', 's' };
  74         EVP_CIPHER_CTX ctx;
  75         EVP_CIPHER_CTX_init(&ctx);
  76         if (EVP_CipherInit_ex(&ctx, EVP_des_ede3_ecb(),NULL, key, NULL, 1) <= 0)
  77                 goto err;
  78         EVP_Cipher(&ctx, citmp, plaintext, 8);
  79         if (EVP_CipherInit_ex(&ctx, EVP_des_ede3_ecb(),NULL, key, NULL, 0) <= 0)
  80                 goto err;
  81         EVP_Cipher(&ctx, pltmp, citmp, 8);
  82         if (memcmp(pltmp, plaintext, 8))
  83                 goto err;
  84         ret = 1;
  85         err:
  86         EVP_CIPHER_CTX_cleanup(&ctx);
  87         return ret;
  88         }
  89
  90 /*
  91  * DSA: generate keys and sign, verify input plaintext.
  92  */
  93 static int FIPS_dsa_test(int bad)
  94     {
  95     DSA *dsa = NULL;
  96     EVP_PKEY pk;
  97     unsigned char dgst[] = "etaonrishdlc";
  98     unsigned char buf[60];
  99     unsigned int slen;
 100     int r = 0;
 101     EVP_MD_CTX mctx;
 102
 103     ERR_clear_error();
 104     EVP_MD_CTX_init(&mctx);
 105     dsa = FIPS_dsa_new();
 106     if (!dsa)
 107         goto end;
 108     if (!DSA_generate_parameters_ex(dsa, 1024,NULL,0,NULL,NULL,NULL))
 109         goto end;
 110     if (!DSA_generate_key(dsa))
 111         goto end;
 112     if (bad)
 113             BN_add_word(dsa->pub_key, 1);
 114
 115     pk.type = EVP_PKEY_DSA;
 116     pk.pkey.dsa = dsa;
 117
 118     if (!EVP_SignInit_ex(&mctx, EVP_dss1(), NULL))
 119         goto end;
 120     if (!EVP_SignUpdate(&mctx, dgst, sizeof(dgst) - 1))
 121         goto end;
 122     if (!EVP_SignFinal(&mctx, buf, &slen, &pk))
 123         goto end;
 124
 125     if (!EVP_VerifyInit_ex(&mctx, EVP_dss1(), NULL))
 126         goto end;
 127     if (!EVP_VerifyUpdate(&mctx, dgst, sizeof(dgst) - 1))
 128         goto end;
 129     r = EVP_VerifyFinal(&mctx, buf, slen, &pk);
 130     end:
 131     EVP_MD_CTX_cleanup(&mctx);
 132     if (dsa)
 133           FIPS_dsa_free(dsa);
 134     if (r != 1)
 135         return 0;
 136     return 1;
 137     }
 138
 139 /*
 140  * RSA: generate keys and sign, verify input plaintext.
 141  */
 142 static int FIPS_rsa_test(int bad)
 143     {
 144     RSA *key;
 145     unsigned char input_ptext[] = "etaonrishdlc";
 146     unsigned char buf[256];
 147     unsigned int slen;
 148     BIGNUM *bn;
 149     EVP_MD_CTX mctx;
 150     EVP_PKEY pk;
 151     int r = 0;
 152
 153     ERR_clear_error();
 154     EVP_MD_CTX_init(&mctx);
 155     key = FIPS_rsa_new();
 156     bn = BN_new();
 157     if (!key || !bn)
 158         return 0;
 159     BN_set_word(bn, 65537);
 160     if (!RSA_generate_key_ex(key, 1024,bn,NULL))
 161         return 0;
 162     BN_free(bn);
 163     if (bad)
 164             BN_add_word(key->n, 1);
 165
 166     pk.type = EVP_PKEY_RSA;
 167     pk.pkey.rsa = key;
 168
 169     if (!EVP_SignInit_ex(&mctx, EVP_sha1(), NULL))
 170         goto end;
 171     if (!EVP_SignUpdate(&mctx, input_ptext, sizeof(input_ptext) - 1))
 172         goto end;
 173     if (!EVP_SignFinal(&mctx, buf, &slen, &pk))
 174         goto end;
 175
 176     if (!EVP_VerifyInit_ex(&mctx, EVP_sha1(), NULL))
 177         goto end;
 178     if (!EVP_VerifyUpdate(&mctx, input_ptext, sizeof(input_ptext) - 1))
 179         goto end;
 180     r = EVP_VerifyFinal(&mctx, buf, slen, &pk);
 181     end:
 182     EVP_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 (!EVP_Digest(str,sizeof(str) - 1,md, NULL, EVP_sha1(), NULL)) 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 (!EVP_Digest(str,sizeof(str) - 1,md, NULL, EVP_sha256(), NULL)) 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 (!EVP_Digest(str,sizeof(str) - 1,md, NULL, EVP_sha512(), NULL)) 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     int i, n;
 381
 382     key = FIPS_rsa_new();
 383     bn = BN_new();
 384     if (!key || !bn)
 385         return 0;
 386     BN_set_word(bn, 65537);
 387     if (!RSA_generate_key_ex(key, 1024,bn,NULL))
 388         return 0;
 389     BN_free(bn);
 390
 391     n = BN_num_bytes(key->d);
 392     printf(" Generated %d byte RSA private key\n", n);
 393     printf("\tBN key before overwriting:\n");
 394     do_bn_print(stdout, key->d);
 395     BN_rand(key->d,n*8,-1,0);
 396     printf("\tBN key after overwriting:\n");
 397     do_bn_print(stdout, key->d);
 398
 399     printf("\tchar buffer key before overwriting: \n\t\t");
 400     for(i = 0; i < sizeof(userkey); i++) printf("%02x", userkey[i]);
 401         printf("\n");
 402     RAND_bytes(userkey, sizeof userkey);
 403     printf("\tchar buffer key after overwriting: \n\t\t");
 404     for(i = 0; i < sizeof(userkey); i++) printf("%02x", userkey[i]);
 405         printf("\n");
 406
 407     return 1;
 408     }
 409
 410 static int Error;
 411 const char * Fail(const char *msg)
 412     {
 413     do_print_errors();
 414     Error++;
 415     return msg;
 416     }
 417
 418 int main(int argc,char **argv)
 419     {
 420
 421     int do_corrupt_rsa_keygen = 0, do_corrupt_dsa_keygen = 0;
 422     int bad_rsa = 0, bad_dsa = 0;
 423     int do_rng_stick = 0;
 424     int no_exit = 0;
 425
 426     printf("\tFIPS-mode test application\n\n");
 427
 428     /* Load entropy from external file, if any */
 429     RAND_load_file(".rnd", 1024);
 430
 431     if (argv[1]) {
 432         /* Corrupted KAT tests */
 433         if (!strcmp(argv[1], "aes")) {
 434             FIPS_corrupt_aes();
 435             printf("AES encryption/decryption with corrupted KAT...\n");
 436         } else if (!strcmp(argv[1], "des")) {
 437             FIPS_corrupt_des();
 438             printf("DES3-ECB encryption/decryption with corrupted KAT...\n");
 439         } else if (!strcmp(argv[1], "dsa")) {
 440             FIPS_corrupt_dsa();
 441             printf("DSA key generation and signature validation with corrupted KAT...\n");
 442         } else if (!strcmp(argv[1], "rsa")) {
 443             FIPS_corrupt_rsa();
 444             printf("RSA key generation and signature validation with corrupted KAT...\n");
 445         } else if (!strcmp(argv[1], "rsakey")) {
 446             printf("RSA key generation and signature validation with corrupted key...\n");
 447             bad_rsa = 1;
 448             no_exit = 1;
 449         } else if (!strcmp(argv[1], "rsakeygen")) {
 450             do_corrupt_rsa_keygen = 1;
 451             no_exit = 1;
 452             printf("RSA key generation and signature validation with corrupted keygen...\n");
 453         } else if (!strcmp(argv[1], "dsakey")) {
 454             printf("DSA key generation and signature validation with corrupted key...\n");
 455             bad_dsa = 1;
 456             no_exit = 1;
 457         } else if (!strcmp(argv[1], "dsakeygen")) {
 458             do_corrupt_dsa_keygen = 1;
 459             no_exit = 1;
 460             printf("DSA key generation and signature validation with corrupted keygen...\n");
 461         } else if (!strcmp(argv[1], "sha1")) {
 462             FIPS_corrupt_sha1();
 463             printf("SHA-1 hash with corrupted KAT...\n");
 464         } else if (!strcmp(argv[1], "rng")) {
 465             FIPS_corrupt_rng();
 466         } else if (!strcmp(argv[1], "rngstick")) {
 467             do_rng_stick = 1;
 468             no_exit = 1;
 469             printf("RNG test with stuck continuous test...\n");
 470         } else {
 471             printf("Bad argument \"%s\"\n", argv[1]);
 472             exit(1);
 473         }
 474         if (!no_exit) {
 475                 if (!FIPS_mode_set(1)) {
 476                     do_print_errors();
 477                     printf("Power-up self test failed\n");
 478                     exit(1);
 479                 }
 480                 printf("Power-up self test successful\n");
 481                 exit(0);
 482         }
 483     }
 484
 485     /* Non-Approved cryptographic operation
 486     */
 487     printf("1. Non-Approved cryptographic operation test...\n");
 488     printf("\ta. Included algorithm (D-H)...");
 489     printf( dh_test() ? "successful\n" :  Fail("FAILED!\n") );
 490
 491     /* Power-up self test
 492     */
 493     ERR_clear_error();
 494     printf("2. Automatic power-up self test...");
 495     if (!FIPS_mode_set(1))
 496         {
 497         do_print_errors();
 498         printf(Fail("FAILED!\n"));
 499         exit(1);
 500         }
 501     printf("successful\n");
 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     printf("3. AES encryption/decryption...");
 512     printf( FIPS_aes_test() ? "successful\n" :  Fail("FAILED!\n") );
 513
 514     /* RSA key generation and encryption/decryption
 515     */
 516     printf("4. RSA key generation and encryption/decryption...");
 517     printf( FIPS_rsa_test(bad_rsa) ? "successful\n" :  Fail("FAILED!\n") );
 518
 519     /* DES-CBC encryption/decryption
 520     */
 521     printf("5. DES-ECB encryption/decryption...");
 522     printf( FIPS_des3_test() ? "successful\n" :  Fail("FAILED!\n") );
 523
 524     /* DSA key generation and signature validation
 525     */
 526     printf("6. DSA key generation and signature validation...");
 527     printf( FIPS_dsa_test(bad_dsa) ? "successful\n" :  Fail("FAILED!\n") );
 528
 529     /* SHA-1 hash
 530     */
 531     printf("7a. SHA-1 hash...");
 532     printf( FIPS_sha1_test() ? "successful\n" :  Fail("FAILED!\n") );
 533
 534     /* SHA-256 hash
 535     */
 536     printf("7b. SHA-256 hash...");
 537     printf( FIPS_sha256_test() ? "successful\n" :  Fail("FAILED!\n") );
 538
 539     /* SHA-512 hash
 540     */
 541     printf("7c. SHA-512 hash...");
 542     printf( FIPS_sha512_test() ? "successful\n" :  Fail("FAILED!\n") );
 543
 544     /* HMAC-SHA-1 hash
 545     */
 546     printf("7d. HMAC-SHA-1 hash...");
 547     printf( FIPS_hmac_sha1_test() ? "successful\n" :  Fail("FAILED!\n") );
 548
 549     /* HMAC-SHA-224 hash
 550     */
 551     printf("7e. HMAC-SHA-224 hash...");
 552     printf( FIPS_hmac_sha224_test() ? "successful\n" :  Fail("FAILED!\n") );
 553
 554     /* HMAC-SHA-256 hash
 555     */
 556     printf("7f. HMAC-SHA-256 hash...");
 557     printf( FIPS_hmac_sha256_test() ? "successful\n" :  Fail("FAILED!\n") );
 558
 559     /* HMAC-SHA-384 hash
 560     */
 561     printf("7g. HMAC-SHA-384 hash...");
 562     printf( FIPS_hmac_sha384_test() ? "successful\n" :  Fail("FAILED!\n") );
 563
 564     /* HMAC-SHA-512 hash
 565     */
 566     printf("7h. HMAC-SHA-512 hash...");
 567     printf( FIPS_hmac_sha512_test() ? "successful\n" :  Fail("FAILED!\n") );
 568
 569     /* Non-Approved cryptographic operation
 570     */
 571     printf("8. Non-Approved cryptographic operation test...\n");
 572     printf("\ta. Included algorithm (D-H)...");
 573     printf( dh_test() ? "successful as expected\n"
 574             : Fail("failed INCORRECTLY!\n") );
 575
 576     /* Zeroization
 577     */
 578     printf("9. Zero-ization...\n");
 579     printf( Zeroize() ? "\tsuccessful as expected\n"
 580             : Fail("\tfailed INCORRECTLY!\n") );
 581
 582     printf("\nAll tests completed with %d errors\n", Error);
 583     return Error ? 1 : 0;
 584     }
 585
 586 #endif