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