crypto/rand/md_rand.c

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