fips/rand/fips_rand.c

   1 /* ====================================================================
   2  * Copyright (c) 2007 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 #define OPENSSL_FIPSAPI
  51
  52 /*
  53  * This is a FIPS approved AES PRNG based on ANSI X9.31 A.2.4.
  54  */
  55
  56 #include "e_os.h"
  57
  58 /* If we don't define _XOPEN_SOURCE_EXTENDED, struct timeval won't
  59    be defined and gettimeofday() won't be declared with strict compilers
  60    like DEC C in ANSI C mode.  */
  61 #ifndef _XOPEN_SOURCE_EXTENDED
  62 #define _XOPEN_SOURCE_EXTENDED 1
  63 #endif
  64
  65 #include <openssl/rand.h>
  66 #include <openssl/aes.h>
  67 #include <openssl/err.h>
  68 #include <openssl/fips_rand.h>
  69 #ifndef OPENSSL_SYS_WIN32
  70 #include <sys/time.h>
  71 #endif
  72 #include <assert.h>
  73 #ifndef OPENSSL_SYS_WIN32
  74 # ifdef OPENSSL_UNISTD
  75 #  include OPENSSL_UNISTD
  76 # else
  77 #  include <unistd.h>
  78 # endif
  79 #endif
  80 #include <string.h>
  81 #include <openssl/fips.h>
  82 #include "fips_locl.h"
  83
  84 #ifdef OPENSSL_FIPS
  85
  86 void *OPENSSL_stderr(void);
  87
  88 #define AES_BLOCK_LENGTH        16
  89
  90
  91 /* AES FIPS PRNG implementation */
  92
  93 typedef struct
  94         {
  95         int seeded;
  96         int keyed;
  97         int test_mode;
  98         int second;
  99         int error;
 100         unsigned long counter;
 101         AES_KEY ks;
 102         int vpos;
 103         /* Temporary storage for key if it equals seed length */
 104         unsigned char tmp_key[AES_BLOCK_LENGTH];
 105         unsigned char V[AES_BLOCK_LENGTH];
 106         unsigned char DT[AES_BLOCK_LENGTH];
 107         unsigned char last[AES_BLOCK_LENGTH];
 108         } FIPS_PRNG_CTX;
 109
 110 static FIPS_PRNG_CTX sctx;
 111
 112 static int fips_prng_fail = 0;
 113
 114 void FIPS_rng_stick(void)
 115         {
 116         fips_prng_fail = 1;
 117         }
 118
 119 static void fips_rand_prng_reset(FIPS_PRNG_CTX *ctx)
 120         {
 121         ctx->seeded = 0;
 122         ctx->keyed = 0;
 123         ctx->test_mode = 0;
 124         ctx->counter = 0;
 125         ctx->second = 0;
 126         ctx->error = 0;
 127         ctx->vpos = 0;
 128         OPENSSL_cleanse(ctx->V, AES_BLOCK_LENGTH);
 129         OPENSSL_cleanse(&ctx->ks, sizeof(AES_KEY));
 130         }
 131
 132
 133 static int fips_set_prng_key(FIPS_PRNG_CTX *ctx,
 134                         const unsigned char *key, unsigned int keylen)
 135         {
 136         FIPS_selftest_check();
 137         if (keylen != 16 && keylen != 24 && keylen != 32)
 138                 {
 139                 /* error: invalid key size */
 140                 return 0;
 141                 }
 142         AES_set_encrypt_key(key, keylen << 3, &ctx->ks);
 143         if (keylen == 16)
 144                 {
 145                 memcpy(ctx->tmp_key, key, 16);
 146                 ctx->keyed = 2;
 147                 }
 148         else
 149                 ctx->keyed = 1;
 150         ctx->seeded = 0;
 151         ctx->second = 0;
 152         return 1;
 153         }
 154
 155 static int fips_set_prng_seed(FIPS_PRNG_CTX *ctx,
 156                         const unsigned char *seed, unsigned int seedlen)
 157         {
 158         unsigned int i;
 159         if (!ctx->keyed)
 160                 return 0;
 161         /* In test mode seed is just supplied data */
 162         if (ctx->test_mode)
 163                 {
 164                 if (seedlen != AES_BLOCK_LENGTH)
 165                         return 0;
 166                 memcpy(ctx->V, seed, AES_BLOCK_LENGTH);
 167                 ctx->seeded = 1;
 168                 return 1;
 169                 }
 170         /* Outside test mode XOR supplied data with existing seed */
 171         for (i = 0; i < seedlen; i++)
 172                 {
 173                 ctx->V[ctx->vpos++] ^= seed[i];
 174                 if (ctx->vpos == AES_BLOCK_LENGTH)
 175                         {
 176                         ctx->vpos = 0;
 177                         /* Special case if first seed and key length equals
 178                          * block size check key and seed do not match.
 179                          */
 180                         if (ctx->keyed == 2)
 181                                 {
 182                                 if (!memcmp(ctx->tmp_key, ctx->V, 16))
 183                                         {
 184                                         RANDerr(RAND_F_FIPS_SET_PRNG_SEED,
 185                                                 RAND_R_PRNG_SEED_MUST_NOT_MATCH_KEY);
 186                                         return 0;
 187                                         }
 188                                 OPENSSL_cleanse(ctx->tmp_key, 16);
 189                                 ctx->keyed = 1;
 190                                 }
 191                         ctx->seeded = 1;
 192                         }
 193                 }
 194         return 1;
 195         }
 196
 197 static int fips_set_test_mode(FIPS_PRNG_CTX *ctx)
 198         {
 199         if (ctx->keyed)
 200                 {
 201                 RANDerr(RAND_F_FIPS_SET_TEST_MODE,RAND_R_PRNG_KEYED);
 202                 return 0;
 203                 }
 204         ctx->test_mode = 1;
 205         return 1;
 206         }
 207
 208 int FIPS_rand_test_mode(void)
 209         {
 210         return fips_set_test_mode(&sctx);
 211         }
 212
 213 int FIPS_rand_set_dt(unsigned char *dt)
 214         {
 215         if (!sctx.test_mode)
 216                 {
 217                 RANDerr(RAND_F_FIPS_RAND_SET_DT,RAND_R_NOT_IN_TEST_MODE);
 218                 return 0;
 219                 }
 220         memcpy(sctx.DT, dt, AES_BLOCK_LENGTH);
 221         return 1;
 222         }
 223
 224 static void fips_get_dt(FIPS_PRNG_CTX *ctx)
 225     {
 226 #ifdef OPENSSL_SYS_WIN32
 227         FILETIME ft;
 228 #else
 229         struct timeval tv;
 230 #endif
 231         unsigned char *buf = ctx->DT;
 232
 233 #ifndef GETPID_IS_MEANINGLESS
 234         unsigned long pid;
 235 #endif
 236
 237 #ifdef OPENSSL_SYS_WIN32
 238         GetSystemTimeAsFileTime(&ft);
 239         buf[0] = (unsigned char) (ft.dwHighDateTime & 0xff);
 240         buf[1] = (unsigned char) ((ft.dwHighDateTime >> 8) & 0xff);
 241         buf[2] = (unsigned char) ((ft.dwHighDateTime >> 16) & 0xff);
 242         buf[3] = (unsigned char) ((ft.dwHighDateTime >> 24) & 0xff);
 243         buf[4] = (unsigned char) (ft.dwLowDateTime & 0xff);
 244         buf[5] = (unsigned char) ((ft.dwLowDateTime >> 8) & 0xff);
 245         buf[6] = (unsigned char) ((ft.dwLowDateTime >> 16) & 0xff);
 246         buf[7] = (unsigned char) ((ft.dwLowDateTime >> 24) & 0xff);
 247 #else
 248         gettimeofday(&tv,NULL);
 249         buf[0] = (unsigned char) (tv.tv_sec & 0xff);
 250         buf[1] = (unsigned char) ((tv.tv_sec >> 8) & 0xff);
 251         buf[2] = (unsigned char) ((tv.tv_sec >> 16) & 0xff);
 252         buf[3] = (unsigned char) ((tv.tv_sec >> 24) & 0xff);
 253         buf[4] = (unsigned char) (tv.tv_usec & 0xff);
 254         buf[5] = (unsigned char) ((tv.tv_usec >> 8) & 0xff);
 255         buf[6] = (unsigned char) ((tv.tv_usec >> 16) & 0xff);
 256         buf[7] = (unsigned char) ((tv.tv_usec >> 24) & 0xff);
 257 #endif
 258         buf[8] = (unsigned char) (ctx->counter & 0xff);
 259         buf[9] = (unsigned char) ((ctx->counter >> 8) & 0xff);
 260         buf[10] = (unsigned char) ((ctx->counter >> 16) & 0xff);
 261         buf[11] = (unsigned char) ((ctx->counter >> 24) & 0xff);
 262
 263         ctx->counter++;
 264
 265
 266 #ifndef GETPID_IS_MEANINGLESS
 267         pid=(unsigned long)getpid();
 268         buf[12] = (unsigned char) (pid & 0xff);
 269         buf[13] = (unsigned char) ((pid >> 8) & 0xff);
 270         buf[14] = (unsigned char) ((pid >> 16) & 0xff);
 271         buf[15] = (unsigned char) ((pid >> 24) & 0xff);
 272 #endif
 273     }
 274
 275 static int fips_rand(FIPS_PRNG_CTX *ctx,
 276                         unsigned char *out, unsigned int outlen)
 277         {
 278         unsigned char R[AES_BLOCK_LENGTH], I[AES_BLOCK_LENGTH];
 279         unsigned char tmp[AES_BLOCK_LENGTH];
 280         int i;
 281         if (ctx->error)
 282                 {
 283                 RANDerr(RAND_F_FIPS_RAND,RAND_R_PRNG_ERROR);
 284                 return 0;
 285                 }
 286         if (!ctx->keyed)
 287                 {
 288                 RANDerr(RAND_F_FIPS_RAND,RAND_R_NO_KEY_SET);
 289                 return 0;
 290                 }
 291         if (!ctx->seeded)
 292                 {
 293                 RANDerr(RAND_F_FIPS_RAND,RAND_R_PRNG_NOT_SEEDED);
 294                 return 0;
 295                 }
 296         for (;;)
 297                 {
 298                 if (!ctx->test_mode)
 299                         fips_get_dt(ctx);
 300                 AES_encrypt(ctx->DT, I, &ctx->ks);
 301                 for (i = 0; i < AES_BLOCK_LENGTH; i++)
 302                         tmp[i] = I[i] ^ ctx->V[i];
 303                 AES_encrypt(tmp, R, &ctx->ks);
 304                 for (i = 0; i < AES_BLOCK_LENGTH; i++)
 305                         tmp[i] = R[i] ^ I[i];
 306                 AES_encrypt(tmp, ctx->V, &ctx->ks);
 307                 /* Continuous PRNG test */
 308                 if (ctx->second)
 309                         {
 310                         if (fips_prng_fail)
 311                                 memcpy(ctx->last, R, AES_BLOCK_LENGTH);
 312                         if (!memcmp(R, ctx->last, AES_BLOCK_LENGTH))
 313                                 {
 314                                 RANDerr(RAND_F_FIPS_RAND,RAND_R_PRNG_STUCK);
 315                                 ctx->error = 1;
 316                                 fips_set_selftest_fail();
 317                                 return 0;
 318                                 }
 319                         }
 320                 memcpy(ctx->last, R, AES_BLOCK_LENGTH);
 321                 if (!ctx->second)
 322                         {
 323                         ctx->second = 1;
 324                         if (!ctx->test_mode)
 325                                 continue;
 326                         }
 327
 328                 if (outlen <= AES_BLOCK_LENGTH)
 329                         {
 330                         memcpy(out, R, outlen);
 331                         break;
 332                         }
 333
 334                 memcpy(out, R, AES_BLOCK_LENGTH);
 335                 out += AES_BLOCK_LENGTH;
 336                 outlen -= AES_BLOCK_LENGTH;
 337                 }
 338         return 1;
 339         }
 340
 341
 342 int FIPS_rand_set_key(const unsigned char *key, int keylen)
 343         {
 344         int ret;
 345         CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 346         ret = fips_set_prng_key(&sctx, key, keylen);
 347         CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 348         return ret;
 349         }
 350
 351 int FIPS_rand_seed(const void *seed, int seedlen)
 352         {
 353         int ret;
 354         CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 355         ret = fips_set_prng_seed(&sctx, seed, seedlen);
 356         CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 357         return ret;
 358         }
 359
 360
 361 int FIPS_rand_bytes(unsigned char *out, int count)
 362         {
 363         int ret;
 364         CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 365         ret = fips_rand(&sctx, out, count);
 366         CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 367         return ret;
 368         }
 369
 370 int FIPS_rand_status(void)
 371         {
 372         int ret;
 373         CRYPTO_r_lock(CRYPTO_LOCK_RAND);
 374         ret = sctx.seeded;
 375         CRYPTO_r_unlock(CRYPTO_LOCK_RAND);
 376         return ret;
 377         }
 378
 379 void FIPS_rand_reset(void)
 380         {
 381         CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 382         fips_rand_prng_reset(&sctx);
 383         CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 384         }
 385
 386 static int fips_do_rand_seed(const void *seed, int seedlen)
 387         {
 388         FIPS_rand_seed(seed, seedlen);
 389         return 1;
 390         }
 391
 392 static int fips_do_rand_add(const void *seed, int seedlen,
 393                                         double add_entropy)
 394         {
 395         FIPS_rand_seed(seed, seedlen);
 396         return 1;
 397         }
 398
 399 static const RAND_METHOD rand_fips_meth=
 400     {
 401     fips_do_rand_seed,
 402     FIPS_rand_bytes,
 403     FIPS_rand_reset,
 404     fips_do_rand_add,
 405     FIPS_rand_bytes,
 406     FIPS_rand_status
 407     };
 408
 409 const RAND_METHOD *FIPS_rand_method(void)
 410 {
 411   return &rand_fips_meth;
 412 }
 413
 414 #endif