crypto/openssl-0.9.7e/fips/fips.c

   1 /* ====================================================================
   2  * Copyright (c) 2003 The OpenSSL Project.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  *
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in
  13  *    the documentation and/or other materials provided with the
  14  *    distribution.
  15  *
  16  * 3. All advertising materials mentioning features or use of this
  17  *    software must display the following acknowledgment:
  18  *    "This product includes software developed by the OpenSSL Project
  19  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  20  *
  21  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  22  *    endorse or promote products derived from this software without
  23  *    prior written permission. For written permission, please contact
  24  *    openssl-core@openssl.org.
  25  *
  26  * 5. Products derived from this software may not be called "OpenSSL"
  27  *    nor may "OpenSSL" appear in their names without prior written
  28  *    permission of the OpenSSL Project.
  29  *
  30  * 6. Redistributions of any form whatsoever must retain the following
  31  *    acknowledgment:
  32  *    "This product includes software developed by the OpenSSL Project
  33  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  34  *
  35  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  36  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  37  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  38  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  39  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  41  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  42  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  43  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  44  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  45  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  46  * OF THE POSSIBILITY OF SUCH DAMAGE.
  47  *
  48  */
  49
  50 #include <openssl/fips.h>
  51 #include <openssl/rand.h>
  52 #include <openssl/fips_rand.h>
  53 #include <openssl/err.h>
  54 #include <openssl/bio.h>
  55 #include <openssl/hmac.h>
  56 #include <string.h>
  57 #include <limits.h>
  58 #include "fips_locl.h"
  59
  60 #ifdef OPENSSL_FIPS
  61
  62 #ifndef PATH_MAX
  63 #define PATH_MAX 1024
  64 #endif
  65
  66 static int fips_md5_allowed = 0;
  67 static int fips_selftest_fail = 0;
  68
  69 void FIPS_allow_md5(int onoff)
  70     {
  71     if (fips_is_started())
  72         {
  73         int owning_thread = fips_is_owning_thread();
  74
  75         if (!owning_thread) CRYPTO_w_lock(CRYPTO_LOCK_FIPS);
  76         fips_md5_allowed = onoff;
  77         if (!owning_thread) CRYPTO_w_unlock(CRYPTO_LOCK_FIPS);
  78         }
  79     }
  80
  81 int FIPS_md5_allowed(void)
  82     {
  83     int ret = 1;
  84     if (fips_is_started())
  85         {
  86         int owning_thread = fips_is_owning_thread();
  87
  88         if (!owning_thread) CRYPTO_r_lock(CRYPTO_LOCK_FIPS);
  89         ret = fips_md5_allowed;
  90         if (!owning_thread) CRYPTO_r_unlock(CRYPTO_LOCK_FIPS);
  91         }
  92     return ret;
  93     }
  94
  95 int FIPS_selftest_failed(void)
  96     {
  97     int ret = 0;
  98     if (fips_is_started())
  99         {
 100         int owning_thread = fips_is_owning_thread();
 101
 102         if (!owning_thread) CRYPTO_r_lock(CRYPTO_LOCK_FIPS);
 103         ret = fips_selftest_fail;
 104         if (!owning_thread) CRYPTO_r_unlock(CRYPTO_LOCK_FIPS);
 105         }
 106     return ret;
 107     }
 108
 109 int FIPS_selftest()
 110     {
 111     ERR_load_crypto_strings();
 112
 113     return FIPS_selftest_sha1()
 114         && FIPS_selftest_aes()
 115         && FIPS_selftest_des()
 116         && FIPS_selftest_rsa()
 117         && FIPS_selftest_dsa();
 118     }
 119
 120 static int FIPS_check_exe(const char *path)
 121     {
 122     unsigned char buf[1024];
 123     char p2[PATH_MAX];
 124     unsigned int n;
 125     unsigned char mdbuf[EVP_MAX_MD_SIZE];
 126     FILE *f;
 127     static char key[]="etaonrishdlcupfm";
 128     HMAC_CTX hmac;
 129
 130     f=fopen(path,"rb");
 131     if(!f)
 132         {
 133         FIPSerr(FIPS_F_FIPS_CHECK_EXE,FIPS_R_CANNOT_READ_EXE);
 134         return 0;
 135         }
 136     HMAC_Init(&hmac,key,strlen(key),EVP_sha1());
 137     while(!feof(f))
 138         {
 139         n=fread(buf,1,sizeof buf,f);
 140         if(ferror(f))
 141             {
 142             clearerr(f);
 143             fclose(f);
 144             FIPSerr(FIPS_F_FIPS_CHECK_EXE,FIPS_R_CANNOT_READ_EXE);
 145             return 0;
 146             }
 147         if (n) HMAC_Update(&hmac,buf,n);
 148         }
 149     fclose(f);
 150     HMAC_Final(&hmac,mdbuf,&n);
 151     BIO_snprintf(p2,sizeof p2,"%s.sha1",path);
 152     f=fopen(p2,"rb");
 153     if(!f || fread(buf,1,20,f) != 20)
 154         {
 155         if (f) fclose(f);
 156         FIPSerr(FIPS_F_FIPS_CHECK_EXE,FIPS_R_CANNOT_READ_EXE_DIGEST);
 157         return 0;
 158         }
 159     fclose(f);
 160     if(memcmp(buf,mdbuf,20))
 161         {
 162         FIPSerr(FIPS_F_FIPS_CHECK_EXE,FIPS_R_EXE_DIGEST_DOES_NOT_MATCH);
 163         return 0;
 164         }
 165     return 1;
 166     }
 167
 168 int FIPS_mode_set(int onoff,const char *path)
 169     {
 170     void fips_set_mode(int _onoff);
 171     int fips_set_owning_thread();
 172     int fips_clear_owning_thread();
 173     int ret = 0;
 174
 175     CRYPTO_w_lock(CRYPTO_LOCK_FIPS);
 176     fips_set_started();
 177     fips_set_owning_thread();
 178
 179     if(onoff)
 180         {
 181         unsigned char buf[24];
 182
 183         fips_selftest_fail = 0;
 184
 185         /* Don't go into FIPS mode twice, just so we can do automagic
 186            seeding */
 187         if(FIPS_mode())
 188             {
 189             FIPSerr(FIPS_F_FIPS_MODE_SET,FIPS_R_FIPS_MODE_ALREADY_SET);
 190             fips_selftest_fail = 1;
 191             ret = 0;
 192             goto end;
 193             }
 194
 195         if(!FIPS_check_exe(path))
 196             {
 197             fips_selftest_fail = 1;
 198             ret = 0;
 199             goto end;
 200             }
 201
 202         /* automagically seed PRNG if not already seeded */
 203         if(!FIPS_rand_seeded())
 204             {
 205             if(RAND_bytes(buf,sizeof buf) <= 0)
 206                 {
 207                 fips_selftest_fail = 1;
 208                 ret = 0;
 209                 goto end;
 210                 }
 211             FIPS_set_prng_key(buf,buf+8);
 212             FIPS_rand_seed(buf+16,8);
 213             }
 214
 215         /* now switch into FIPS mode */
 216         fips_set_rand_check(FIPS_rand_method());
 217         RAND_set_rand_method(FIPS_rand_method());
 218         if(FIPS_selftest())
 219             fips_set_mode(1);
 220         else
 221             {
 222             fips_selftest_fail = 1;
 223             ret = 0;
 224             goto end;
 225             }
 226         ret = 1;
 227         goto end;
 228         }
 229     fips_set_mode(0);
 230     fips_selftest_fail = 0;
 231     ret = 1;
 232 end:
 233     fips_clear_owning_thread();
 234     CRYPTO_w_unlock(CRYPTO_LOCK_FIPS);
 235     return ret;
 236     }
 237
 238 #if 0
 239 /* here just to cause error codes to exist */
 240 static void dummy()
 241     {
 242     FIPSerr(FIPS_F_HASH_FINAL,FIPS_F_NON_FIPS_METHOD);
 243     FIPSerr(FIPS_F_HASH_FINAL,FIPS_R_FIPS_SELFTEST_FAILED);
 244     }
 245 #endif
 246
 247 #endif