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
 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 /* valid iff crypto_lock_rand is set */
 162 static CRYPTO_THREADID locking_threadid;
 163
 164
 165 #ifdef PREDICT
 166 int rand_predictable=0;
 167 #endif
 168
 169 const char RAND_version[]="RAND" OPENSSL_VERSION_PTEXT;
 170
 171 static void rand_hw_seed(EVP_MD_CTX *ctx);
 172
 173 static void ssleay_rand_cleanup(void);
 174 static int ssleay_rand_seed(const void *buf, int num);
 175 static int ssleay_rand_add(const void *buf, int num, double add_entropy);
 176 static int ssleay_rand_bytes(unsigned char *buf, int num, int pseudo);
 177 static int ssleay_rand_nopseudo_bytes(unsigned char *buf, int num);
 178 static int ssleay_rand_pseudo_bytes(unsigned char *buf, int num);
 179 static int ssleay_rand_status(void);
 180
 181 static RAND_METHOD rand_ssleay_meth={
 182         ssleay_rand_seed,
 183         ssleay_rand_nopseudo_bytes,
 184         ssleay_rand_cleanup,
 185         ssleay_rand_add,
 186         ssleay_rand_pseudo_bytes,
 187         ssleay_rand_status
 188         };
 189
 190 RAND_METHOD *RAND_SSLeay(void)
 191         {
 192         return(&rand_ssleay_meth);
 193         }
 194
 195 static void ssleay_rand_cleanup(void)
 196         {
 197         OPENSSL_cleanse(state,sizeof(state));
 198         state_num=0;
 199         state_index=0;
 200         OPENSSL_cleanse(md,MD_DIGEST_LENGTH);
 201         md_count[0]=0;
 202         md_count[1]=0;
 203         entropy=0;
 204         initialized=0;
 205         }
 206
 207 static int ssleay_rand_add(const void *buf, int num, double add)
 208         {
 209         int i,j,k,st_idx;
 210         long md_c[2];
 211         unsigned char local_md[MD_DIGEST_LENGTH];
 212         EVP_MD_CTX m;
 213         int do_not_lock;
 214         int rv = 0;
 215
 216         if (!num)
 217                 return 1;
 218
 219         /*
 220          * (Based on the rand(3) manpage)
 221          *
 222          * The input is chopped up into units of 20 bytes (or less for
 223          * the last block).  Each of these blocks is run through the hash
 224          * function as follows:  The data passed to the hash function
 225          * is the current 'md', the same number of bytes from the 'state'
 226          * (the location determined by in incremented looping index) as
 227          * the current 'block', the new key data 'block', and 'count'
 228          * (which is incremented after each use).
 229          * The result of this is kept in 'md' and also xored into the
 230          * 'state' at the same locations that were used as input into the
 231          * hash function.
 232          */
 233
 234         EVP_MD_CTX_init(&m);
 235         /* check if we already have the lock */
 236         if (crypto_lock_rand)
 237                 {
 238                 CRYPTO_THREADID cur;
 239                 CRYPTO_THREADID_current(&cur);
 240                 CRYPTO_r_lock(CRYPTO_LOCK_RAND2);
 241                 do_not_lock = !CRYPTO_THREADID_cmp(&locking_threadid, &cur);
 242                 CRYPTO_r_unlock(CRYPTO_LOCK_RAND2);
 243                 }
 244         else
 245                 do_not_lock = 0;
 246
 247         if (!do_not_lock) CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 248         st_idx=state_index;
 249
 250         /* use our own copies of the counters so that even
 251          * if a concurrent thread seeds with exactly the
 252          * same data and uses the same subarray there's _some_
 253          * difference */
 254         md_c[0] = md_count[0];
 255         md_c[1] = md_count[1];
 256
 257         memcpy(local_md, md, sizeof md);
 258
 259         /* state_index <= state_num <= STATE_SIZE */
 260         state_index += num;
 261         if (state_index >= STATE_SIZE)
 262                 {
 263                 state_index%=STATE_SIZE;
 264                 state_num=STATE_SIZE;
 265                 }
 266         else if (state_num < STATE_SIZE)
 267                 {
 268                 if (state_index > state_num)
 269                         state_num=state_index;
 270                 }
 271         /* state_index <= state_num <= STATE_SIZE */
 272
 273         /* state[st_idx], ..., state[(st_idx + num - 1) % STATE_SIZE]
 274          * are what we will use now, but other threads may use them
 275          * as well */
 276
 277         md_count[1] += (num / MD_DIGEST_LENGTH) + (num % MD_DIGEST_LENGTH > 0);
 278
 279         if (!do_not_lock) CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 280
 281         for (i=0; i<num; i+=MD_DIGEST_LENGTH)
 282                 {
 283                 j=(num-i);
 284                 j=(j > MD_DIGEST_LENGTH)?MD_DIGEST_LENGTH:j;
 285
 286                 if (!MD_Init(&m))
 287                         goto err;
 288                 if (!MD_Update(&m,local_md,MD_DIGEST_LENGTH))
 289                         goto err;
 290                 k=(st_idx+j)-STATE_SIZE;
 291                 if (k > 0)
 292                         {
 293                         if (!MD_Update(&m,&(state[st_idx]),j-k))
 294                                 goto err;
 295                         if (!MD_Update(&m,&(state[0]),k))
 296                                 goto err;
 297                         }
 298                 else
 299                         if (!MD_Update(&m,&(state[st_idx]),j))
 300                                 goto err;
 301
 302                 /* DO NOT REMOVE THE FOLLOWING CALL TO MD_Update()! */
 303                 if (!MD_Update(&m,buf,j))
 304                         goto err;
 305                 /* We know that line may cause programs such as
 306                    purify and valgrind to complain about use of
 307                    uninitialized data.  The problem is not, it's
 308                    with the caller.  Removing that line will make
 309                    sure you get really bad randomness and thereby
 310                    other problems such as very insecure keys. */
 311
 312                 if (!MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c)))
 313                         goto err;
 314                 if (!MD_Final(&m,local_md))
 315                         goto err;
 316                 md_c[1]++;
 317
 318                 buf=(const char *)buf + j;
 319
 320                 for (k=0; k<j; k++)
 321                         {
 322                         /* Parallel threads may interfere with this,
 323                          * but always each byte of the new state is
 324                          * the XOR of some previous value of its
 325                          * and local_md (itermediate values may be lost).
 326                          * Alway using locking could hurt performance more
 327                          * than necessary given that conflicts occur only
 328                          * when the total seeding is longer than the random
 329                          * state. */
 330                         state[st_idx++]^=local_md[k];
 331                         if (st_idx >= STATE_SIZE)
 332                                 st_idx=0;
 333                         }
 334                 }
 335
 336         if (!do_not_lock) CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 337         /* Don't just copy back local_md into md -- this could mean that
 338          * other thread's seeding remains without effect (except for
 339          * the incremented counter).  By XORing it we keep at least as
 340          * much entropy as fits into md. */
 341         for (k = 0; k < (int)sizeof(md); k++)
 342                 {
 343                 md[k] ^= local_md[k];
 344                 }
 345         if (entropy < ENTROPY_NEEDED) /* stop counting when we have enough */
 346             entropy += add;
 347         if (!do_not_lock) CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 348
 349 #if !defined(OPENSSL_THREADS) && !defined(OPENSSL_SYS_WIN32)
 350         assert(md_c[1] == md_count[1]);
 351 #endif
 352         rv = 1;
 353         err:
 354         EVP_MD_CTX_cleanup(&m);
 355         return rv;
 356         }
 357
 358 static int ssleay_rand_seed(const void *buf, int num)
 359         {
 360         return ssleay_rand_add(buf, num, (double)num);
 361         }
 362
 363 static int ssleay_rand_bytes(unsigned char *buf, int num, int pseudo)
 364         {
 365         static volatile int stirred_pool = 0;
 366         int i,j,k,st_num,st_idx;
 367         int num_ceil;
 368         int ok;
 369         long md_c[2];
 370         unsigned char local_md[MD_DIGEST_LENGTH];
 371         EVP_MD_CTX m;
 372 #ifndef GETPID_IS_MEANINGLESS
 373         pid_t curr_pid = getpid();
 374 #endif
 375         time_t curr_time = time(NULL);
 376         int do_stir_pool = 0;
 377 /* time value for various platforms */
 378 #ifdef OPENSSL_SYS_WIN32
 379         FILETIME tv;
 380 # ifdef _WIN32_WCE
 381         SYSTEMTIME t;
 382         GetSystemTime(&t);
 383         SystemTimeToFileTime(&t, &tv);
 384 # else
 385         GetSystemTimeAsFileTime(&tv);
 386 # endif
 387 #elif defined(OPENSSL_SYS_VXWORKS)
 388         struct timespec tv;
 389         clock_gettime(CLOCK_REALTIME, &ts);
 390 #elif defined(OPENSSL_SYSNAME_DSPBIOS)
 391         unsigned long long tv, OPENSSL_rdtsc();
 392         tv = OPENSSL_rdtsc();
 393 #else
 394         struct timeval tv;
 395         gettimeofday(&tv, NULL);
 396 #endif
 397
 398 #ifdef PREDICT
 399         if (rand_predictable)
 400                 {
 401                 static unsigned char val=0;
 402
 403                 for (i=0; i<num; i++)
 404                         buf[i]=val++;
 405                 return(1);
 406                 }
 407 #endif
 408
 409         if (num <= 0)
 410                 return 1;
 411
 412         EVP_MD_CTX_init(&m);
 413         /* round upwards to multiple of MD_DIGEST_LENGTH/2 */
 414         num_ceil = (1 + (num-1)/(MD_DIGEST_LENGTH/2)) * (MD_DIGEST_LENGTH/2);
 415
 416         /*
 417          * (Based on the rand(3) manpage:)
 418          *
 419          * For each group of 10 bytes (or less), we do the following:
 420          *
 421          * Input into the hash function the local 'md' (which is initialized from
 422          * the global 'md' before any bytes are generated), the bytes that are to
 423          * be overwritten by the random bytes, and bytes from the 'state'
 424          * (incrementing looping index). From this digest output (which is kept
 425          * in 'md'), the top (up to) 10 bytes are returned to the caller and the
 426          * bottom 10 bytes are xored into the 'state'.
 427          *
 428          * Finally, after we have finished 'num' random bytes for the
 429          * caller, 'count' (which is incremented) and the local and global 'md'
 430          * are fed into the hash function and the results are kept in the
 431          * global 'md'.
 432          */
 433
 434         CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 435
 436         /* prevent ssleay_rand_bytes() from trying to obtain the lock again */
 437         CRYPTO_w_lock(CRYPTO_LOCK_RAND2);
 438         CRYPTO_THREADID_current(&locking_threadid);
 439         CRYPTO_w_unlock(CRYPTO_LOCK_RAND2);
 440         crypto_lock_rand = 1;
 441
 442         if (!initialized)
 443                 {
 444                 RAND_poll();
 445                 initialized = 1;
 446                 }
 447
 448         if (!stirred_pool)
 449                 do_stir_pool = 1;
 450
 451         ok = (entropy >= ENTROPY_NEEDED);
 452         if (!ok)
 453                 {
 454                 /* If the PRNG state is not yet unpredictable, then seeing
 455                  * the PRNG output may help attackers to determine the new
 456                  * state; thus we have to decrease the entropy estimate.
 457                  * Once we've had enough initial seeding we don't bother to
 458                  * adjust the entropy count, though, because we're not ambitious
 459                  * to provide *information-theoretic* randomness.
 460                  *
 461                  * NOTE: This approach fails if the program forks before
 462                  * we have enough entropy. Entropy should be collected
 463                  * in a separate input pool and be transferred to the
 464                  * output pool only when the entropy limit has been reached.
 465                  */
 466                 entropy -= num;
 467                 if (entropy < 0)
 468                         entropy = 0;
 469                 }
 470
 471         if (do_stir_pool)
 472                 {
 473                 /* In the output function only half of 'md' remains secret,
 474                  * so we better make sure that the required entropy gets
 475                  * 'evenly distributed' through 'state', our randomness pool.
 476                  * The input function (ssleay_rand_add) chains all of 'md',
 477                  * which makes it more suitable for this purpose.
 478                  */
 479
 480                 int n = STATE_SIZE; /* so that the complete pool gets accessed */
 481                 while (n > 0)
 482                         {
 483 #if MD_DIGEST_LENGTH > 20
 484 # error "Please adjust DUMMY_SEED."
 485 #endif
 486 #define DUMMY_SEED "...................." /* at least MD_DIGEST_LENGTH */
 487                         /* Note that the seed does not matter, it's just that
 488                          * ssleay_rand_add expects to have something to hash. */
 489                         ssleay_rand_add(DUMMY_SEED, MD_DIGEST_LENGTH, 0.0);
 490                         n -= MD_DIGEST_LENGTH;
 491                         }
 492                 if (ok)
 493                         stirred_pool = 1;
 494                 }
 495
 496         st_idx=state_index;
 497         st_num=state_num;
 498         md_c[0] = md_count[0];
 499         md_c[1] = md_count[1];
 500         memcpy(local_md, md, sizeof md);
 501
 502         state_index+=num_ceil;
 503         if (state_index > state_num)
 504                 state_index %= state_num;
 505
 506         /* state[st_idx], ..., state[(st_idx + num_ceil - 1) % st_num]
 507          * are now ours (but other threads may use them too) */
 508
 509         md_count[0] += 1;
 510
 511         /* before unlocking, we must clear 'crypto_lock_rand' */
 512         crypto_lock_rand = 0;
 513         CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 514
 515         while (num > 0)
 516                 {
 517                 /* num_ceil -= MD_DIGEST_LENGTH/2 */
 518                 j=(num >= MD_DIGEST_LENGTH/2)?MD_DIGEST_LENGTH/2:num;
 519                 num-=j;
 520                 if (!MD_Init(&m))
 521                         goto err;
 522 #ifndef GETPID_IS_MEANINGLESS
 523                 if (curr_pid) /* just in the first iteration to save time */
 524                         {
 525                         if (!MD_Update(&m,(unsigned char*)&curr_pid,
 526                                        sizeof curr_pid))
 527                                 goto err;
 528                         curr_pid = 0;
 529                         }
 530 #endif
 531                 if (curr_time) /* just in the first iteration to save time */
 532                         {
 533                         if (!MD_Update(&m,(unsigned char*)&curr_time,
 534                                        sizeof curr_time))
 535                                 goto err;
 536                         if (!MD_Update(&m,(unsigned char*)&tv,
 537                                        sizeof tv))
 538                                 goto err;
 539                         curr_time = 0;
 540                         rand_hw_seed(&m);
 541                         }
 542                 if (!MD_Update(&m,local_md,MD_DIGEST_LENGTH))
 543                         goto err;
 544                 if (!MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c)))
 545                         goto err;
 546
 547 #ifndef PURIFY /* purify complains */
 548                 /* The following line uses the supplied buffer as a small
 549                  * source of entropy: since this buffer is often uninitialised
 550                  * it may cause programs such as purify or valgrind to
 551                  * complain. So for those builds it is not used: the removal
 552                  * of such a small source of entropy has negligible impact on
 553                  * security.
 554                  */
 555                 if (!MD_Update(&m,buf,j))
 556                         goto err;
 557 #endif
 558
 559                 k=(st_idx+MD_DIGEST_LENGTH/2)-st_num;
 560                 if (k > 0)
 561                         {
 562                         if (!MD_Update(&m,&(state[st_idx]),MD_DIGEST_LENGTH/2-k))
 563                                 goto err;
 564                         if (!MD_Update(&m,&(state[0]),k))
 565                                 goto err;
 566                         }
 567                 else
 568                         if (!MD_Update(&m,&(state[st_idx]),MD_DIGEST_LENGTH/2))
 569                                 goto err;
 570                 if (!MD_Final(&m,local_md))
 571                         goto err;
 572
 573                 for (i=0; i<MD_DIGEST_LENGTH/2; i++)
 574                         {
 575                         /* may compete with other threads */
 576                         state[st_idx++]^=local_md[i];
 577                         if (st_idx >= st_num)
 578                                 st_idx=0;
 579                         if (i < j)
 580                                 *(buf++)=local_md[i+MD_DIGEST_LENGTH/2];
 581                         }
 582                 }
 583
 584         if (!MD_Init(&m)
 585                 || !MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c))
 586                 || !MD_Update(&m,local_md,MD_DIGEST_LENGTH))
 587                 goto err;
 588         CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 589         if (!MD_Update(&m,md,MD_DIGEST_LENGTH) || !MD_Final(&m,md))
 590                 {
 591                 CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 592                 goto err;
 593                 }
 594         CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 595
 596         EVP_MD_CTX_cleanup(&m);
 597         if (ok)
 598                 return(1);
 599         else if (pseudo)
 600                 return 0;
 601         else
 602                 {
 603                 RANDerr(RAND_F_SSLEAY_RAND_BYTES,RAND_R_PRNG_NOT_SEEDED);
 604                 ERR_add_error_data(1, "You need to read the OpenSSL FAQ, "
 605                         "http://www.openssl.org/support/faq.html");
 606                 return(0);
 607                 }
 608         err:
 609         EVP_MD_CTX_cleanup(&m);
 610         RANDerr(RAND_F_SSLEAY_RAND_BYTES,ERR_R_EVP_LIB);
 611         return 0;
 612
 613         }
 614
 615 static int ssleay_rand_nopseudo_bytes(unsigned char *buf, int num)
 616         {
 617         return ssleay_rand_bytes(buf, num, 0);
 618         }
 619
 620 /* pseudo-random bytes that are guaranteed to be unique but not
 621    unpredictable */
 622 static int ssleay_rand_pseudo_bytes(unsigned char *buf, int num)
 623         {
 624         return ssleay_rand_bytes(buf, num, 1);
 625         }
 626
 627 static int ssleay_rand_status(void)
 628         {
 629         CRYPTO_THREADID cur;
 630         int ret;
 631         int do_not_lock;
 632
 633         CRYPTO_THREADID_current(&cur);
 634         /* check if we already have the lock
 635          * (could happen if a RAND_poll() implementation calls RAND_status()) */
 636         if (crypto_lock_rand)
 637                 {
 638                 CRYPTO_r_lock(CRYPTO_LOCK_RAND2);
 639                 do_not_lock = !CRYPTO_THREADID_cmp(&locking_threadid, &cur);
 640                 CRYPTO_r_unlock(CRYPTO_LOCK_RAND2);
 641                 }
 642         else
 643                 do_not_lock = 0;
 644
 645         if (!do_not_lock)
 646                 {
 647                 CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 648
 649                 /* prevent ssleay_rand_bytes() from trying to obtain the lock again */
 650                 CRYPTO_w_lock(CRYPTO_LOCK_RAND2);
 651                 CRYPTO_THREADID_cpy(&locking_threadid, &cur);
 652                 CRYPTO_w_unlock(CRYPTO_LOCK_RAND2);
 653                 crypto_lock_rand = 1;
 654                 }
 655
 656         if (!initialized)
 657                 {
 658                 RAND_poll();
 659                 initialized = 1;
 660                 }
 661
 662         ret = entropy >= ENTROPY_NEEDED;
 663
 664         if (!do_not_lock)
 665                 {
 666                 /* before unlocking, we must clear 'crypto_lock_rand' */
 667                 crypto_lock_rand = 0;
 668
 669                 CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 670                 }
 671
 672         return ret;
 673         }
 674
 675 /* rand_hw_seed: get seed data from any available hardware RNG.
 676  * only currently supports rdrand.
 677  */
 678
 679 /* Adapted from eng_rdrand.c */
 680
 681 #if (defined(__i386)   || defined(__i386__)   || defined(_M_IX86) || \
 682      defined(__x86_64) || defined(__x86_64__) || \
 683      defined(_M_AMD64) || defined (_M_X64)) && defined(OPENSSL_CPUID_OBJ)
 684
 685 #define RDRAND_CALLS    4
 686
 687 size_t OPENSSL_ia32_rdrand(void);
 688 extern unsigned int OPENSSL_ia32cap_P[];
 689
 690 static void rand_hw_seed(EVP_MD_CTX *ctx)
 691         {
 692         int i;
 693         if (!(OPENSSL_ia32cap_P[1] & (1<<(62-32))))
 694                 return;
 695         for (i = 0; i < RDRAND_CALLS; i++)
 696                 {
 697                 size_t rnd;
 698                 rnd = OPENSSL_ia32_rdrand();
 699                 if (rnd == 0)
 700                         return;
 701                 MD_Update(ctx, (unsigned char *)&rnd, sizeof(size_t));
 702                 }
 703         }
 704
 705 /* XOR an existing buffer with random data */
 706
 707 void rand_hw_xor(unsigned char *buf, size_t num)
 708         {
 709         size_t rnd;
 710         if (!(OPENSSL_ia32cap_P[1] & (1<<(62-32))))
 711                 return;
 712         while (num >= sizeof(size_t))
 713                 {
 714                 rnd = OPENSSL_ia32_rdrand();
 715                 if (rnd == 0)
 716                         return;
 717                 *((size_t *)buf) ^= rnd;
 718                 buf += sizeof(size_t);
 719                 num -= sizeof(size_t);
 720                 }
 721         if (num)
 722                 {
 723                 rnd = OPENSSL_ia32_rdrand();
 724                 if (rnd == 0)
 725                         return;
 726                 while(num)
 727                         {
 728                         *buf ^= rnd & 0xff;
 729                         rnd >>= 8;
 730                         buf++;
 731                         num--;
 732                         }
 733                 }
 734         }
 735
 736
 737 #else
 738
 739 static void rand_hw_seed(EVP_MD_CTX *ctx)
 740         {
 741         return;
 742         }
 743
 744 void rand_hw_xor(unsigned char *buf, size_t num)
 745         {
 746         return;
 747         }
 748
 749 #endif