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 #ifdef MD_RAND_DEBUG
 113 # ifndef NDEBUG
 114 #   define NDEBUG
 115 # endif
 116 #endif
 117
 118 #include <assert.h>
 119 #include <stdio.h>
 120 #include <string.h>
 121
 122 #include "e_os.h"
 123
 124 #include <openssl/rand.h>
 125 #include "rand_lcl.h"
 126
 127 #include <openssl/crypto.h>
 128 #include <openssl/err.h>
 129
 130 #ifdef BN_DEBUG
 131 # define PREDICT
 132 #endif
 133
 134 /* #define PREDICT      1 */
 135
 136 #define STATE_SIZE      1023
 137 static int state_num=0,state_index=0;
 138 static unsigned char state[STATE_SIZE+MD_DIGEST_LENGTH];
 139 static unsigned char md[MD_DIGEST_LENGTH];
 140 static long md_count[2]={0,0};
 141 static double entropy=0;
 142 static int initialized=0;
 143
 144 static unsigned int crypto_lock_rand = 0; /* may be set only when a thread
 145                                            * holds CRYPTO_LOCK_RAND
 146                                            * (to prevent double locking) */
 147 /* access to lockin_thread is synchronized by CRYPTO_LOCK_RAND2 */
 148 static CRYPTO_THREADID locking_threadid; /* valid iff crypto_lock_rand is set */
 149
 150
 151 #ifdef PREDICT
 152 int rand_predictable=0;
 153 #endif
 154
 155 const char RAND_version[]="RAND" OPENSSL_VERSION_PTEXT;
 156
 157 static void ssleay_rand_cleanup(void);
 158 static int ssleay_rand_seed(const void *buf, int num);
 159 static int ssleay_rand_add(const void *buf, int num, double add_entropy);
 160 static int ssleay_rand_bytes(unsigned char *buf, int num);
 161 static int ssleay_rand_pseudo_bytes(unsigned char *buf, int num);
 162 static int ssleay_rand_status(void);
 163
 164 RAND_METHOD rand_ssleay_meth={
 165         ssleay_rand_seed,
 166         ssleay_rand_bytes,
 167         ssleay_rand_cleanup,
 168         ssleay_rand_add,
 169         ssleay_rand_pseudo_bytes,
 170         ssleay_rand_status
 171         };
 172
 173 RAND_METHOD *RAND_SSLeay(void)
 174         {
 175         return(&rand_ssleay_meth);
 176         }
 177
 178 static void ssleay_rand_cleanup(void)
 179         {
 180         OPENSSL_cleanse(state,sizeof(state));
 181         state_num=0;
 182         state_index=0;
 183         OPENSSL_cleanse(md,MD_DIGEST_LENGTH);
 184         md_count[0]=0;
 185         md_count[1]=0;
 186         entropy=0;
 187         initialized=0;
 188         }
 189
 190 static int ssleay_rand_add(const void *buf, int num, double add)
 191         {
 192         int i,j,k,st_idx;
 193         long md_c[2];
 194         unsigned char local_md[MD_DIGEST_LENGTH];
 195         EVP_MD_CTX m;
 196         int do_not_lock;
 197         int rv = 0;
 198
 199         /*
 200          * (Based on the rand(3) manpage)
 201          *
 202          * The input is chopped up into units of 20 bytes (or less for
 203          * the last block).  Each of these blocks is run through the hash
 204          * function as follows:  The data passed to the hash function
 205          * is the current 'md', the same number of bytes from the 'state'
 206          * (the location determined by in incremented looping index) as
 207          * the current 'block', the new key data 'block', and 'count'
 208          * (which is incremented after each use).
 209          * The result of this is kept in 'md' and also xored into the
 210          * 'state' at the same locations that were used as input into the
 211          * hash function.
 212          */
 213
 214         EVP_MD_CTX_init(&m);
 215         /* check if we already have the lock */
 216         if (crypto_lock_rand)
 217                 {
 218                 CRYPTO_THREADID cur;
 219                 CRYPTO_THREADID_current(&cur);
 220                 CRYPTO_r_lock(CRYPTO_LOCK_RAND2);
 221                 do_not_lock = !CRYPTO_THREADID_cmp(&locking_threadid, &cur);
 222                 CRYPTO_r_unlock(CRYPTO_LOCK_RAND2);
 223                 }
 224         else
 225                 do_not_lock = 0;
 226
 227         if (!do_not_lock) CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 228         st_idx=state_index;
 229
 230         /* use our own copies of the counters so that even
 231          * if a concurrent thread seeds with exactly the
 232          * same data and uses the same subarray there's _some_
 233          * difference */
 234         md_c[0] = md_count[0];
 235         md_c[1] = md_count[1];
 236
 237         memcpy(local_md, md, sizeof md);
 238
 239         /* state_index <= state_num <= STATE_SIZE */
 240         state_index += num;
 241         if (state_index >= STATE_SIZE)
 242                 {
 243                 state_index%=STATE_SIZE;
 244                 state_num=STATE_SIZE;
 245                 }
 246         else if (state_num < STATE_SIZE)
 247                 {
 248                 if (state_index > state_num)
 249                         state_num=state_index;
 250                 }
 251         /* state_index <= state_num <= STATE_SIZE */
 252
 253         /* state[st_idx], ..., state[(st_idx + num - 1) % STATE_SIZE]
 254          * are what we will use now, but other threads may use them
 255          * as well */
 256
 257         md_count[1] += (num / MD_DIGEST_LENGTH) + (num % MD_DIGEST_LENGTH > 0);
 258
 259         if (!do_not_lock) CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 260
 261         for (i=0; i<num; i+=MD_DIGEST_LENGTH)
 262                 {
 263                 j=(num-i);
 264                 j=(j > MD_DIGEST_LENGTH)?MD_DIGEST_LENGTH:j;
 265
 266                 if (!MD_Init(&m))
 267                         goto err;
 268                 if (!MD_Update(&m,local_md,MD_DIGEST_LENGTH))
 269                         goto err;
 270                 k=(st_idx+j)-STATE_SIZE;
 271                 if (k > 0)
 272                         {
 273                         if (!MD_Update(&m,&(state[st_idx]),j-k))
 274                                 goto err;
 275                         if (!MD_Update(&m,&(state[0]),k))
 276                                 goto err;
 277                         }
 278                 else
 279                         if (!MD_Update(&m,&(state[st_idx]),j))
 280                                 goto err;
 281
 282                 /* DO NOT REMOVE THE FOLLOWING CALL TO MD_Update()! */
 283                 if (!MD_Update(&m,buf,j))
 284                         goto err;
 285                 /* We know that line may cause programs such as
 286                    purify and valgrind to complain about use of
 287                    uninitialized data.  The problem is not, it's
 288                    with the caller.  Removing that line will make
 289                    sure you get really bad randomness and thereby
 290                    other problems such as very insecure keys. */
 291
 292                 if (!MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c)))
 293                         goto err;
 294                 if (!MD_Final(&m,local_md))
 295                         goto err;
 296                 md_c[1]++;
 297
 298                 buf=(const char *)buf + j;
 299
 300                 for (k=0; k<j; k++)
 301                         {
 302                         /* Parallel threads may interfere with this,
 303                          * but always each byte of the new state is
 304                          * the XOR of some previous value of its
 305                          * and local_md (itermediate values may be lost).
 306                          * Alway using locking could hurt performance more
 307                          * than necessary given that conflicts occur only
 308                          * when the total seeding is longer than the random
 309                          * state. */
 310                         state[st_idx++]^=local_md[k];
 311                         if (st_idx >= STATE_SIZE)
 312                                 st_idx=0;
 313                         }
 314                 }
 315
 316         if (!do_not_lock) CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 317         /* Don't just copy back local_md into md -- this could mean that
 318          * other thread's seeding remains without effect (except for
 319          * the incremented counter).  By XORing it we keep at least as
 320          * much entropy as fits into md. */
 321         for (k = 0; k < (int)sizeof(md); k++)
 322                 {
 323                 md[k] ^= local_md[k];
 324                 }
 325         if (entropy < ENTROPY_NEEDED) /* stop counting when we have enough */
 326             entropy += add;
 327         if (!do_not_lock) CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 328
 329 #if !defined(OPENSSL_THREADS) && !defined(OPENSSL_SYS_WIN32)
 330         assert(md_c[1] == md_count[1]);
 331 #endif
 332         rv = 1;
 333         err:
 334         EVP_MD_CTX_cleanup(&m);
 335         return rv;
 336         }
 337
 338 static int ssleay_rand_seed(const void *buf, int num)
 339         {
 340         return ssleay_rand_add(buf, num, (double)num);
 341         }
 342
 343 static int ssleay_rand_bytes(unsigned char *buf, int num)
 344         {
 345         static volatile int stirred_pool = 0;
 346         int i,j,k,st_num,st_idx;
 347         int num_ceil;
 348         int ok;
 349         long md_c[2];
 350         unsigned char local_md[MD_DIGEST_LENGTH];
 351         EVP_MD_CTX m;
 352 #ifndef GETPID_IS_MEANINGLESS
 353         pid_t curr_pid = getpid();
 354 #endif
 355         int do_stir_pool = 0;
 356
 357 #ifdef PREDICT
 358         if (rand_predictable)
 359                 {
 360                 static unsigned char val=0;
 361
 362                 for (i=0; i<num; i++)
 363                         buf[i]=val++;
 364                 return(1);
 365                 }
 366 #endif
 367
 368         if (num <= 0)
 369                 return 1;
 370
 371         EVP_MD_CTX_init(&m);
 372         /* round upwards to multiple of MD_DIGEST_LENGTH/2 */
 373         num_ceil = (1 + (num-1)/(MD_DIGEST_LENGTH/2)) * (MD_DIGEST_LENGTH/2);
 374
 375         /*
 376          * (Based on the rand(3) manpage:)
 377          *
 378          * For each group of 10 bytes (or less), we do the following:
 379          *
 380          * Input into the hash function the local 'md' (which is initialized from
 381          * the global 'md' before any bytes are generated), the bytes that are to
 382          * be overwritten by the random bytes, and bytes from the 'state'
 383          * (incrementing looping index). From this digest output (which is kept
 384          * in 'md'), the top (up to) 10 bytes are returned to the caller and the
 385          * bottom 10 bytes are xored into the 'state'.
 386          *
 387          * Finally, after we have finished 'num' random bytes for the
 388          * caller, 'count' (which is incremented) and the local and global 'md'
 389          * are fed into the hash function and the results are kept in the
 390          * global 'md'.
 391          */
 392
 393         CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 394
 395         /* prevent ssleay_rand_bytes() from trying to obtain the lock again */
 396         CRYPTO_w_lock(CRYPTO_LOCK_RAND2);
 397         CRYPTO_THREADID_current(&locking_threadid);
 398         CRYPTO_w_unlock(CRYPTO_LOCK_RAND2);
 399         crypto_lock_rand = 1;
 400
 401         if (!initialized)
 402                 {
 403                 RAND_poll();
 404                 initialized = 1;
 405                 }
 406
 407         if (!stirred_pool)
 408                 do_stir_pool = 1;
 409
 410         ok = (entropy >= ENTROPY_NEEDED);
 411         if (!ok)
 412                 {
 413                 /* If the PRNG state is not yet unpredictable, then seeing
 414                  * the PRNG output may help attackers to determine the new
 415                  * state; thus we have to decrease the entropy estimate.
 416                  * Once we've had enough initial seeding we don't bother to
 417                  * adjust the entropy count, though, because we're not ambitious
 418                  * to provide *information-theoretic* randomness.
 419                  *
 420                  * NOTE: This approach fails if the program forks before
 421                  * we have enough entropy. Entropy should be collected
 422                  * in a separate input pool and be transferred to the
 423                  * output pool only when the entropy limit has been reached.
 424                  */
 425                 entropy -= num;
 426                 if (entropy < 0)
 427                         entropy = 0;
 428                 }
 429
 430         if (do_stir_pool)
 431                 {
 432                 /* In the output function only half of 'md' remains secret,
 433                  * so we better make sure that the required entropy gets
 434                  * 'evenly distributed' through 'state', our randomness pool.
 435                  * The input function (ssleay_rand_add) chains all of 'md',
 436                  * which makes it more suitable for this purpose.
 437                  */
 438
 439                 int n = STATE_SIZE; /* so that the complete pool gets accessed */
 440                 while (n > 0)
 441                         {
 442 #if MD_DIGEST_LENGTH > 20
 443 # error "Please adjust DUMMY_SEED."
 444 #endif
 445 #define DUMMY_SEED "...................." /* at least MD_DIGEST_LENGTH */
 446                         /* Note that the seed does not matter, it's just that
 447                          * ssleay_rand_add expects to have something to hash. */
 448                         ssleay_rand_add(DUMMY_SEED, MD_DIGEST_LENGTH, 0.0);
 449                         n -= MD_DIGEST_LENGTH;
 450                         }
 451                 if (ok)
 452                         stirred_pool = 1;
 453                 }
 454
 455         st_idx=state_index;
 456         st_num=state_num;
 457         md_c[0] = md_count[0];
 458         md_c[1] = md_count[1];
 459         memcpy(local_md, md, sizeof md);
 460
 461         state_index+=num_ceil;
 462         if (state_index > state_num)
 463                 state_index %= state_num;
 464
 465         /* state[st_idx], ..., state[(st_idx + num_ceil - 1) % st_num]
 466          * are now ours (but other threads may use them too) */
 467
 468         md_count[0] += 1;
 469
 470         /* before unlocking, we must clear 'crypto_lock_rand' */
 471         crypto_lock_rand = 0;
 472         CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 473
 474         while (num > 0)
 475                 {
 476                 /* num_ceil -= MD_DIGEST_LENGTH/2 */
 477                 j=(num >= MD_DIGEST_LENGTH/2)?MD_DIGEST_LENGTH/2:num;
 478                 num-=j;
 479                 if (!MD_Init(&m))
 480                         goto err;
 481 #ifndef GETPID_IS_MEANINGLESS
 482                 if (curr_pid) /* just in the first iteration to save time */
 483                         {
 484                         if (!MD_Update(&m,(unsigned char*)&curr_pid,sizeof curr_pid))
 485                                 goto err;
 486                         curr_pid = 0;
 487                         }
 488 #endif
 489                 if (!MD_Update(&m,local_md,MD_DIGEST_LENGTH))
 490                         goto err;
 491                 if (!MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c)))
 492                         goto err;
 493
 494 #ifndef PURIFY /* purify complains */
 495                 /* The following line uses the supplied buffer as a small
 496                  * source of entropy: since this buffer is often uninitialised
 497                  * it may cause programs such as purify or valgrind to
 498                  * complain. So for those builds it is not used: the removal
 499                  * of such a small source of entropy has negligible impact on
 500                  * security.
 501                  */
 502                 if (!MD_Update(&m,buf,j))
 503                         goto err;
 504 #endif
 505
 506                 k=(st_idx+MD_DIGEST_LENGTH/2)-st_num;
 507                 if (k > 0)
 508                         {
 509                         if (!MD_Update(&m,&(state[st_idx]),MD_DIGEST_LENGTH/2-k))
 510                                 goto err;
 511                         if (!MD_Update(&m,&(state[0]),k))
 512                                 goto err;
 513                         }
 514                 else
 515                         if (!MD_Update(&m,&(state[st_idx]),MD_DIGEST_LENGTH/2))
 516                                 goto err;
 517                 if (!MD_Final(&m,local_md))
 518                         goto err;
 519
 520                 for (i=0; i<MD_DIGEST_LENGTH/2; i++)
 521                         {
 522                         state[st_idx++]^=local_md[i]; /* may compete with other threads */
 523                         if (st_idx >= st_num)
 524                                 st_idx=0;
 525                         if (i < j)
 526                                 *(buf++)=local_md[i+MD_DIGEST_LENGTH/2];
 527                         }
 528                 }
 529
 530         if (!MD_Init(&m)
 531                 || !MD_Update(&m,(unsigned char *)&(md_c[0]),sizeof(md_c))
 532                 || !MD_Update(&m,local_md,MD_DIGEST_LENGTH))
 533                 goto err;
 534         CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 535         if (!MD_Update(&m,md,MD_DIGEST_LENGTH) || !MD_Final(&m,md))
 536                 {
 537                 CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 538                 goto err;
 539                 }
 540         CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 541
 542         EVP_MD_CTX_cleanup(&m);
 543         if (ok)
 544                 return(1);
 545         else
 546                 {
 547                 RANDerr(RAND_F_SSLEAY_RAND_BYTES,RAND_R_PRNG_NOT_SEEDED);
 548                 ERR_add_error_data(1, "You need to read the OpenSSL FAQ, "
 549                         "http://www.openssl.org/support/faq.html");
 550                 return(0);
 551                 }
 552         err:
 553         EVP_MD_CTX_cleanup(&m);
 554         RANDerr(RAND_F_SSLEAY_RAND_BYTES,ERR_R_EVP_LIB);
 555         return 0;
 556
 557         }
 558
 559 /* pseudo-random bytes that are guaranteed to be unique but not
 560    unpredictable */
 561 static int ssleay_rand_pseudo_bytes(unsigned char *buf, int num)
 562         {
 563         int ret;
 564         unsigned long err;
 565
 566         ret = RAND_bytes(buf, num);
 567         if (ret == 0)
 568                 {
 569                 err = ERR_peek_error();
 570                 if (ERR_GET_LIB(err) == ERR_LIB_RAND &&
 571                     ERR_GET_REASON(err) == RAND_R_PRNG_NOT_SEEDED)
 572                         ERR_clear_error();
 573                 }
 574         return (ret);
 575         }
 576
 577 static int ssleay_rand_status(void)
 578         {
 579         CRYPTO_THREADID cur;
 580         int ret;
 581         int do_not_lock;
 582
 583         CRYPTO_THREADID_current(&cur);
 584         /* check if we already have the lock
 585          * (could happen if a RAND_poll() implementation calls RAND_status()) */
 586         if (crypto_lock_rand)
 587                 {
 588                 CRYPTO_r_lock(CRYPTO_LOCK_RAND2);
 589                 do_not_lock = !CRYPTO_THREADID_cmp(&locking_threadid, &cur);
 590                 CRYPTO_r_unlock(CRYPTO_LOCK_RAND2);
 591                 }
 592         else
 593                 do_not_lock = 0;
 594
 595         if (!do_not_lock)
 596                 {
 597                 CRYPTO_w_lock(CRYPTO_LOCK_RAND);
 598
 599                 /* prevent ssleay_rand_bytes() from trying to obtain the lock again */
 600                 CRYPTO_w_lock(CRYPTO_LOCK_RAND2);
 601                 CRYPTO_THREADID_cpy(&locking_threadid, &cur);
 602                 CRYPTO_w_unlock(CRYPTO_LOCK_RAND2);
 603                 crypto_lock_rand = 1;
 604                 }
 605
 606         if (!initialized)
 607                 {
 608                 RAND_poll();
 609                 initialized = 1;
 610                 }
 611
 612         ret = entropy >= ENTROPY_NEEDED;
 613
 614         if (!do_not_lock)
 615                 {
 616                 /* before unlocking, we must clear 'crypto_lock_rand' */
 617                 crypto_lock_rand = 0;
 618
 619                 CRYPTO_w_unlock(CRYPTO_LOCK_RAND);
 620                 }
 621
 622         return ret;
 623         }