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