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/cmac.h>
  25 #include <openssl/sha.h>
  26 #include <openssl/err.h>
  27
  28 #include <openssl/bn.h>
  29 #include <openssl/rand.h>
  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 #define ERR_clear_error() while(0)
  40
  41 #include <openssl/rsa.h>
  42 #include <openssl/dsa.h>
  43 #include <openssl/dh.h>
  44
  45 #include <openssl/fips.h>
  46 #include <openssl/fips_rand.h>
  47 #include "fips_utl.h"
  48
  49 /* AES: encrypt and decrypt known plaintext, verify result matches original plaintext
  50 */
  51 static int FIPS_aes_test(void)
  52         {
  53         int ret = 0;
  54         unsigned char pltmp[16];
  55         unsigned char citmp[16];
  56         unsigned char key[16] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
  57         unsigned char plaintext[16] = "etaonrishdlcu";
  58         EVP_CIPHER_CTX ctx;
  59         FIPS_cipher_ctx_init(&ctx);
  60         if (FIPS_cipherinit(&ctx, EVP_aes_128_ecb(), key, NULL, 1) <= 0)
  61                 goto err;
  62         FIPS_cipher(&ctx, citmp, plaintext, 16);
  63         if (FIPS_cipherinit(&ctx, EVP_aes_128_ecb(), key, NULL, 0) <= 0)
  64                 goto err;
  65         FIPS_cipher(&ctx, pltmp, citmp, 16);
  66         if (memcmp(pltmp, plaintext, 16))
  67                 goto err;
  68         ret = 1;
  69         err:
  70         FIPS_cipher_ctx_cleanup(&ctx);
  71         return ret;
  72         }
  73
  74 static int FIPS_aes_gcm_test(void)
  75         {
  76         int ret = 0;
  77         unsigned char pltmp[16];
  78         unsigned char citmp[16];
  79         unsigned char tagtmp[16];
  80         unsigned char key[16] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
  81         unsigned char iv[16] = {21,22,23,24,25,26,27,28,29,30,31,32};
  82         unsigned char aad[] = "Some text AAD";
  83         unsigned char plaintext[16] = "etaonrishdlcu";
  84         EVP_CIPHER_CTX ctx;
  85         FIPS_cipher_ctx_init(&ctx);
  86         if (FIPS_cipherinit(&ctx, EVP_aes_128_gcm(), key, iv, 1) <= 0)
  87                 goto err;
  88         FIPS_cipher(&ctx, NULL, aad, sizeof(aad));
  89         FIPS_cipher(&ctx, citmp, plaintext, 16);
  90         FIPS_cipher(&ctx, NULL, NULL, 0);
  91         if (!FIPS_cipher_ctx_ctrl(&ctx, EVP_CTRL_GCM_GET_TAG, 16, tagtmp))
  92                 goto err;
  93
  94         if (FIPS_cipherinit(&ctx, EVP_aes_128_gcm(), key, iv, 0) <= 0)
  95                 goto err;
  96         if (!FIPS_cipher_ctx_ctrl(&ctx, EVP_CTRL_GCM_SET_TAG, 16, tagtmp))
  97                 goto err;
  98
  99         FIPS_cipher(&ctx, NULL, aad, sizeof(aad));
 100
 101         FIPS_cipher(&ctx, pltmp, citmp, 16);
 102
 103         if (FIPS_cipher(&ctx, NULL, NULL, 0) < 0)
 104                 goto err;
 105
 106         if (memcmp(pltmp, plaintext, 16))
 107                 goto err;
 108
 109         ret = 1;
 110         err:
 111         FIPS_cipher_ctx_cleanup(&ctx);
 112         return ret;
 113         }
 114
 115 static int FIPS_des3_test(void)
 116         {
 117         int ret = 0;
 118         unsigned char pltmp[8];
 119         unsigned char citmp[8];
 120         unsigned char key[] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,
 121                               19,20,21,22,23,24};
 122         unsigned char plaintext[] = { 'e', 't', 'a', 'o', 'n', 'r', 'i', 's' };
 123         EVP_CIPHER_CTX ctx;
 124         FIPS_cipher_ctx_init(&ctx);
 125         if (FIPS_cipherinit(&ctx, EVP_des_ede3_ecb(), key, NULL, 1) <= 0)
 126                 goto err;
 127         FIPS_cipher(&ctx, citmp, plaintext, 8);
 128         if (FIPS_cipherinit(&ctx, EVP_des_ede3_ecb(), key, NULL, 0) <= 0)
 129                 goto err;
 130         FIPS_cipher(&ctx, pltmp, citmp, 8);
 131         if (memcmp(pltmp, plaintext, 8))
 132                 goto err;
 133         ret = 1;
 134         err:
 135         FIPS_cipher_ctx_cleanup(&ctx);
 136         return ret;
 137         }
 138
 139 /*
 140  * DSA: generate keys and sign, verify input plaintext.
 141  */
 142 static int FIPS_dsa_test(int bad)
 143     {
 144     DSA *dsa = NULL;
 145     unsigned char dgst[] = "etaonrishdlc";
 146     int r = 0;
 147     EVP_MD_CTX mctx;
 148     DSA_SIG *sig = NULL;
 149
 150     ERR_clear_error();
 151     FIPS_md_ctx_init(&mctx);
 152     dsa = FIPS_dsa_new();
 153     if (!dsa)
 154         goto end;
 155     if (!DSA_generate_parameters_ex(dsa, 1024,NULL,0,NULL,NULL,NULL))
 156         goto end;
 157     if (!DSA_generate_key(dsa))
 158         goto end;
 159     if (bad)
 160             BN_add_word(dsa->pub_key, 1);
 161
 162     if (!FIPS_digestinit(&mctx, EVP_sha256()))
 163         goto end;
 164     if (!FIPS_digestupdate(&mctx, dgst, sizeof(dgst) - 1))
 165         goto end;
 166     sig = FIPS_dsa_sign_ctx(dsa, &mctx);
 167     if (!sig)
 168         goto end;
 169
 170     if (!FIPS_digestinit(&mctx, EVP_sha256()))
 171         goto end;
 172     if (!FIPS_digestupdate(&mctx, dgst, sizeof(dgst) - 1))
 173         goto end;
 174     r = FIPS_dsa_verify_ctx(dsa, &mctx, sig);
 175     end:
 176     if (sig)
 177         FIPS_dsa_sig_free(sig);
 178     FIPS_md_ctx_cleanup(&mctx);
 179     if (dsa)
 180           FIPS_dsa_free(dsa);
 181     if (r != 1)
 182         return 0;
 183     return 1;
 184     }
 185
 186 /*
 187  * RSA: generate keys and sign, verify input plaintext.
 188  */
 189 static int FIPS_rsa_test(int bad)
 190     {
 191     RSA *key;
 192     unsigned char input_ptext[] = "etaonrishdlc";
 193     unsigned char buf[256];
 194     unsigned int slen;
 195     BIGNUM *bn;
 196     EVP_MD_CTX mctx;
 197     int r = 0;
 198
 199     ERR_clear_error();
 200     FIPS_md_ctx_init(&mctx);
 201     key = FIPS_rsa_new();
 202     bn = BN_new();
 203     if (!key || !bn)
 204         return 0;
 205     BN_set_word(bn, 65537);
 206     if (!RSA_generate_key_ex(key, 2048,bn,NULL))
 207         return 0;
 208     BN_free(bn);
 209     if (bad)
 210             BN_add_word(key->n, 1);
 211
 212     if (!FIPS_digestinit(&mctx, EVP_sha256()))
 213         goto end;
 214     if (!FIPS_digestupdate(&mctx, input_ptext, sizeof(input_ptext) - 1))
 215         goto end;
 216     if (!FIPS_rsa_sign_ctx(key, &mctx, RSA_PKCS1_PADDING, 0, NULL, buf, &slen))
 217         goto end;
 218
 219     if (!FIPS_digestinit(&mctx, EVP_sha256()))
 220         goto end;
 221     if (!FIPS_digestupdate(&mctx, input_ptext, sizeof(input_ptext) - 1))
 222         goto end;
 223     r = FIPS_rsa_verify_ctx(key, &mctx, RSA_PKCS1_PADDING, 0, NULL, buf, slen);
 224     end:
 225     FIPS_md_ctx_cleanup(&mctx);
 226     if (key)
 227           FIPS_rsa_free(key);
 228     if (r != 1)
 229         return 0;
 230     return 1;
 231     }
 232
 233 /* SHA1: generate hash of known digest value and compare to known
 234    precomputed correct hash
 235 */
 236 static int FIPS_sha1_test()
 237     {
 238     unsigned char digest[SHA_DIGEST_LENGTH] =
 239         { 0x11, 0xf1, 0x9a, 0x3a, 0xec, 0x1a, 0x1e, 0x8e, 0x65, 0xd4, 0x9a, 0x38, 0x0c, 0x8b, 0x1e, 0x2c, 0xe8, 0xb3, 0xc5, 0x18 };
 240     unsigned char str[] = "etaonrishd";
 241
 242     unsigned char md[SHA_DIGEST_LENGTH];
 243
 244     ERR_clear_error();
 245     if (!FIPS_digest(str,sizeof(str) - 1,md, NULL, EVP_sha1())) return 0;
 246     if (memcmp(md,digest,sizeof(md)))
 247         return 0;
 248     return 1;
 249     }
 250
 251 /* SHA256: generate hash of known digest value and compare to known
 252    precomputed correct hash
 253 */
 254 static int FIPS_sha256_test()
 255     {
 256     unsigned char digest[SHA256_DIGEST_LENGTH] =
 257         {0xf5, 0x53, 0xcd, 0xb8, 0xcf, 0x1, 0xee, 0x17, 0x9b, 0x93, 0xc9, 0x68, 0xc0, 0xea, 0x40, 0x91,
 258          0x6, 0xec, 0x8e, 0x11, 0x96, 0xc8, 0x5d, 0x1c, 0xaf, 0x64, 0x22, 0xe6, 0x50, 0x4f, 0x47, 0x57};
 259     unsigned char str[] = "etaonrishd";
 260
 261     unsigned char md[SHA256_DIGEST_LENGTH];
 262
 263     ERR_clear_error();
 264     if (!FIPS_digest(str,sizeof(str) - 1,md, NULL, EVP_sha256())) return 0;
 265     if (memcmp(md,digest,sizeof(md)))
 266         return 0;
 267     return 1;
 268     }
 269
 270 /* SHA512: generate hash of known digest value and compare to known
 271    precomputed correct hash
 272 */
 273 static int FIPS_sha512_test()
 274     {
 275     unsigned char digest[SHA512_DIGEST_LENGTH] =
 276         {0x99, 0xc9, 0xe9, 0x5b, 0x88, 0xd4, 0x78, 0x88, 0xdf, 0x88, 0x5f, 0x94, 0x71, 0x64, 0x28, 0xca,
 277          0x16, 0x1f, 0x3d, 0xf4, 0x1f, 0xf3, 0x0f, 0xc5, 0x03, 0x99, 0xb2, 0xd0, 0xe7, 0x0b, 0x94, 0x4a,
 278          0x45, 0xd2, 0x6c, 0x4f, 0x20, 0x06, 0xef, 0x71, 0xa9, 0x25, 0x7f, 0x24, 0xb1, 0xd9, 0x40, 0x22,
 279          0x49, 0x54, 0x10, 0xc2, 0x22, 0x9d, 0x27, 0xfe, 0xbd, 0xd6, 0xd6, 0xeb, 0x2d, 0x42, 0x1d, 0xa3};
 280     unsigned char str[] = "etaonrishd";
 281
 282     unsigned char md[SHA512_DIGEST_LENGTH];
 283
 284     ERR_clear_error();
 285     if (!FIPS_digest(str,sizeof(str) - 1,md, NULL, EVP_sha512())) return 0;
 286     if (memcmp(md,digest,sizeof(md)))
 287         return 0;
 288     return 1;
 289     }
 290
 291 /* HMAC-SHA1: generate hash of known digest value and compare to known
 292    precomputed correct hash
 293 */
 294 static int FIPS_hmac_sha1_test()
 295     {
 296     unsigned char key[] = "etaonrishd";
 297     unsigned char iv[] = "Sample text";
 298     unsigned char kaval[EVP_MAX_MD_SIZE] =
 299         {0x73, 0xf7, 0xa0, 0x48, 0xf8, 0x94, 0xed, 0xdd, 0x0a, 0xea, 0xea, 0x56, 0x1b, 0x61, 0x2e, 0x70,
 300          0xb2, 0xfb, 0xec, 0xc6};
 301
 302     unsigned char out[EVP_MAX_MD_SIZE];
 303     unsigned int outlen;
 304
 305     ERR_clear_error();
 306     if (!HMAC(EVP_sha1(),key,sizeof(key)-1,iv,sizeof(iv)-1,out,&outlen)) return 0;
 307     if (memcmp(out,kaval,outlen))
 308         return 0;
 309     return 1;
 310     }
 311
 312 /* HMAC-SHA224: generate hash of known digest value and compare to known
 313    precomputed correct hash
 314 */
 315 static int FIPS_hmac_sha224_test()
 316     {
 317     unsigned char key[] = "etaonrishd";
 318     unsigned char iv[] = "Sample text";
 319     unsigned char kaval[EVP_MAX_MD_SIZE] =
 320         {0x75, 0x58, 0xd5, 0xbd, 0x55, 0x6d, 0x87, 0x0f, 0x75, 0xff, 0xbe, 0x1c, 0xb2, 0xf0, 0x20, 0x35,
 321          0xe5, 0x62, 0x49, 0xb6, 0x94, 0xb9, 0xfc, 0x65, 0x34, 0x33, 0x3a, 0x19};
 322
 323     unsigned char out[EVP_MAX_MD_SIZE];
 324     unsigned int outlen;
 325
 326     ERR_clear_error();
 327     if (!HMAC(EVP_sha224(),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-SHA256: generate hash of known digest value and compare to known
 334    precomputed correct hash
 335 */
 336 static int FIPS_hmac_sha256_test()
 337     {
 338     unsigned char key[] = "etaonrishd";
 339     unsigned char iv[] = "Sample text";
 340     unsigned char kaval[EVP_MAX_MD_SIZE] =
 341         {0xe9, 0x17, 0xc1, 0x7b, 0x4c, 0x6b, 0x77, 0xda, 0xd2, 0x30, 0x36, 0x02, 0xf5, 0x72, 0x33, 0x87,
 342          0x9f, 0xc6, 0x6e, 0x7b, 0x7e, 0xa8, 0xea, 0xaa, 0x9f, 0xba, 0xee, 0x51, 0xff, 0xda, 0x24, 0xf4};
 343
 344     unsigned char out[EVP_MAX_MD_SIZE];
 345     unsigned int outlen;
 346
 347     ERR_clear_error();
 348     if (!HMAC(EVP_sha256(),key,sizeof(key)-1,iv,sizeof(iv)-1,out,&outlen)) return 0;
 349     if (memcmp(out,kaval,outlen))
 350         return 0;
 351     return 1;
 352     }
 353
 354 /* HMAC-SHA384: generate hash of known digest value and compare to known
 355    precomputed correct hash
 356 */
 357 static int FIPS_hmac_sha384_test()
 358     {
 359     unsigned char key[] = "etaonrishd";
 360     unsigned char iv[] = "Sample text";
 361     unsigned char kaval[EVP_MAX_MD_SIZE] =
 362         {0xb2, 0x9d, 0x40, 0x58, 0x32, 0xc4, 0xe3, 0x31, 0xb6, 0x63, 0x08, 0x26, 0x99, 0xef, 0x3b, 0x10,
 363          0xe2, 0xdf, 0xf8, 0xff, 0xc6, 0xe1, 0x03, 0x29, 0x81, 0x2a, 0x1b, 0xac, 0xb0, 0x07, 0x39, 0x08,
 364          0xf3, 0x91, 0x35, 0x11, 0x76, 0xd6, 0x4c, 0x20, 0xfb, 0x4d, 0xc3, 0xf3, 0xb8, 0x9b, 0x88, 0x1c};
 365
 366     unsigned char out[EVP_MAX_MD_SIZE];
 367     unsigned int outlen;
 368
 369     ERR_clear_error();
 370     if (!HMAC(EVP_sha384(),key,sizeof(key)-1,iv,sizeof(iv)-1,out,&outlen)) return 0;
 371     if (memcmp(out,kaval,outlen))
 372         return 0;
 373     return 1;
 374     }
 375
 376 /* HMAC-SHA512: generate hash of known digest value and compare to known
 377    precomputed correct hash
 378 */
 379 static int FIPS_hmac_sha512_test()
 380     {
 381     unsigned char key[] = "etaonrishd";
 382     unsigned char iv[] = "Sample text";
 383     unsigned char kaval[EVP_MAX_MD_SIZE] =
 384         {0xcd, 0x3e, 0xb9, 0x51, 0xb8, 0xbc, 0x7f, 0x9a, 0x23, 0xaf, 0xf3, 0x77, 0x59, 0x85, 0xa9, 0xe6,
 385          0xf7, 0xd1, 0x51, 0x96, 0x17, 0xe0, 0x92, 0xd8, 0xa6, 0x3b, 0xc1, 0xad, 0x7e, 0x24, 0xca, 0xb1,
 386          0xd7, 0x79, 0x0a, 0xa5, 0xea, 0x2c, 0x02, 0x58, 0x0b, 0xa6, 0x52, 0x6b, 0x61, 0x7f, 0xeb, 0x9c,
 387          0x47, 0x86, 0x5d, 0x74, 0x2b, 0x88, 0xdf, 0xee, 0x46, 0x69, 0x96, 0x3d, 0xa6, 0xd9, 0x2a, 0x53};
 388
 389     unsigned char out[EVP_MAX_MD_SIZE];
 390     unsigned int outlen;
 391
 392     ERR_clear_error();
 393     if (!HMAC(EVP_sha512(),key,sizeof(key)-1,iv,sizeof(iv)-1,out,&outlen)) return 0;
 394     if (memcmp(out,kaval,outlen))
 395         return 0;
 396     return 1;
 397     }
 398
 399 /* CMAC-AES128: generate hash of known digest value and compare to known
 400    precomputed correct hash
 401 */
 402 static int FIPS_cmac_aes128_test()
 403     {
 404     unsigned char key[16] = { 0x2b,0x7e,0x15,0x16, 0x28,0xae,0xd2,0xa6,
 405                               0xab,0xf7,0x15,0x88, 0x09,0xcf,0x4f,0x3c, };
 406     unsigned char data[] = "Sample text";
 407     unsigned char kaval[EVP_MAX_MD_SIZE] =
 408             { 0x16,0x83,0xfe,0xac, 0x52,0x9b,0xae,0x23,
 409               0xd7,0xd5,0x66,0xf5, 0xd2,0x8d,0xbd,0x2a, };
 410
 411     unsigned char *out = NULL;
 412     size_t outlen;
 413     CMAC_CTX *ctx = CMAC_CTX_new();
 414     int r = 0;
 415
 416     ERR_clear_error();
 417
 418     if (!ctx)
 419             goto end;
 420     if (!CMAC_Init(ctx,key,sizeof(key),EVP_aes_128_cbc(),NULL))
 421             goto end;
 422     if (!CMAC_Update(ctx,data,sizeof(data)-1))
 423             goto end;
 424     /* This should return 1.  If not, there's a programming error... */
 425     if (!CMAC_Final(ctx, out, &outlen))
 426             goto end;
 427     out = OPENSSL_malloc(outlen);
 428     if (!CMAC_Final(ctx, out, &outlen))
 429             goto end;
 430 #if 0
 431     {
 432     char *hexout = OPENSSL_malloc(outlen * 2 + 1);
 433     bin2hex(out, outlen, hexout);
 434     printf("CMAC-AES128: res = %s\n", hexout);
 435     OPENSSL_free(hexout);
 436     }
 437     r = 1;
 438 #else
 439     if (!memcmp(out,kaval,outlen))
 440             r = 1;
 441 #endif
 442     end:
 443     CMAC_CTX_free(ctx);
 444     if (out)
 445           OPENSSL_free(out);
 446     return r;
 447     }
 448
 449 /* CMAC-AES192: generate hash of known digest value and compare to known
 450    precomputed correct hash
 451 */
 452 static int FIPS_cmac_aes192_test()
 453     {
 454     unsigned char key[] = { 0x8e,0x73,0xb0,0xf7, 0xda,0x0e,0x64,0x52,
 455                             0xc8,0x10,0xf3,0x2b, 0x80,0x90,0x79,0xe5,
 456                             0x62,0xf8,0xea,0xd2, 0x52,0x2c,0x6b,0x7b, };
 457     unsigned char data[] = "Sample text";
 458     unsigned char kaval[] =
 459             { 0xd6,0x99,0x19,0x25, 0xe5,0x1d,0x95,0x48,
 460               0xb1,0x4a,0x0b,0xf2, 0xc6,0x3c,0x47,0x1f, };
 461
 462     unsigned char *out = NULL;
 463     size_t outlen;
 464     CMAC_CTX *ctx = CMAC_CTX_new();
 465     int r = 0;
 466
 467     ERR_clear_error();
 468
 469     if (!ctx)
 470             goto end;
 471     if (!CMAC_Init(ctx,key,sizeof(key),EVP_aes_192_cbc(),NULL))
 472             goto end;
 473     if (!CMAC_Update(ctx,data,sizeof(data)-1))
 474             goto end;
 475     /* This should return 1.  If not, there's a programming error... */
 476     if (!CMAC_Final(ctx, out, &outlen))
 477             goto end;
 478     out = OPENSSL_malloc(outlen);
 479     if (!CMAC_Final(ctx, out, &outlen))
 480             goto end;
 481 #if 0
 482     {
 483     char *hexout = OPENSSL_malloc(outlen * 2 + 1);
 484     bin2hex(out, outlen, hexout);
 485     printf("CMAC-AES192: res = %s\n", hexout);
 486     OPENSSL_free(hexout);
 487     }
 488     r = 1;
 489 #else
 490     if (!memcmp(out,kaval,outlen))
 491             r = 1;
 492 #endif
 493     end:
 494     CMAC_CTX_free(ctx);
 495     if (out)
 496           OPENSSL_free(out);
 497     return r;
 498     }
 499
 500 /* CMAC-AES256: generate hash of known digest value and compare to known
 501    precomputed correct hash
 502 */
 503 static int FIPS_cmac_aes256_test()
 504     {
 505     unsigned char key[] = { 0x60,0x3d,0xeb,0x10, 0x15,0xca,0x71,0xbe,
 506                             0x2b,0x73,0xae,0xf0, 0x85,0x7d,0x77,0x81,
 507                             0x1f,0x35,0x2c,0x07, 0x3b,0x61,0x08,0xd7,
 508                             0x2d,0x98,0x10,0xa3, 0x09,0x14,0xdf,0xf4, };
 509     unsigned char data[] = "Sample text";
 510     unsigned char kaval[] =
 511             { 0xec,0xc2,0xcf,0x63, 0xc7,0xce,0xfc,0xa4,
 512               0xb0,0x86,0x37,0x5f, 0x15,0x60,0xba,0x1f, };
 513
 514     unsigned char *out = NULL;
 515     size_t outlen;
 516     CMAC_CTX *ctx = CMAC_CTX_new();
 517     int r = 0;
 518
 519     ERR_clear_error();
 520
 521     if (!ctx)
 522             goto end;
 523     if (!CMAC_Init(ctx,key,sizeof(key),EVP_aes_256_cbc(),NULL))
 524             goto end;
 525     if (!CMAC_Update(ctx,data,sizeof(data)-1))
 526             goto end;
 527     /* This should return 1.  If not, there's a programming error... */
 528     if (!CMAC_Final(ctx, out, &outlen))
 529             goto end;
 530     out = OPENSSL_malloc(outlen);
 531     if (!CMAC_Final(ctx, out, &outlen))
 532             goto end;
 533 #if 0
 534     {
 535     char *hexout = OPENSSL_malloc(outlen * 2 + 1);
 536     bin2hex(out, outlen, hexout);
 537     printf("CMAC-AES256: res = %s\n", hexout);
 538     OPENSSL_free(hexout);
 539     }
 540     r = 1;
 541 #else
 542     if (!memcmp(out,kaval,outlen))
 543             r = 1;
 544 #endif
 545     end:
 546     CMAC_CTX_free(ctx);
 547     if (out)
 548           OPENSSL_free(out);
 549     return r;
 550     }
 551
 552 /* CMAC-TDEA3: generate hash of known digest value and compare to known
 553    precomputed correct hash
 554 */
 555 static int FIPS_cmac_tdea3_test()
 556     {
 557     unsigned char key[] = { 0x8a,0xa8,0x3b,0xf8, 0xcb,0xda,0x10,0x62,
 558                             0x0b,0xc1,0xbf,0x19, 0xfb,0xb6,0xcd,0x58,
 559                             0xbc,0x31,0x3d,0x4a, 0x37,0x1c,0xa8,0xb5, };
 560     unsigned char data[] = "Sample text";
 561     unsigned char kaval[EVP_MAX_MD_SIZE] =
 562             { 0xb4,0x06,0x4e,0xbf, 0x59,0x89,0xba,0x68, };
 563
 564     unsigned char *out = NULL;
 565     size_t outlen;
 566     CMAC_CTX *ctx = CMAC_CTX_new();
 567     int r = 0;
 568
 569     ERR_clear_error();
 570
 571     if (!ctx)
 572             goto end;
 573     if (!CMAC_Init(ctx,key,sizeof(key),EVP_des_ede3_cbc(),NULL))
 574             goto end;
 575     if (!CMAC_Update(ctx,data,sizeof(data)-1))
 576             goto end;
 577     /* This should return 1.  If not, there's a programming error... */
 578     if (!CMAC_Final(ctx, out, &outlen))
 579             goto end;
 580     out = OPENSSL_malloc(outlen);
 581     if (!CMAC_Final(ctx, out, &outlen))
 582             goto end;
 583 #if 0
 584     {
 585     char *hexout = OPENSSL_malloc(outlen * 2 + 1);
 586     bin2hex(out, outlen, hexout);
 587     printf("CMAC-TDEA3: res = %s\n", hexout);
 588     OPENSSL_free(hexout);
 589     }
 590     r = 1;
 591 #else
 592     if (!memcmp(out,kaval,outlen))
 593             r = 1;
 594 #endif
 595     end:
 596     CMAC_CTX_free(ctx);
 597     if (out)
 598           OPENSSL_free(out);
 599     return r;
 600     }
 601
 602
 603 /* DH: generate shared parameters
 604 */
 605 static int dh_test()
 606     {
 607     DH *dh;
 608     ERR_clear_error();
 609     dh = FIPS_dh_new();
 610     if (!dh)
 611         return 0;
 612     if (!DH_generate_parameters_ex(dh, 1024, 2, NULL))
 613         return 0;
 614     FIPS_dh_free(dh);
 615     return 1;
 616     }
 617
 618 /* Zeroize
 619 */
 620 static int Zeroize()
 621     {
 622     RSA *key;
 623     BIGNUM *bn;
 624     unsigned char userkey[16] =
 625         { 0x48, 0x50, 0xf0, 0xa3, 0x3a, 0xed, 0xd3, 0xaf, 0x6e, 0x47, 0x7f, 0x83, 0x02, 0xb1, 0x09, 0x68 };
 626     size_t i;
 627     int n;
 628
 629     key = FIPS_rsa_new();
 630     bn = BN_new();
 631     if (!key || !bn)
 632         return 0;
 633     BN_set_word(bn, 65537);
 634     if (!RSA_generate_key_ex(key, 1024,bn,NULL))
 635         return 0;
 636     BN_free(bn);
 637
 638     n = BN_num_bytes(key->d);
 639     printf(" Generated %d byte RSA private key\n", n);
 640     printf("\tBN key before overwriting:\n");
 641     do_bn_print(stdout, key->d);
 642     BN_rand(key->d,n*8,-1,0);
 643     printf("\tBN key after overwriting:\n");
 644     do_bn_print(stdout, key->d);
 645
 646     printf("\tchar buffer key before overwriting: \n\t\t");
 647     for(i = 0; i < sizeof(userkey); i++) printf("%02x", userkey[i]);
 648         printf("\n");
 649     RAND_bytes(userkey, sizeof userkey);
 650     printf("\tchar buffer key after overwriting: \n\t\t");
 651     for(i = 0; i < sizeof(userkey); i++) printf("%02x", userkey[i]);
 652         printf("\n");
 653
 654     FIPS_rsa_free(key);
 655
 656     return 1;
 657     }
 658
 659 /* Dummy Entropy for DRBG tests. WARNING: THIS IS TOTALLY BOGUS
 660  * HAS ZERO SECURITY AND MUST NOT BE USED IN REAL APPLICATIONS.
 661  */
 662
 663 static unsigned char dummy_drbg_entropy[1024];
 664
 665 static size_t drbg_test_cb(DRBG_CTX *ctx, unsigned char **pout,
 666                                 int entropy, size_t min_len, size_t max_len)
 667         {
 668         *pout = dummy_drbg_entropy;
 669         /* Round up to multiple of block size */
 670         return (min_len + 0xf) & ~0xf;
 671         }
 672
 673 /* DRBG test: just generate lots of data and trigger health checks */
 674
 675 static int do_drbg_test(int type, int flags)
 676     {
 677     DRBG_CTX *dctx;
 678     int rv = 0;
 679     size_t i;
 680     unsigned char randout[1024];
 681     dctx = FIPS_drbg_new(type, flags);
 682     if (!dctx)
 683         return 0;
 684     FIPS_drbg_set_callbacks(dctx, drbg_test_cb, 0, 0x10, drbg_test_cb, 0);
 685     for (i = 0; i < sizeof(dummy_drbg_entropy); i++)
 686         {
 687         dummy_drbg_entropy[i] = i & 0xff;
 688         }
 689     if (!FIPS_drbg_instantiate(dctx, dummy_drbg_entropy, 10))
 690         goto err;
 691     FIPS_drbg_set_check_interval(dctx, 10);
 692     for (i = 0; i < 32; i++)
 693         {
 694         if (!FIPS_drbg_generate(dctx, randout, sizeof(randout), 0, NULL, 0))
 695                 goto err;
 696         if (!FIPS_drbg_generate(dctx, randout, sizeof(randout), 0, dummy_drbg_entropy, 1))
 697                 goto err;
 698         }
 699     rv = 1;
 700     err:
 701     FIPS_drbg_free(dctx);
 702     return rv;
 703     }
 704
 705 typedef struct
 706     {
 707     int type, flags;
 708     } DRBG_LIST;
 709
 710 static int do_drbg_all(void)
 711     {
 712     static DRBG_LIST drbg_types[] =
 713         {
 714                 {NID_sha1, 0},
 715                 {NID_sha224, 0},
 716                 {NID_sha256, 0},
 717                 {NID_sha384, 0},
 718                 {NID_sha512, 0},
 719                 {NID_hmacWithSHA1, 0},
 720                 {NID_hmacWithSHA224, 0},
 721                 {NID_hmacWithSHA256, 0},
 722                 {NID_hmacWithSHA384, 0},
 723                 {NID_hmacWithSHA512, 0},
 724                 {NID_aes_128_ctr, 0},
 725                 {NID_aes_192_ctr, 0},
 726                 {NID_aes_256_ctr, 0},
 727                 {NID_aes_128_ctr, DRBG_FLAG_CTR_USE_DF},
 728                 {NID_aes_192_ctr, DRBG_FLAG_CTR_USE_DF},
 729                 {NID_aes_256_ctr, DRBG_FLAG_CTR_USE_DF},
 730                 {(NID_X9_62_prime256v1 << 16)|NID_sha1, 0},
 731                 {(NID_X9_62_prime256v1 << 16)|NID_sha224, 0},
 732                 {(NID_X9_62_prime256v1 << 16)|NID_sha256, 0},
 733                 {(NID_X9_62_prime256v1 << 16)|NID_sha384, 0},
 734                 {(NID_X9_62_prime256v1 << 16)|NID_sha512, 0},
 735                 {(NID_secp384r1 << 16)|NID_sha224, 0},
 736                 {(NID_secp384r1 << 16)|NID_sha256, 0},
 737                 {(NID_secp384r1 << 16)|NID_sha384, 0},
 738                 {(NID_secp384r1 << 16)|NID_sha512, 0},
 739                 {(NID_secp521r1 << 16)|NID_sha256, 0},
 740                 {(NID_secp521r1 << 16)|NID_sha384, 0},
 741                 {(NID_secp521r1 << 16)|NID_sha512, 0},
 742                 {0, 0}
 743         };
 744     DRBG_LIST *lst;
 745     int rv = 1;
 746     for (lst = drbg_types;; lst++)
 747         {
 748         if (lst->type == 0)
 749                 break;
 750         if (!do_drbg_test(lst->type, lst->flags))
 751                 rv = 0;
 752         }
 753     return rv;
 754     }
 755
 756 static int Error;
 757 static const char * Fail(const char *msg)
 758     {
 759     Error++;
 760     return msg;
 761     }
 762
 763 static void test_msg(const char *msg, int result)
 764         {
 765         printf("%s...%s\n", msg, result ? "successful" : Fail("Failed!"));
 766         }
 767
 768 /* Table of IDs for POST translating between NIDs and names */
 769
 770 typedef struct
 771         {
 772         int id;
 773         const char *name;
 774         } POST_ID;
 775
 776 POST_ID id_list[] = {
 777         {NID_sha1, "SHA1"},
 778         {NID_sha224, "SHA224"},
 779         {NID_sha256, "SHA256"},
 780         {NID_sha384, "SHA384"},
 781         {NID_sha512, "SHA512"},
 782         {NID_hmacWithSHA1, "HMAC-SHA1"},
 783         {NID_hmacWithSHA224, "HMAC-SHA224"},
 784         {NID_hmacWithSHA256, "HMAC-SHA256"},
 785         {NID_hmacWithSHA384, "HMAC-SHA384"},
 786         {NID_hmacWithSHA512, "HMAC-SHA512"},
 787         {EVP_PKEY_RSA, "RSA"},
 788         {EVP_PKEY_DSA, "DSA"},
 789         {EVP_PKEY_EC, "ECDSA"},
 790         {NID_aes_128_cbc, "AES-128-CBC"},
 791         {NID_aes_192_cbc, "AES-192-CBC"},
 792         {NID_aes_256_cbc, "AES-256-CBC"},
 793         {NID_aes_128_ctr, "AES-128-CTR"},
 794         {NID_aes_192_ctr, "AES-192-CTR"},
 795         {NID_aes_256_ctr, "AES-256-CTR"},
 796         {NID_aes_128_ecb, "AES-128-ECB"},
 797         {NID_aes_128_xts, "AES-128-XTS"},
 798         {NID_aes_256_xts, "AES-256-XTS"},
 799         {NID_des_ede3_cbc, "DES-EDE3-CBC"},
 800         {NID_des_ede3_ecb, "DES-EDE3-ECB"},
 801         {NID_secp224r1, "P-224"},
 802         {NID_sect233r1, "B-233"},
 803         {NID_sect233k1, "K-233"},
 804         {NID_X9_62_prime256v1, "P-256"},
 805         {NID_secp384r1, "P-384"},
 806         {NID_secp521r1, "P-521"},
 807         {0, NULL}
 808 };
 809
 810 static const char *lookup_id(int id)
 811         {
 812         POST_ID *n;
 813         static char out[40];
 814         for (n = id_list; n->name; n++)
 815                 {
 816                 if (n->id == id)
 817                         return n->name;
 818                 }
 819         sprintf(out, "ID=%d", id);
 820         return out;
 821         }
 822
 823 static int fail_id = -1;
 824 static int fail_sub = -1;
 825 static int fail_key = -1;
 826
 827 static int post_cb(int op, int id, int subid, void *ex)
 828         {
 829         const char *idstr, *exstr = "";
 830         char asctmp[20];
 831         int keytype = -1;
 832 #ifdef FIPS_POST_TIME
 833         static struct timespec start, end, tstart, tend;
 834 #endif
 835         switch(id)
 836                 {
 837                 case FIPS_TEST_INTEGRITY:
 838                 idstr = "Integrity";
 839                 break;
 840
 841                 case FIPS_TEST_DIGEST:
 842                 idstr = "Digest";
 843                 exstr = lookup_id(subid);
 844                 break;
 845
 846                 case FIPS_TEST_CIPHER:
 847                 exstr = lookup_id(subid);
 848                 idstr = "Cipher";
 849                 break;
 850
 851                 case FIPS_TEST_SIGNATURE:
 852                 if (ex)
 853                         {
 854                         EVP_PKEY *pkey = ex;
 855                         keytype = pkey->type;
 856                         if (keytype == EVP_PKEY_EC)
 857                                 {
 858                                 const EC_GROUP *grp;
 859                                 int cnid;
 860                                 grp = EC_KEY_get0_group(pkey->pkey.ec);
 861                                 cnid = EC_GROUP_get_curve_name(grp);
 862                                 sprintf(asctmp, "ECDSA %s", lookup_id(cnid));
 863                                 exstr = asctmp;
 864                                 }
 865                         else
 866                                 exstr = lookup_id(keytype);
 867                         }
 868                 idstr = "Signature";
 869                 break;
 870
 871                 case FIPS_TEST_HMAC:
 872                 exstr = lookup_id(subid);
 873                 idstr = "HMAC";
 874                 break;
 875
 876                 case FIPS_TEST_CMAC:
 877                 idstr = "CMAC";
 878                 exstr = lookup_id(subid);
 879                 break;
 880
 881                 case FIPS_TEST_GCM:
 882                 idstr = "GCM";
 883                 break;
 884
 885                 case FIPS_TEST_XTS:
 886                 idstr = "XTS";
 887                 exstr = lookup_id(subid);
 888                 break;
 889
 890                 case FIPS_TEST_CCM:
 891                 idstr = "CCM";
 892                 break;
 893
 894                 case FIPS_TEST_X931:
 895                 idstr = "X9.31 PRNG";
 896                 sprintf(asctmp, "keylen=%d", subid);
 897                 exstr = asctmp;
 898                 break;
 899
 900                 case FIPS_TEST_DRBG:
 901                 idstr = "DRBG";
 902                 if (*(int *)ex & DRBG_FLAG_CTR_USE_DF)
 903                         {
 904                         sprintf(asctmp, "%s DF", lookup_id(subid));
 905                         exstr = asctmp;
 906                         }
 907                 else if (subid >> 16)
 908                         {
 909                         sprintf(asctmp, "%s %s",
 910                                         lookup_id(subid >> 16),
 911                                         lookup_id(subid & 0xFFFF));
 912                         exstr = asctmp;
 913                         }
 914                 else
 915                         exstr = lookup_id(subid);
 916                 break;
 917
 918                 case FIPS_TEST_PAIRWISE:
 919                 if (ex)
 920                         {
 921                         EVP_PKEY *pkey = ex;
 922                         keytype = pkey->type;
 923                         exstr = lookup_id(keytype);
 924                         }
 925                 idstr = "Pairwise Consistency";
 926                 break;
 927
 928                 case FIPS_TEST_CONTINUOUS:
 929                 idstr = "Continuous PRNG";
 930                 break;
 931
 932                 case FIPS_TEST_ECDH:
 933                 idstr = "ECDH";
 934                 exstr = lookup_id(subid);
 935                 break;
 936
 937                 default:
 938                 idstr = "Unknown";
 939                 break;
 940
 941                 }
 942
 943         switch(op)
 944                 {
 945                 case FIPS_POST_BEGIN:
 946 #ifdef FIPS_POST_TIME
 947                 clock_getres(CLOCK_REALTIME, &tstart);
 948                 printf("\tTimer resolution %ld s, %ld ns\n",
 949                                 (long)tstart.tv_sec, (long)tstart.tv_nsec);
 950                 clock_gettime(CLOCK_REALTIME, &tstart);
 951 #endif
 952                 printf("\tPOST started\n");
 953                 break;
 954
 955                 case FIPS_POST_END:
 956                 printf("\tPOST %s\n", id ? "Success" : "Failed");
 957 #ifdef FIPS_POST_TIME
 958                 clock_gettime(CLOCK_REALTIME, &tend);
 959                 printf("\t\tTook %f seconds\n",
 960                         (double)((tend.tv_sec+tend.tv_nsec*1e-9)
 961                         - (tstart.tv_sec+tstart.tv_nsec*1e-9)));
 962 #endif
 963                 break;
 964
 965                 case FIPS_POST_STARTED:
 966                 printf("\t\t%s %s test started\n", idstr, exstr);
 967 #ifdef FIPS_POST_TIME
 968                 clock_gettime(CLOCK_REALTIME, &start);
 969 #endif
 970                 break;
 971
 972                 case FIPS_POST_SUCCESS:
 973                 printf("\t\t%s %s test OK\n", idstr, exstr);
 974 #ifdef FIPS_POST_TIME
 975                 clock_gettime(CLOCK_REALTIME, &end);
 976                 printf("\t\t\tTook %f seconds\n",
 977                         (double)((end.tv_sec+end.tv_nsec*1e-9)
 978                         - (start.tv_sec+start.tv_nsec*1e-9)));
 979 #endif
 980                 break;
 981
 982                 case FIPS_POST_FAIL:
 983                 printf("\t\t%s %s test FAILED!!\n", idstr, exstr);
 984                 break;
 985
 986                 case FIPS_POST_CORRUPT:
 987                 if (fail_id == id
 988                         && (fail_key == -1 || fail_key == keytype)
 989                         && (fail_sub == -1 || fail_sub == subid))
 990                         {
 991                         printf("\t\t%s %s test failure induced\n", idstr, exstr);
 992                         return 0;
 993                         }
 994                 break;
 995
 996                 }
 997         return 1;
 998         }
 999
1000 #ifdef FIPS_ALGVS
1001 int fips_test_suite_main(int argc, char **argv)
1002 #else
1003 int main(int argc, char **argv)
1004 #endif
1005     {
1006     int bad_rsa = 0, bad_dsa = 0;
1007     int do_rng_stick = 0;
1008     int do_drbg_stick = 0;
1009     int no_exit = 0;
1010     int no_dh = 0;
1011     char *pass = FIPS_AUTH_USER_PASS;
1012
1013     FIPS_post_set_callback(post_cb);
1014
1015     printf("\tFIPS-mode test application\n");
1016
1017     printf("\t%s\n\n", FIPS_module_version_text());
1018
1019     if (argv[1]) {
1020         /* Corrupted KAT tests */
1021         if (!strcmp(argv[1], "integrity")) {
1022             fail_id = FIPS_TEST_INTEGRITY;
1023         } else if (!strcmp(argv[1], "aes")) {
1024             fail_id = FIPS_TEST_CIPHER;
1025             fail_sub = NID_aes_128_ecb;
1026         } else if (!strcmp(argv[1], "aes-ccm")) {
1027             fail_id = FIPS_TEST_CCM;
1028         } else if (!strcmp(argv[1], "aes-gcm")) {
1029             fail_id = FIPS_TEST_GCM;
1030         } else if (!strcmp(argv[1], "aes-xts")) {
1031             fail_id = FIPS_TEST_XTS;
1032         } else if (!strcmp(argv[1], "des")) {
1033             fail_id = FIPS_TEST_CIPHER;
1034             fail_sub = NID_des_ede3_ecb;
1035         } else if (!strcmp(argv[1], "dsa")) {
1036             fail_id = FIPS_TEST_SIGNATURE;
1037             fail_key = EVP_PKEY_DSA;
1038         } else if (!strcmp(argv[1], "ecdh")) {
1039             fail_id = FIPS_TEST_ECDH;
1040         } else if (!strcmp(argv[1], "ecdsa")) {
1041             fail_id = FIPS_TEST_SIGNATURE;
1042             fail_key = EVP_PKEY_EC;
1043         } else if (!strcmp(argv[1], "rsa")) {
1044             fail_id = FIPS_TEST_SIGNATURE;
1045             fail_key = EVP_PKEY_RSA;
1046         } else if (!strcmp(argv[1], "rsakey")) {
1047             printf("RSA key generation and signature validation with corrupted key...\n");
1048             bad_rsa = 1;
1049             no_exit = 1;
1050         } else if (!strcmp(argv[1], "rsakeygen")) {
1051             fail_id = FIPS_TEST_PAIRWISE;
1052             fail_key = EVP_PKEY_RSA;
1053             no_exit = 1;
1054         } else if (!strcmp(argv[1], "dsakey")) {
1055             printf("DSA key generation and signature validation with corrupted key...\n");
1056             bad_dsa = 1;
1057             no_exit = 1;
1058         } else if (!strcmp(argv[1], "dsakeygen")) {
1059             fail_id = FIPS_TEST_PAIRWISE;
1060             fail_key = EVP_PKEY_DSA;
1061             no_exit = 1;
1062         } else if (!strcmp(argv[1], "sha1")) {
1063             fail_id = FIPS_TEST_DIGEST;
1064         } else if (!strcmp(argv[1], "hmac")) {
1065             fail_id = FIPS_TEST_HMAC;
1066         } else if (!strcmp(argv[1], "cmac")) {
1067             fail_id = FIPS_TEST_CMAC;
1068         } else if (!strcmp(argv[1], "drbg")) {
1069             fail_id = FIPS_TEST_DRBG;
1070         } else if (!strcmp(argv[1], "rng")) {
1071             fail_id = FIPS_TEST_X931;
1072         } else if (!strcmp(argv[1], "nodh")) {
1073             no_dh = 1;
1074             no_exit = 1;
1075         } else if (!strcmp(argv[1], "post")) {
1076             fail_id = -1;
1077         } else if (!strcmp(argv[1], "rngstick")) {
1078             do_rng_stick = 1;
1079             no_exit = 1;
1080             printf("RNG test with stuck continuous test...\n");
1081         } else if (!strcmp(argv[1], "drbgentstick")) {
1082                 do_entropy_stick();
1083         } else if (!strcmp(argv[1], "drbgstick")) {
1084             do_drbg_stick = 1;
1085             no_exit = 1;
1086             printf("DRBG test with stuck continuous test...\n");
1087         } else if (!strcmp(argv[1], "user")) {
1088                 pass = FIPS_AUTH_USER_PASS;
1089         } else if (!strcmp(argv[1], "officer")) {
1090                 pass = FIPS_AUTH_OFFICER_PASS;
1091         } else if (!strcmp(argv[1], "badpass")) {
1092                 pass = "bad invalid password";
1093         } else if (!strcmp(argv[1], "nopass")) {
1094                 pass = "";
1095         } else {
1096             printf("Bad argument \"%s\"\n", argv[1]);
1097             return 1;
1098         }
1099         if (!no_exit) {
1100                 fips_algtest_init_nofips();
1101                 if (!FIPS_module_mode_set(1, pass)) {
1102                     printf("Power-up self test failed\n");
1103                     return 1;
1104                 }
1105                 printf("Power-up self test successful\n");
1106                 return 0;
1107         }
1108     }
1109
1110     fips_algtest_init_nofips();
1111
1112     /* Non-Approved cryptographic operation
1113     */
1114     printf("1. Non-Approved cryptographic operation test...\n");
1115     if (no_dh)
1116         printf("\t D-H test skipped\n");
1117     else
1118         test_msg("\ta. Included algorithm (D-H)...", dh_test());
1119
1120     /* Power-up self test
1121     */
1122     ERR_clear_error();
1123     test_msg("2. Automatic power-up self test", FIPS_module_mode_set(1, pass));
1124     if (!FIPS_module_mode())
1125         return 1;
1126     if (do_drbg_stick)
1127             FIPS_drbg_stick();
1128     if (do_rng_stick)
1129             FIPS_x931_stick();
1130
1131     /* AES encryption/decryption
1132     */
1133     test_msg("3a. AES encryption/decryption", FIPS_aes_test());
1134     /* AES GCM encryption/decryption
1135     */
1136     test_msg("3b. AES-GCM encryption/decryption", FIPS_aes_gcm_test());
1137
1138     /* RSA key generation and encryption/decryption
1139     */
1140     test_msg("4. RSA key generation and encryption/decryption",
1141                                                 FIPS_rsa_test(bad_rsa));
1142
1143     /* DES-CBC encryption/decryption
1144     */
1145     test_msg("5. DES-ECB encryption/decryption", FIPS_des3_test());
1146
1147     /* DSA key generation and signature validation
1148     */
1149     test_msg("6. DSA key generation and signature validation",
1150                                                 FIPS_dsa_test(bad_dsa));
1151
1152     /* SHA-1 hash
1153     */
1154     test_msg("7a. SHA-1 hash", FIPS_sha1_test());
1155
1156     /* SHA-256 hash
1157     */
1158     test_msg("7b. SHA-256 hash", FIPS_sha256_test());
1159
1160     /* SHA-512 hash
1161     */
1162     test_msg("7c. SHA-512 hash", FIPS_sha512_test());
1163
1164     /* HMAC-SHA-1 hash
1165     */
1166     test_msg("7d. HMAC-SHA-1 hash", FIPS_hmac_sha1_test());
1167
1168     /* HMAC-SHA-224 hash
1169     */
1170     test_msg("7e. HMAC-SHA-224 hash", FIPS_hmac_sha224_test());
1171
1172     /* HMAC-SHA-256 hash
1173     */
1174     test_msg("7f. HMAC-SHA-256 hash", FIPS_hmac_sha256_test());
1175
1176     /* HMAC-SHA-384 hash
1177     */
1178     test_msg("7g. HMAC-SHA-384 hash", FIPS_hmac_sha384_test());
1179
1180     /* HMAC-SHA-512 hash
1181     */
1182     test_msg("7h. HMAC-SHA-512 hash", FIPS_hmac_sha512_test());
1183
1184     /* CMAC-AES-128 hash
1185     */
1186     test_msg("8a. CMAC-AES-128 hash", FIPS_cmac_aes128_test());
1187
1188     /* CMAC-AES-192 hash
1189     */
1190     test_msg("8b. CMAC-AES-192 hash", FIPS_cmac_aes192_test());
1191
1192     /* CMAC-AES-256 hash
1193     */
1194     test_msg("8c. CMAC-AES-256 hash", FIPS_cmac_aes256_test());
1195
1196 # if 0                          /* Not a FIPS algorithm */
1197     /* CMAC-TDEA-2 hash
1198     */
1199     test_msg("8d. CMAC-TDEA-2 hash", FIPS_cmac_tdea2_test());
1200 #endif
1201
1202     /* CMAC-TDEA-3 hash
1203     */
1204     test_msg("8e. CMAC-TDEA-3 hash", FIPS_cmac_tdea3_test());
1205
1206     /* Non-Approved cryptographic operation
1207     */
1208     printf("9. Non-Approved cryptographic operation test...\n");
1209     printf("\ta. Included algorithm (D-H)...%s\n",
1210                 no_dh ? "skipped" :
1211                 dh_test() ? "successful as expected"
1212                                                 : Fail("failed INCORRECTLY!") );
1213
1214     /* Zeroization
1215     */
1216     printf("10. Zero-ization...\n\t%s\n",
1217                 Zeroize() ? "successful as expected"
1218                                         : Fail("failed INCORRECTLY!") );
1219
1220     printf("11. Complete DRBG health check...\n");
1221     printf("\t%s\n", FIPS_selftest_drbg_all() ? "successful as expected"
1222                                         : Fail("failed INCORRECTLY!") );
1223
1224     printf("12. DRBG generation check...\n");
1225     printf("\t%s\n", do_drbg_all() ? "successful as expected"
1226                                         : Fail("failed INCORRECTLY!") );
1227
1228     printf("\nAll tests completed with %d errors\n", Error);
1229     return Error ? 1 : 0;
1230     }
1231
1232 #endif