fips-1.0/fips_test_suite.c

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