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_selftest_fail = 0;
  67 static int fips_mode = 0;
  68 static const void *fips_rand_check = 0;
  69
  70 static void fips_set_mode(int onoff)
  71         {
  72         int owning_thread = fips_is_owning_thread();
  73
  74         if (fips_is_started())
  75                 {
  76                 if (!owning_thread) fips_w_lock();
  77                 fips_mode = onoff;
  78                 if (!owning_thread) fips_w_unlock();
  79                 }
  80         }
  81
  82 static void fips_set_rand_check(const void *rand_check)
  83         {
  84         int owning_thread = fips_is_owning_thread();
  85
  86         if (fips_is_started())
  87                 {
  88                 if (!owning_thread) fips_w_lock();
  89                 fips_rand_check = rand_check;
  90                 if (!owning_thread) fips_w_unlock();
  91                 }
  92         }
  93
  94 int FIPS_mode(void)
  95         {
  96         int ret = 0;
  97         int owning_thread = fips_is_owning_thread();
  98
  99         if (fips_is_started())
 100                 {
 101                 if (!owning_thread) fips_r_lock();
 102                 ret = fips_mode;
 103                 if (!owning_thread) fips_r_unlock();
 104                 }
 105         return ret;
 106         }
 107
 108 const void *FIPS_rand_check(void)
 109         {
 110         const void *ret = 0;
 111         int owning_thread = fips_is_owning_thread();
 112
 113         if (fips_is_started())
 114                 {
 115                 if (!owning_thread) fips_r_lock();
 116                 ret = fips_rand_check;
 117                 if (!owning_thread) fips_r_unlock();
 118                 }
 119         return ret;
 120         }
 121
 122 int FIPS_selftest_failed(void)
 123     {
 124     int ret = 0;
 125     if (fips_is_started())
 126         {
 127         int owning_thread = fips_is_owning_thread();
 128
 129         if (!owning_thread) fips_r_lock();
 130         ret = fips_selftest_fail;
 131         if (!owning_thread) fips_r_unlock();
 132         }
 133     return ret;
 134     }
 135
 136 int FIPS_selftest()
 137     {
 138     ERR_load_crypto_strings();
 139
 140     return FIPS_selftest_sha1()
 141         && FIPS_selftest_aes()
 142         && FIPS_selftest_des()
 143         && FIPS_selftest_rsa()
 144         && FIPS_selftest_dsa();
 145     }
 146
 147 static int FIPS_check_exe(const char *path)
 148     {
 149     unsigned char buf[1024];
 150     char p2[PATH_MAX];
 151     unsigned int n;
 152     unsigned char mdbuf[EVP_MAX_MD_SIZE];
 153     FILE *f;
 154     static char key[]="etaonrishdlcupfm";
 155     HMAC_CTX hmac;
 156     const char *sha1_fmt="%s.sha1";
 157
 158     f=fopen(path,"rb");
 159 #ifdef __CYGWIN32__
 160     /* cygwin scrupulously strips .exe extentions:-( as of now it's
 161        actually no point to attempt above fopen, but we keep the call
 162        just in case the behavior changes in the future... */
 163     if (!f)
 164         {
 165         sha1_fmt="%s.exe.sha1";
 166         BIO_snprintf(p2,sizeof p2,"%s.exe",path);
 167         f=fopen(p2,"rb");
 168         }
 169 #endif
 170     if(!f)
 171         {
 172         FIPSerr(FIPS_F_FIPS_CHECK_EXE,FIPS_R_CANNOT_READ_EXE);
 173         return 0;
 174         }
 175     HMAC_Init(&hmac,key,strlen(key),EVP_sha1());
 176     while(!feof(f))
 177         {
 178         n=fread(buf,1,sizeof buf,f);
 179         if(ferror(f))
 180             {
 181             clearerr(f);
 182             fclose(f);
 183             FIPSerr(FIPS_F_FIPS_CHECK_EXE,FIPS_R_CANNOT_READ_EXE);
 184             return 0;
 185             }
 186         if (n) HMAC_Update(&hmac,buf,n);
 187         }
 188     fclose(f);
 189     HMAC_Final(&hmac,mdbuf,&n);
 190     HMAC_CTX_cleanup(&hmac);
 191     BIO_snprintf(p2,sizeof p2,sha1_fmt,path);
 192     f=fopen(p2,"rb");
 193     if(!f || fread(buf,1,20,f) != 20)
 194         {
 195         if (f) fclose(f);
 196         FIPSerr(FIPS_F_FIPS_CHECK_EXE,FIPS_R_CANNOT_READ_EXE_DIGEST);
 197         return 0;
 198         }
 199     fclose(f);
 200     if(memcmp(buf,mdbuf,20))
 201         {
 202         FIPSerr(FIPS_F_FIPS_CHECK_EXE,FIPS_R_EXE_DIGEST_DOES_NOT_MATCH);
 203         return 0;
 204         }
 205     return 1;
 206     }
 207
 208 int FIPS_mode_set(int onoff,const char *path)
 209     {
 210     void fips_set_mode(int _onoff);
 211     int fips_set_owning_thread();
 212     int fips_clear_owning_thread();
 213     int ret = 0;
 214
 215     fips_w_lock();
 216     fips_set_started();
 217     fips_set_owning_thread();
 218
 219     if(onoff)
 220         {
 221         unsigned char buf[24];
 222
 223         fips_selftest_fail = 0;
 224
 225         /* Don't go into FIPS mode twice, just so we can do automagic
 226            seeding */
 227         if(FIPS_mode())
 228             {
 229             FIPSerr(FIPS_F_FIPS_MODE_SET,FIPS_R_FIPS_MODE_ALREADY_SET);
 230             fips_selftest_fail = 1;
 231             ret = 0;
 232             goto end;
 233             }
 234
 235         if(!FIPS_check_exe(path))
 236             {
 237             fips_selftest_fail = 1;
 238             ret = 0;
 239             goto end;
 240             }
 241
 242         /* automagically seed PRNG if not already seeded */
 243         if(!FIPS_rand_seeded())
 244             {
 245             if(RAND_bytes(buf,sizeof buf) <= 0)
 246                 {
 247                 fips_selftest_fail = 1;
 248                 ret = 0;
 249                 goto end;
 250                 }
 251             FIPS_set_prng_key(buf,buf+8);
 252             FIPS_rand_seed(buf+16,8);
 253             }
 254
 255         /* now switch into FIPS mode */
 256         fips_set_rand_check(FIPS_rand_method());
 257         RAND_set_rand_method(FIPS_rand_method());
 258         if(FIPS_selftest())
 259             fips_set_mode(1);
 260         else
 261             {
 262             fips_selftest_fail = 1;
 263             ret = 0;
 264             goto end;
 265             }
 266         ret = 1;
 267         goto end;
 268         }
 269     fips_set_mode(0);
 270     fips_selftest_fail = 0;
 271     ret = 1;
 272 end:
 273     fips_clear_owning_thread();
 274     fips_w_unlock();
 275     return ret;
 276     }
 277
 278 #if 0
 279 /* here just to cause error codes to exist */
 280 static void dummy()
 281     {
 282     FIPSerr(FIPS_F_HASH_FINAL,FIPS_F_NON_FIPS_METHOD);
 283     FIPSerr(FIPS_F_HASH_FINAL,FIPS_R_FIPS_SELFTEST_FAILED);
 284     }
 285 #endif
 286
 287 #endif