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