crypto/rand/md_rand.c

   1 /* crypto/rand/md_rand.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58 /* ====================================================================
  59  * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
  60  *
  61  * Redistribution and use in source and binary forms, with or without
  62  * modification, are permitted provided that the following conditions
  63  * are met:
  64  *
  65  * 1. Redistributions of source code must retain the above copyright
  66  *    notice, this list of conditions and the following disclaimer.
  67  *
  68  * 2. Redistributions in binary form must reproduce the above copyright
  69  *    notice, this list of conditions and the following disclaimer in
  70  *    the documentation and/or other materials provided with the
  71  *    distribution.
  72  *
  73  * 3. All advertising materials mentioning features or use of this
  74  *    software must display the following acknowledgment:
  75  *    "This product includes software developed by the OpenSSL Project
  76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  77  *
  78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  79  *    endorse or promote products derived from this software without
  80  *    prior written permission. For written permission, please contact
  81  *    openssl-core@openssl.org.
  82  *
  83  * 5. Products derived from this software may not be called "OpenSSL"
  84  *    nor may "OpenSSL" appear in their names without prior written
  85  *    permission of the OpenSSL Project.
  86  *
  87  * 6. Redistributions of any form whatsoever must retain the following
  88  *    acknowledgment:
  89  *    "This product includes software developed by the OpenSSL Project
  90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  91  *
  92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 103  * OF THE POSSIBILITY OF SUCH DAMAGE.
 104  * ====================================================================
 105  *
 106  * This product includes cryptographic software written by Eric Young
 107  * (eay@cryptsoft.com).  This product includes software written by Tim
 108  * Hudson (tjh@cryptsoft.com).
 109  *
 110  */
 111
 112 #define OPENSSL_FIPSAPI
 113
 114 #ifdef MD_RAND_DEBUG
 115 # ifndef NDEBUG
 116 #   define NDEBUG
 117 # endif
 118 #endif
 119
 120 #include <assert.h>
 121 #include <stdio.h>
 122 #include <string.h>
 123
 124 #include "e_os.h"
 125
 126 #if !(defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_VXWORKS) || defined(OPENSSL_SYSNAME_DSPBIOS))
 127 # include <sys/time.h>
 128 #endif
 129 #if defined(OPENSSL_SYS_VXWORKS)
 130 # include <time.h>
 131 #endif
 132
 133 #include <openssl/crypto.h>
 134 #include <openssl/rand.h>
 135 #include "rand_lcl.h"
 136
 137 #include <openssl/err.h>
 138
 139 #ifdef OPENSSL_FIPS
 140 #include <openssl/fips.h>
 141 #endif
 142
 143 #ifdef BN_DEBUG
 144 # define PREDICT
 145 #endif
 146
 147 /* #define PREDICT      1 */
 148
 149 #define STATE_SIZE      1023
 150 static int state_num=0,state_index=0;
 151 static unsigned char state[STATE_SIZE+MD_DIGEST_LENGTH];
 152 static unsigned char md[MD_DIGEST_LENGTH];
 153 static long md_count[2]={0,0};
 154 static double entropy=0;
 155 static int initialized=0;
 156
 157 static unsigned int crypto_lock_rand = 0; /* may be set only when a thread
 158                                            * holds CRYPTO_LOCK_RAND
 159                                            * (to prevent double locking) */
 160 /* access to lockin_thread is synchronized by CRYPTO_LOCK_RAND2 */
 161 static CRYPTO_THREADID locking_threadid; /* valid iff crypto_lock_rand is set */
 162
 163
 164 #ifdef PREDICT
 165 int rand_predictable=0;
 166 #endif
 167
 168 const char RAND_version[]="RAND" OPENSSL_VERSION_PTEXT;
 169
 170 static void rand_hw_seed(EVP_MD_CTX *ctx);
 171
 172 static void ssleay_rand_cleanup(void);
 173 static int ssleay_rand_seed(const void *buf, int num);
 174 static int ssleay_rand_add(const void *buf, int num, double add_entropy);
 175 static int ssleay_rand_bytes(unsigned char *buf, int num, int pseudo);
 176 static int ssleay_rand_nopseudo_bytes(unsigned char *buf, int num);
 177 static int ssleay_rand_pseudo_bytes(unsigned char *buf, int num);
 178 static int ssleay_rand_status(void);
 179
 180 static RAND_METHOD rand_ssleay_meth={
 181         ssleay_rand_seed,
 182         ssleay_rand_nopseudo_bytes,
 183         ssleay_rand_cleanup,
 184         ssleay_rand_add,
 185         ssleay_rand_pseudo_bytes,
 186         ssleay_rand_status
 187         };
 188
 189 RAND_METHOD *RAND_SSLeay(void)
 190         {
 191         return(&rand_ssleay_meth);
 192         }
 193
 194 static void ssleay_rand_cleanup(void)
 195         {
 196         OPENSSL_cleanse(state,sizeof(state));
 197         state_num=0;
 198         state_index=0;
 199         OPENSSL_cleanse(md,MD_DIGEST_LENGTH);
 200         md_count[0]=0;
 201         md_count[1]=0;
 202         entropy=0;
 203         initialized=0;
 204         }
 205
 206 static int ssleay_rand_add(const void *buf, int num, double add)
 207         {
 208         int i,j,k,st_idx;
 209         long md_c[2];
 210         unsigned char local_md[MD_DIGEST_LENGTH];
 211         EVP_MD_CTX m;
 212         int do_not_lock;
 213         int rv = 0;
 214
 215         /*
 216          * (Based on the rand(3) manpage)
 217          *
 218          * The input is chopped up into units of 20 bytes (or less for
 219          * the last block).  Each of these blocks is run through the hash
 220          * function as follows:  The data passed to the hash function
 221          * is the current 'md', the same number of bytes from the 'state'
 222          * (the location determined by in incremented looping index) as
 223          * the current 'block', the new key data 'block', and 'count'
 224          * (which is incremented after each use).
 225          * The result of this is kept in 'md' and also xored into the
 226          * 'state' at the same locations that were used as input into the
 227          * hash function.
 228          */
 229
 230         EVP_MD_CTX_init(&m);
 231         /* check if we already have the lock */
 232         if (crypto_lock_rand)
 233                 {
 234                 CRYPTO_THREADID cur;
 235                 CRYPTO_THREADID_current(&cur);
 236                 CRYPTO_r_lock(CRYPTO_LOCK_RAND2);
 237                 do_not_lock = !CRYPTO_THREADID_cmp(&locking_threadid, &cur);
 238                 CRYPTO_r_unlock(CRYPTO_LOCK_RAND2);
 239                 }
 240         else
 241                 do_not_lock = 0;
 242
 243         if (!do_not_lock) CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 244         st_idx=state_index;
 245
 246         /* use our own copies of the counters so that even
 247          * if a concurrent thread seeds with exactly the
 248          * same data and uses the same subarray there's _some_
 249          * difference */
 250         md_c[0] = md_count[0];
 251         md_c[1] = md_count[1];
 252
 253         memcpy(local_md, md, sizeof md);
 254
 255         /* state_index <= state_num <= STATE_SIZE */
 256         state_index += num;
 257         if (state_index >= STATE_SIZE)
 258                 {
 259                 state_index%=STATE_SIZE;
 260                 state_num=STATE_SIZE;
 261                 }
 262         else if (state_num < STATE_SIZE)
 263                 {
 264                 if (state_index > state_num)
 265                         state_num=state_index;
 266                 }
 267         /* state_index <= state_num <= STATE_SIZE */
 268
 269         /* state[st_idx], ..., state[(st_idx + num - 1) % STATE_SIZE]
 270          * are what we will use now, but other threads may use them
 271          * as well */
 272
 273         md_count[1] += (num / MD_DIGEST_LENGTH) + (num % MD_DIGEST_LENGTH > 0);
 274
 275         if (!do_not_lock) CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 276
 277         for (i=0; i<num; i+=MD_DIGEST_LENGTH)
 278                 {
 279                 j=(num-i);
 280                 j=(j > MD_DIGEST_LENGTH)?MD_DIGEST_LENGTH:j;
 281
 282                 if (!MD_Init(&m))
 283                         goto err;
 284                 if (!MD_Update(&m,local_md,MD_DIGEST_LENGTH))
 285                         goto err;
 286                 k=(st_idx+j)-STATE_SIZE;
 287                 if (k > 0)
 288                         {
 289                         if (!MD_Update(&m,&(state[st_idx]),j-k))
 290                                 goto err;
 291                         if (!MD_Update(&m,&(state[0]),k))
 292                                 goto err;
 293                         }
 294                 else
 295                         if (!MD_Update(&m,&(state[st_idx]),j))
 296                                 goto err;
 297
 298                 /* DO NOT REMOVE THE FOLLOWING CALL TO MD_Update()! */
 299                 if (!MD_Update(&m,buf,j))
 300                         goto err;
 301                 /* We know that line may cause programs such as
 302                    purify and valgrind to complain about use of
 303                    uninitialized data.  The problem is not, it's
 304                    with the caller.  Removing that line will make
 305                    sure you get really bad randomness and thereby
 306                    other problems such as very insecure keys. */
 307
 308                 if (!MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c)))
 309                         goto err;
 310                 if (!MD_Final(&m,local_md))
 311                         goto err;
 312                 md_c[1]++;
 313
 314                 buf=(const char *)buf + j;
 315
 316                 for (k=0; k<j; k++)
 317                         {
 318                         /* Parallel threads may interfere with this,
 319                          * but always each byte of the new state is
 320                          * the XOR of some previous value of its
 321                          * and local_md (itermediate values may be lost).
 322                          * Alway using locking could hurt performance more
 323                          * than necessary given that conflicts occur only
 324                          * when the total seeding is longer than the random
 325                          * state. */
 326                         state[st_idx++]^=local_md[k];
 327                         if (st_idx >= STATE_SIZE)
 328                                 st_idx=0;
 329                         }
 330                 }
 331
 332         if (!do_not_lock) CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 333         /* Don't just copy back local_md into md -- this could mean that
 334          * other thread's seeding remains without effect (except for
 335          * the incremented counter).  By XORing it we keep at least as
 336          * much entropy as fits into md. */
 337         for (k = 0; k < (int)sizeof(md); k++)
 338                 {
 339                 md[k] ^= local_md[k];
 340                 }
 341         if (entropy < ENTROPY_NEEDED) /* stop counting when we have enough */
 342             entropy += add;
 343         if (!do_not_lock) CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 344
 345 #if !defined(OPENSSL_THREADS) && !defined(OPENSSL_SYS_WIN32)
 346         assert(md_c[1] == md_count[1]);
 347 #endif
 348         rv = 1;
 349         err:
 350         EVP_MD_CTX_cleanup(&m);
 351         return rv;
 352         }
 353
 354 static int ssleay_rand_seed(const void *buf, int num)
 355         {
 356         return ssleay_rand_add(buf, num, (double)num);
 357         }
 358
 359 static int ssleay_rand_bytes(unsigned char *buf, int num, int pseudo)
 360         {
 361         static volatile int stirred_pool = 0;
 362         int i,j,k,st_num,st_idx;
 363         int num_ceil;
 364         int ok;
 365         long md_c[2];
 366         unsigned char local_md[MD_DIGEST_LENGTH];
 367         EVP_MD_CTX m;
 368 #ifndef GETPID_IS_MEANINGLESS
 369         pid_t curr_pid = getpid();
 370 #endif
 371         time_t curr_time = time(NULL);
 372         int do_stir_pool = 0;
 373 /* time value for various platforms */
 374 #ifdef OPENSSL_SYS_WIN32
 375         FILETIME tv;
 376 # ifdef _WIN32_WCE
 377         SYSTEMTIME t;
 378         GetSystemTime(&t);
 379         SystemTimeToFileTime(&t, &tv);
 380 # else
 381         GetSystemTimeAsFileTime(&tv);
 382 # endif
 383 #elif defined(OPENSSL_SYS_VXWORKS)
 384         struct timespec tv;
 385         clock_gettime(CLOCK_REALTIME, &ts);
 386 #elif defined(OPENSSL_SYSNAME_DSPBIOS)
 387         unsigned long long tv, OPENSSL_rdtsc();
 388         tv = OPENSSL_rdtsc();
 389 #else
 390         struct timeval tv;
 391         gettimeofday(&tv, NULL);
 392 #endif
 393
 394 #ifdef PREDICT
 395         if (rand_predictable)
 396                 {
 397                 static unsigned char val=0;
 398
 399                 for (i=0; i<num; i++)
 400                         buf[i]=val++;
 401                 return(1);
 402                 }
 403 #endif
 404
 405         if (num <= 0)
 406                 return 1;
 407
 408         EVP_MD_CTX_init(&m);
 409         /* round upwards to multiple of MD_DIGEST_LENGTH/2 */
 410         num_ceil = (1 + (num-1)/(MD_DIGEST_LENGTH/2)) * (MD_DIGEST_LENGTH/2);
 411
 412         /*
 413          * (Based on the rand(3) manpage:)
 414          *
 415          * For each group of 10 bytes (or less), we do the following:
 416          *
 417          * Input into the hash function the local 'md' (which is initialized from
 418          * the global 'md' before any bytes are generated), the bytes that are to
 419          * be overwritten by the random bytes, and bytes from the 'state'
 420          * (incrementing looping index). From this digest output (which is kept
 421          * in 'md'), the top (up to) 10 bytes are returned to the caller and the
 422          * bottom 10 bytes are xored into the 'state'.
 423          *
 424          * Finally, after we have finished 'num' random bytes for the
 425          * caller, 'count' (which is incremented) and the local and global 'md'
 426          * are fed into the hash function and the results are kept in the
 427          * global 'md'.
 428          */
 429
 430         CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 431
 432         /* prevent ssleay_rand_bytes() from trying to obtain the lock again */
 433         CRYPTO_w_lock(CRYPTO_LOCK_RAND2);
 434         CRYPTO_THREADID_current(&locking_threadid);
 435         CRYPTO_w_unlock(CRYPTO_LOCK_RAND2);
 436         crypto_lock_rand = 1;
 437
 438         if (!initialized)
 439                 {
 440                 RAND_poll();
 441                 initialized = 1;
 442                 }
 443
 444         if (!stirred_pool)
 445                 do_stir_pool = 1;
 446
 447         ok = (entropy >= ENTROPY_NEEDED);
 448         if (!ok)
 449                 {
 450                 /* If the PRNG state is not yet unpredictable, then seeing
 451                  * the PRNG output may help attackers to determine the new
 452                  * state; thus we have to decrease the entropy estimate.
 453                  * Once we've had enough initial seeding we don't bother to
 454                  * adjust the entropy count, though, because we're not ambitious
 455                  * to provide *information-theoretic* randomness.
 456                  *
 457                  * NOTE: This approach fails if the program forks before
 458                  * we have enough entropy. Entropy should be collected
 459                  * in a separate input pool and be transferred to the
 460                  * output pool only when the entropy limit has been reached.
 461                  */
 462                 entropy -= num;
 463                 if (entropy < 0)
 464                         entropy = 0;
 465                 }
 466
 467         if (do_stir_pool)
 468                 {
 469                 /* In the output function only half of 'md' remains secret,
 470                  * so we better make sure that the required entropy gets
 471                  * 'evenly distributed' through 'state', our randomness pool.
 472                  * The input function (ssleay_rand_add) chains all of 'md',
 473                  * which makes it more suitable for this purpose.
 474                  */
 475
 476                 int n = STATE_SIZE; /* so that the complete pool gets accessed */
 477                 while (n > 0)
 478                         {
 479 #if MD_DIGEST_LENGTH > 20
 480 # error "Please adjust DUMMY_SEED."
 481 #endif
 482 #define DUMMY_SEED "...................." /* at least MD_DIGEST_LENGTH */
 483                         /* Note that the seed does not matter, it's just that
 484                          * ssleay_rand_add expects to have something to hash. */
 485                         ssleay_rand_add(DUMMY_SEED, MD_DIGEST_LENGTH, 0.0);
 486                         n -= MD_DIGEST_LENGTH;
 487                         }
 488                 if (ok)
 489                         stirred_pool = 1;
 490                 }
 491
 492         st_idx=state_index;
 493         st_num=state_num;
 494         md_c[0] = md_count[0];
 495         md_c[1] = md_count[1];
 496         memcpy(local_md, md, sizeof md);
 497
 498         state_index+=num_ceil;
 499         if (state_index > state_num)
 500                 state_index %= state_num;
 501
 502         /* state[st_idx], ..., state[(st_idx + num_ceil - 1) % st_num]
 503          * are now ours (but other threads may use them too) */
 504
 505         md_count[0] += 1;
 506
 507         /* before unlocking, we must clear 'crypto_lock_rand' */
 508         crypto_lock_rand = 0;
 509         CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 510
 511         while (num > 0)
 512                 {
 513                 /* num_ceil -= MD_DIGEST_LENGTH/2 */
 514                 j=(num >= MD_DIGEST_LENGTH/2)?MD_DIGEST_LENGTH/2:num;
 515                 num-=j;
 516                 if (!MD_Init(&m))
 517                         goto err;
 518 #ifndef GETPID_IS_MEANINGLESS
 519                 if (curr_pid) /* just in the first iteration to save time */
 520                         {
 521                         if (!MD_Update(&m,(unsigned char*)&curr_pid,
 522                                        sizeof curr_pid))
 523                                 goto err;
 524                         curr_pid = 0;
 525                         }
 526 #endif
 527                 if (curr_time) /* just in the first iteration to save time */
 528                         {
 529                         if (!MD_Update(&m,(unsigned char*)&curr_time,
 530                                        sizeof curr_time))
 531                                 goto err;
 532                         if (!MD_Update(&m,(unsigned char*)&tv,
 533                                        sizeof tv))
 534                                 goto err;
 535                         curr_time = 0;
 536                         rand_hw_seed(&m);
 537                         }
 538                 if (!MD_Update(&m,local_md,MD_DIGEST_LENGTH))
 539                         goto err;
 540                 if (!MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c)))
 541                         goto err;
 542
 543 #ifndef PURIFY /* purify complains */
 544                 /* The following line uses the supplied buffer as a small
 545                  * source of entropy: since this buffer is often uninitialised
 546                  * it may cause programs such as purify or valgrind to
 547                  * complain. So for those builds it is not used: the removal
 548                  * of such a small source of entropy has negligible impact on
 549                  * security.
 550                  */
 551                 if (!MD_Update(&m,buf,j))
 552                         goto err;
 553 #endif
 554
 555                 k=(st_idx+MD_DIGEST_LENGTH/2)-st_num;
 556                 if (k > 0)
 557                         {
 558                         if (!MD_Update(&m,&(state[st_idx]),MD_DIGEST_LENGTH/2-k))
 559                                 goto err;
 560                         if (!MD_Update(&m,&(state[0]),k))
 561                                 goto err;
 562                         }
 563                 else
 564                         if (!MD_Update(&m,&(state[st_idx]),MD_DIGEST_LENGTH/2))
 565                                 goto err;
 566                 if (!MD_Final(&m,local_md))
 567                         goto err;
 568
 569                 for (i=0; i<MD_DIGEST_LENGTH/2; i++)
 570                         {
 571                         state[st_idx++]^=local_md[i]; /* may compete with other threads */
 572                         if (st_idx >= st_num)
 573                                 st_idx=0;
 574                         if (i < j)
 575                                 *(buf++)=local_md[i+MD_DIGEST_LENGTH/2];
 576                         }
 577                 }
 578
 579         if (!MD_Init(&m)
 580                 || !MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c))
 581                 || !MD_Update(&m,local_md,MD_DIGEST_LENGTH))
 582                 goto err;
 583         CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 584         if (!MD_Update(&m,md,MD_DIGEST_LENGTH) || !MD_Final(&m,md))
 585                 {
 586                 CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 587                 goto err;
 588                 }
 589         CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 590
 591         EVP_MD_CTX_cleanup(&m);
 592         if (ok)
 593                 return(1);
 594         else if (pseudo)
 595                 return 0;
 596         else
 597                 {
 598                 RANDerr(RAND_F_SSLEAY_RAND_BYTES,RAND_R_PRNG_NOT_SEEDED);
 599                 ERR_add_error_data(1, "You need to read the OpenSSL FAQ, "
 600                         "http://www.openssl.org/support/faq.html");
 601                 return(0);
 602                 }
 603         err:
 604         EVP_MD_CTX_cleanup(&m);
 605         RANDerr(RAND_F_SSLEAY_RAND_BYTES,ERR_R_EVP_LIB);
 606         return 0;
 607
 608         }
 609
 610 static int ssleay_rand_nopseudo_bytes(unsigned char *buf, int num)
 611         {
 612         return ssleay_rand_bytes(buf, num, 0);
 613         }
 614
 615 /* pseudo-random bytes that are guaranteed to be unique but not
 616    unpredictable */
 617 static int ssleay_rand_pseudo_bytes(unsigned char *buf, int num)
 618         {
 619         return ssleay_rand_bytes(buf, num, 1);
 620         }
 621
 622 static int ssleay_rand_status(void)
 623         {
 624         CRYPTO_THREADID cur;
 625         int ret;
 626         int do_not_lock;
 627
 628         CRYPTO_THREADID_current(&cur);
 629         /* check if we already have the lock
 630          * (could happen if a RAND_poll() implementation calls RAND_status()) */
 631         if (crypto_lock_rand)
 632                 {
 633                 CRYPTO_r_lock(CRYPTO_LOCK_RAND2);
 634                 do_not_lock = !CRYPTO_THREADID_cmp(&locking_threadid, &cur);
 635                 CRYPTO_r_unlock(CRYPTO_LOCK_RAND2);
 636                 }
 637         else
 638                 do_not_lock = 0;
 639
 640         if (!do_not_lock)
 641                 {
 642                 CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 643
 644                 /* prevent ssleay_rand_bytes() from trying to obtain the lock again */
 645                 CRYPTO_w_lock(CRYPTO_LOCK_RAND2);
 646                 CRYPTO_THREADID_cpy(&locking_threadid, &cur);
 647                 CRYPTO_w_unlock(CRYPTO_LOCK_RAND2);
 648                 crypto_lock_rand = 1;
 649                 }
 650
 651         if (!initialized)
 652                 {
 653                 RAND_poll();
 654                 initialized = 1;
 655                 }
 656
 657         ret = entropy >= ENTROPY_NEEDED;
 658
 659         if (!do_not_lock)
 660                 {
 661                 /* before unlocking, we must clear 'crypto_lock_rand' */
 662                 crypto_lock_rand = 0;
 663
 664                 CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 665                 }
 666
 667         return ret;
 668         }
 669
 670 /* rand_hw_seed: get seed data from any available hardware RNG.
 671  * only currently supports rdrand.
 672  */
 673
 674 /* Adapted from eng_rdrand.c */
 675
 676 #if (defined(__i386)   || defined(__i386__)   || defined(_M_IX86) || \
 677      defined(__x86_64) || defined(__x86_64__) || \
 678      defined(_M_AMD64) || defined (_M_X64)) && defined(OPENSSL_CPUID_OBJ)
 679
 680 #define RDRAND_CALLS    4
 681
 682 size_t OPENSSL_ia32_rdrand(void);
 683 extern unsigned int OPENSSL_ia32cap_P[];
 684
 685 static void rand_hw_seed(EVP_MD_CTX *ctx)
 686         {
 687         int i;
 688         if (!(OPENSSL_ia32cap_P[1] & (1<<(62-32))))
 689                 return;
 690         for (i = 0; i < RDRAND_CALLS; i++)
 691                 {
 692                 size_t rnd;
 693                 rnd = OPENSSL_ia32_rdrand();
 694                 if (rnd == 0)
 695                         return;
 696                 MD_Update(ctx, (unsigned char *)&rnd, sizeof(size_t));
 697                 }
 698         }
 699
 700 /* XOR an existing buffer with random data */
 701
 702 void rand_hw_xor(unsigned char *buf, size_t num)
 703         {
 704         size_t rnd;
 705         if (!(OPENSSL_ia32cap_P[1] & (1<<(62-32))))
 706                 return;
 707         while (num >= sizeof(size_t))
 708                 {
 709                 rnd = OPENSSL_ia32_rdrand();
 710                 if (rnd == 0)
 711                         return;
 712                 *((size_t *)buf) ^= rnd;
 713                 buf += sizeof(size_t);
 714                 num -= sizeof(size_t);
 715                 }
 716         if (num)
 717                 {
 718                 rnd = OPENSSL_ia32_rdrand();
 719                 if (rnd == 0)
 720                         return;
 721                 while(num)
 722                         {
 723                         *buf ^= rnd & 0xff;
 724                         rnd >>= 8;
 725                         buf++;
 726                         num--;
 727                         }
 728                 }
 729         }
 730
 731
 732 #else
 733
 734 static void rand_hw_seed(EVP_MD_CTX *ctx)
 735         {
 736         return;
 737         }
 738
 739 void rand_hw_xor(unsigned char *buf, size_t num)
 740         {
 741         return;
 742         }
 743
 744 #endif