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