884917a36e28ded885d16baacc7a55f01e35ad50
[openssl.git] / crypto / rand / rand_lib.c
1 /*
2  * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include <time.h>
12 #include "internal/cryptlib.h"
13 #include <openssl/opensslconf.h>
14 #include "internal/rand_int.h"
15 #include <openssl/engine.h>
16 #include "internal/thread_once.h"
17 #include "rand_lcl.h"
18 #include "e_os.h"
19
20 #ifndef OPENSSL_NO_ENGINE
21 /* non-NULL if default_RAND_meth is ENGINE-provided */
22 static ENGINE *funct_ref;
23 static CRYPTO_RWLOCK *rand_engine_lock;
24 #endif
25 static CRYPTO_RWLOCK *rand_meth_lock;
26 static const RAND_METHOD *default_RAND_meth;
27 static CRYPTO_ONCE rand_init = CRYPTO_ONCE_STATIC_INIT;
28
29 int rand_fork_count;
30
31 static CRYPTO_RWLOCK *rand_nonce_lock;
32 static int rand_nonce_count;
33
34 static int rand_cleaning_up = 0;
35
36 #ifdef OPENSSL_RAND_SEED_RDTSC
37 /*
38  * IMPORTANT NOTE:  It is not currently possible to use this code
39  * because we are not sure about the amount of randomness it provides.
40  * Some SP900 tests have been run, but there is internal skepticism.
41  * So for now this code is not used.
42  */
43 # error "RDTSC enabled?  Should not be possible!"
44
45 /*
46  * Acquire entropy from high-speed clock
47  *
48  * Since we get some randomness from the low-order bits of the
49  * high-speed clock, it can help.
50  *
51  * Returns the total entropy count, if it exceeds the requested
52  * entropy count. Otherwise, returns an entropy count of 0.
53  */
54 size_t rand_acquire_entropy_from_tsc(RAND_POOL *pool)
55 {
56     unsigned char c;
57     int i;
58
59     if ((OPENSSL_ia32cap_P[0] & (1 << 4)) != 0) {
60         for (i = 0; i < TSC_READ_COUNT; i++) {
61             c = (unsigned char)(OPENSSL_rdtsc() & 0xFF);
62             rand_pool_add(pool, &c, 1, 4);
63         }
64     }
65     return rand_pool_entropy_available(pool);
66 }
67 #endif
68
69 #ifdef OPENSSL_RAND_SEED_RDCPU
70 size_t OPENSSL_ia32_rdseed_bytes(unsigned char *buf, size_t len);
71 size_t OPENSSL_ia32_rdrand_bytes(unsigned char *buf, size_t len);
72
73 extern unsigned int OPENSSL_ia32cap_P[];
74
75 /*
76  * Acquire entropy using Intel-specific cpu instructions
77  *
78  * Uses the RDSEED instruction if available, otherwise uses
79  * RDRAND if available.
80  *
81  * For the differences between RDSEED and RDRAND, and why RDSEED
82  * is the preferred choice, see https://goo.gl/oK3KcN
83  *
84  * Returns the total entropy count, if it exceeds the requested
85  * entropy count. Otherwise, returns an entropy count of 0.
86  */
87 size_t rand_acquire_entropy_from_cpu(RAND_POOL *pool)
88 {
89     size_t bytes_needed;
90     unsigned char *buffer;
91
92     bytes_needed = rand_pool_bytes_needed(pool, 1 /*entropy_factor*/);
93     if (bytes_needed > 0) {
94         buffer = rand_pool_add_begin(pool, bytes_needed);
95
96         if (buffer != NULL) {
97             /* Whichever comes first, use RDSEED, RDRAND or nothing */
98             if ((OPENSSL_ia32cap_P[2] & (1 << 18)) != 0) {
99                 if (OPENSSL_ia32_rdseed_bytes(buffer, bytes_needed)
100                     == bytes_needed) {
101                     rand_pool_add_end(pool, bytes_needed, 8 * bytes_needed);
102                 }
103             } else if ((OPENSSL_ia32cap_P[1] & (1 << (62 - 32))) != 0) {
104                 if (OPENSSL_ia32_rdrand_bytes(buffer, bytes_needed)
105                     == bytes_needed) {
106                     rand_pool_add_end(pool, bytes_needed, 8 * bytes_needed);
107                 }
108             } else {
109                 rand_pool_add_end(pool, 0, 0);
110             }
111         }
112     }
113
114     return rand_pool_entropy_available(pool);
115 }
116 #endif
117
118
119 /*
120  * Implements the get_entropy() callback (see RAND_DRBG_set_callbacks())
121  *
122  * If the DRBG has a parent, then the required amount of entropy input
123  * is fetched using the parent's RAND_DRBG_generate().
124  *
125  * Otherwise, the entropy is polled from the system entropy sources
126  * using rand_pool_acquire_entropy().
127  *
128  * If a random pool has been added to the DRBG using RAND_add(), then
129  * its entropy will be used up first.
130  */
131 size_t rand_drbg_get_entropy(RAND_DRBG *drbg,
132                              unsigned char **pout,
133                              int entropy, size_t min_len, size_t max_len,
134                              int prediction_resistance)
135 {
136     size_t ret = 0;
137     size_t entropy_available = 0;
138     RAND_POOL *pool;
139
140     if (drbg->parent && drbg->strength > drbg->parent->strength) {
141         /*
142          * We currently don't support the algorithm from NIST SP 800-90C
143          * 10.1.2 to use a weaker DRBG as source
144          */
145         RANDerr(RAND_F_RAND_DRBG_GET_ENTROPY, RAND_R_PARENT_STRENGTH_TOO_WEAK);
146         return 0;
147     }
148
149     if (drbg->pool != NULL) {
150         pool = drbg->pool;
151         pool->entropy_requested = entropy;
152     } else {
153         pool = rand_pool_new(entropy, min_len, max_len);
154         if (pool == NULL)
155             return 0;
156     }
157
158     if (drbg->parent) {
159         size_t bytes_needed = rand_pool_bytes_needed(pool, 1 /*entropy_factor*/);
160         unsigned char *buffer = rand_pool_add_begin(pool, bytes_needed);
161
162         if (buffer != NULL) {
163             size_t bytes = 0;
164
165             /*
166              * Get random from parent, include our state as additional input.
167              * Our lock is already held, but we need to lock our parent before
168              * generating bits from it. (Note: taking the lock will be a no-op
169              * if locking if drbg->parent->lock == NULL.)
170              */
171             rand_drbg_lock(drbg->parent);
172             if (RAND_DRBG_generate(drbg->parent,
173                                    buffer, bytes_needed,
174                                    prediction_resistance,
175                                    NULL, 0) != 0)
176                 bytes = bytes_needed;
177             drbg->reseed_next_counter
178                 = tsan_load(&drbg->parent->reseed_prop_counter);
179             rand_drbg_unlock(drbg->parent);
180
181             rand_pool_add_end(pool, bytes, 8 * bytes);
182             entropy_available = rand_pool_entropy_available(pool);
183         }
184
185     } else {
186         if (prediction_resistance) {
187             /*
188              * We don't have any entropy sources that comply with the NIST
189              * standard to provide prediction resistance (see NIST SP 800-90C,
190              * Section 5.4).
191              */
192             RANDerr(RAND_F_RAND_DRBG_GET_ENTROPY,
193                     RAND_R_PREDICTION_RESISTANCE_NOT_SUPPORTED);
194             goto err;
195         }
196
197         /* Get entropy by polling system entropy sources. */
198         entropy_available = rand_pool_acquire_entropy(pool);
199     }
200
201     if (entropy_available > 0) {
202         ret   = rand_pool_length(pool);
203         *pout = rand_pool_detach(pool);
204     }
205
206  err:
207     if (drbg->pool == NULL)
208         rand_pool_free(pool);
209     return ret;
210 }
211
212 /*
213  * Implements the cleanup_entropy() callback (see RAND_DRBG_set_callbacks())
214  *
215  */
216 void rand_drbg_cleanup_entropy(RAND_DRBG *drbg,
217                                unsigned char *out, size_t outlen)
218 {
219     if (drbg->pool == NULL)
220         OPENSSL_secure_clear_free(out, outlen);
221 }
222
223
224 /*
225  * Implements the get_nonce() callback (see RAND_DRBG_set_callbacks())
226  *
227  */
228 size_t rand_drbg_get_nonce(RAND_DRBG *drbg,
229                            unsigned char **pout,
230                            int entropy, size_t min_len, size_t max_len)
231 {
232     size_t ret = 0;
233     RAND_POOL *pool;
234
235     struct {
236         void * instance;
237         int count;
238     } data = { 0 };
239
240     pool = rand_pool_new(0, min_len, max_len);
241     if (pool == NULL)
242         return 0;
243
244     if (rand_pool_add_nonce_data(pool) == 0)
245         goto err;
246
247     data.instance = drbg;
248     CRYPTO_atomic_add(&rand_nonce_count, 1, &data.count, rand_nonce_lock);
249
250     if (rand_pool_add(pool, (unsigned char *)&data, sizeof(data), 0) == 0)
251         goto err;
252
253     ret   = rand_pool_length(pool);
254     *pout = rand_pool_detach(pool);
255
256  err:
257     rand_pool_free(pool);
258
259     return ret;
260 }
261
262 /*
263  * Implements the cleanup_nonce() callback (see RAND_DRBG_set_callbacks())
264  *
265  */
266 void rand_drbg_cleanup_nonce(RAND_DRBG *drbg,
267                              unsigned char *out, size_t outlen)
268 {
269     OPENSSL_secure_clear_free(out, outlen);
270 }
271
272 /*
273  * Generate additional data that can be used for the drbg. The data does
274  * not need to contain entropy, but it's useful if it contains at least
275  * some bits that are unpredictable.
276  *
277  * Returns 0 on failure.
278  *
279  * On success it allocates a buffer at |*pout| and returns the length of
280  * the data. The buffer should get freed using OPENSSL_secure_clear_free().
281  */
282 size_t rand_drbg_get_additional_data(RAND_POOL *pool, unsigned char **pout)
283 {
284     size_t ret = 0;
285
286     if (rand_pool_add_additional_data(pool) == 0)
287         goto err;
288
289     ret = rand_pool_length(pool);
290     *pout = rand_pool_detach(pool);
291
292  err:
293     return ret;
294 }
295
296 void rand_drbg_cleanup_additional_data(RAND_POOL *pool, unsigned char *out)
297 {
298     rand_pool_reattach(pool, out);
299 }
300
301 void rand_fork(void)
302 {
303     rand_fork_count++;
304 }
305
306 DEFINE_RUN_ONCE_STATIC(do_rand_init)
307 {
308 #ifndef OPENSSL_NO_ENGINE
309     rand_engine_lock = CRYPTO_THREAD_lock_new();
310     if (rand_engine_lock == NULL)
311         return 0;
312 #endif
313
314     rand_meth_lock = CRYPTO_THREAD_lock_new();
315     if (rand_meth_lock == NULL)
316         goto err1;
317
318     rand_nonce_lock = CRYPTO_THREAD_lock_new();
319     if (rand_nonce_lock == NULL)
320         goto err2;
321
322     if (!rand_cleaning_up && !rand_pool_init())
323         goto err3;
324
325     return 1;
326
327 err3:
328     rand_pool_cleanup();
329 err2:
330     CRYPTO_THREAD_lock_free(rand_meth_lock);
331     rand_meth_lock = NULL;
332 err1:
333 #ifndef OPENSSL_NO_ENGINE
334     CRYPTO_THREAD_lock_free(rand_engine_lock);
335     rand_engine_lock = NULL;
336 #endif
337     return 0;
338 }
339
340 void rand_cleanup_int(void)
341 {
342     const RAND_METHOD *meth = default_RAND_meth;
343
344     rand_cleaning_up = 1;
345
346     if (meth != NULL && meth->cleanup != NULL)
347         meth->cleanup();
348     RAND_set_rand_method(NULL);
349     rand_pool_cleanup();
350 #ifndef OPENSSL_NO_ENGINE
351     CRYPTO_THREAD_lock_free(rand_engine_lock);
352     rand_engine_lock = NULL;
353 #endif
354     CRYPTO_THREAD_lock_free(rand_meth_lock);
355     rand_meth_lock = NULL;
356     CRYPTO_THREAD_lock_free(rand_nonce_lock);
357     rand_nonce_lock = NULL;
358 }
359
360 /*
361  * RAND_close_seed_files() ensures that any seed file decriptors are
362  * closed after use.
363  */
364 void RAND_keep_random_devices_open(int keep)
365 {
366     rand_pool_keep_random_devices_open(keep);
367 }
368
369 /*
370  * RAND_poll() reseeds the default RNG using random input
371  *
372  * The random input is obtained from polling various entropy
373  * sources which depend on the operating system and are
374  * configurable via the --with-rand-seed configure option.
375  */
376 int RAND_poll(void)
377 {
378     int ret = 0;
379
380     RAND_POOL *pool = NULL;
381
382     const RAND_METHOD *meth = RAND_get_rand_method();
383
384     if (meth == RAND_OpenSSL()) {
385         /* fill random pool and seed the master DRBG */
386         RAND_DRBG *drbg = RAND_DRBG_get0_master();
387
388         if (drbg == NULL)
389             return 0;
390
391         rand_drbg_lock(drbg);
392         ret = rand_drbg_restart(drbg, NULL, 0, 0);
393         rand_drbg_unlock(drbg);
394
395         return ret;
396
397     } else {
398         /* fill random pool and seed the current legacy RNG */
399         pool = rand_pool_new(RAND_DRBG_STRENGTH,
400                              RAND_DRBG_STRENGTH / 8,
401                              RAND_POOL_MAX_LENGTH);
402         if (pool == NULL)
403             return 0;
404
405         if (rand_pool_acquire_entropy(pool) == 0)
406             goto err;
407
408         if (meth->add == NULL
409             || meth->add(rand_pool_buffer(pool),
410                          rand_pool_length(pool),
411                          (rand_pool_entropy(pool) / 8.0)) == 0)
412             goto err;
413
414         ret = 1;
415     }
416
417 err:
418     rand_pool_free(pool);
419     return ret;
420 }
421
422 /*
423  * Allocate memory and initialize a new random pool
424  */
425
426 RAND_POOL *rand_pool_new(int entropy_requested, size_t min_len, size_t max_len)
427 {
428     RAND_POOL *pool = OPENSSL_zalloc(sizeof(*pool));
429
430     if (pool == NULL) {
431         RANDerr(RAND_F_RAND_POOL_NEW, ERR_R_MALLOC_FAILURE);
432         return NULL;
433     }
434
435     pool->min_len = min_len;
436     pool->max_len = (max_len > RAND_POOL_MAX_LENGTH) ?
437         RAND_POOL_MAX_LENGTH : max_len;
438
439     pool->buffer = OPENSSL_secure_zalloc(pool->max_len);
440     if (pool->buffer == NULL) {
441         RANDerr(RAND_F_RAND_POOL_NEW, ERR_R_MALLOC_FAILURE);
442         goto err;
443     }
444
445     pool->entropy_requested = entropy_requested;
446
447     return pool;
448
449 err:
450     OPENSSL_free(pool);
451     return NULL;
452 }
453
454 /*
455  * Attach new random pool to the given buffer
456  *
457  * This function is intended to be used only for feeding random data
458  * provided by RAND_add() and RAND_seed() into the <master> DRBG.
459  */
460 RAND_POOL *rand_pool_attach(const unsigned char *buffer, size_t len,
461                             size_t entropy)
462 {
463     RAND_POOL *pool = OPENSSL_zalloc(sizeof(*pool));
464
465     if (pool == NULL) {
466         RANDerr(RAND_F_RAND_POOL_ATTACH, ERR_R_MALLOC_FAILURE);
467         return NULL;
468     }
469
470     /*
471      * The const needs to be cast away, but attached buffers will not be
472      * modified (in contrary to allocated buffers which are zeroed and
473      * freed in the end).
474      */
475     pool->buffer = (unsigned char *) buffer;
476     pool->len = len;
477
478     pool->attached = 1;
479
480     pool->min_len = pool->max_len = pool->len;
481     pool->entropy = entropy;
482
483     return pool;
484 }
485
486 /*
487  * Free |pool|, securely erasing its buffer.
488  */
489 void rand_pool_free(RAND_POOL *pool)
490 {
491     if (pool == NULL)
492         return;
493
494     /*
495      * Although it would be advisable from a cryptographical viewpoint,
496      * we are not allowed to clear attached buffers, since they are passed
497      * to rand_pool_attach() as `const unsigned char*`.
498      * (see corresponding comment in rand_pool_attach()).
499      */
500     if (!pool->attached)
501         OPENSSL_secure_clear_free(pool->buffer, pool->max_len);
502     OPENSSL_free(pool);
503 }
504
505 /*
506  * Return the |pool|'s buffer to the caller (readonly).
507  */
508 const unsigned char *rand_pool_buffer(RAND_POOL *pool)
509 {
510     return pool->buffer;
511 }
512
513 /*
514  * Return the |pool|'s entropy to the caller.
515  */
516 size_t rand_pool_entropy(RAND_POOL *pool)
517 {
518     return pool->entropy;
519 }
520
521 /*
522  * Return the |pool|'s buffer length to the caller.
523  */
524 size_t rand_pool_length(RAND_POOL *pool)
525 {
526     return pool->len;
527 }
528
529 /*
530  * Detach the |pool| buffer and return it to the caller.
531  * It's the responsibility of the caller to free the buffer
532  * using OPENSSL_secure_clear_free() or to re-attach it
533  * again to the pool using rand_pool_reattach().
534  */
535 unsigned char *rand_pool_detach(RAND_POOL *pool)
536 {
537     unsigned char *ret = pool->buffer;
538     pool->buffer = NULL;
539     pool->entropy = 0;
540     return ret;
541 }
542
543 /*
544  * Re-attach the |pool| buffer. It is only allowed to pass
545  * the |buffer| which was previously detached from the same pool.
546  */
547 void rand_pool_reattach(RAND_POOL *pool, unsigned char *buffer)
548 {
549     pool->buffer = buffer;
550     OPENSSL_cleanse(pool->buffer, pool->len);
551     pool->len = 0;
552 }
553
554 /*
555  * If |entropy_factor| bits contain 1 bit of entropy, how many bytes does one
556  * need to obtain at least |bits| bits of entropy?
557  */
558 #define ENTROPY_TO_BYTES(bits, entropy_factor) \
559     (((bits) * (entropy_factor) + 7) / 8)
560
561
562 /*
563  * Checks whether the |pool|'s entropy is available to the caller.
564  * This is the case when entropy count and buffer length are high enough.
565  * Returns
566  *
567  *  |entropy|  if the entropy count and buffer size is large enough
568  *      0      otherwise
569  */
570 size_t rand_pool_entropy_available(RAND_POOL *pool)
571 {
572     if (pool->entropy < pool->entropy_requested)
573         return 0;
574
575     if (pool->len < pool->min_len)
576         return 0;
577
578     return pool->entropy;
579 }
580
581 /*
582  * Returns the (remaining) amount of entropy needed to fill
583  * the random pool.
584  */
585
586 size_t rand_pool_entropy_needed(RAND_POOL *pool)
587 {
588     if (pool->entropy < pool->entropy_requested)
589         return pool->entropy_requested - pool->entropy;
590
591     return 0;
592 }
593
594 /*
595  * Returns the number of bytes needed to fill the pool, assuming
596  * the input has 1 / |entropy_factor| entropy bits per data bit.
597  * In case of an error, 0 is returned.
598  */
599
600 size_t rand_pool_bytes_needed(RAND_POOL *pool, unsigned int entropy_factor)
601 {
602     size_t bytes_needed;
603     size_t entropy_needed = rand_pool_entropy_needed(pool);
604
605     if (entropy_factor < 1) {
606         RANDerr(RAND_F_RAND_POOL_BYTES_NEEDED, RAND_R_ARGUMENT_OUT_OF_RANGE);
607         return 0;
608     }
609
610     bytes_needed = ENTROPY_TO_BYTES(entropy_needed, entropy_factor);
611
612     if (bytes_needed > pool->max_len - pool->len) {
613         /* not enough space left */
614         RANDerr(RAND_F_RAND_POOL_BYTES_NEEDED, RAND_R_RANDOM_POOL_OVERFLOW);
615         return 0;
616     }
617
618     if (pool->len < pool->min_len &&
619         bytes_needed < pool->min_len - pool->len)
620         /* to meet the min_len requirement */
621         bytes_needed = pool->min_len - pool->len;
622
623     return bytes_needed;
624 }
625
626 /* Returns the remaining number of bytes available */
627 size_t rand_pool_bytes_remaining(RAND_POOL *pool)
628 {
629     return pool->max_len - pool->len;
630 }
631
632 /*
633  * Add random bytes to the random pool.
634  *
635  * It is expected that the |buffer| contains |len| bytes of
636  * random input which contains at least |entropy| bits of
637  * randomness.
638  *
639  * Returns 1 if the added amount is adequate, otherwise 0
640  */
641 int rand_pool_add(RAND_POOL *pool,
642                   const unsigned char *buffer, size_t len, size_t entropy)
643 {
644     if (len > pool->max_len - pool->len) {
645         RANDerr(RAND_F_RAND_POOL_ADD, RAND_R_ENTROPY_INPUT_TOO_LONG);
646         return 0;
647     }
648
649     if (pool->buffer == NULL) {
650         RANDerr(RAND_F_RAND_POOL_ADD, ERR_R_INTERNAL_ERROR);
651         return 0;
652     }
653
654     if (len > 0) {
655         memcpy(pool->buffer + pool->len, buffer, len);
656         pool->len += len;
657         pool->entropy += entropy;
658     }
659
660     return 1;
661 }
662
663 /*
664  * Start to add random bytes to the random pool in-place.
665  *
666  * Reserves the next |len| bytes for adding random bytes in-place
667  * and returns a pointer to the buffer.
668  * The caller is allowed to copy up to |len| bytes into the buffer.
669  * If |len| == 0 this is considered a no-op and a NULL pointer
670  * is returned without producing an error message.
671  *
672  * After updating the buffer, rand_pool_add_end() needs to be called
673  * to finish the udpate operation (see next comment).
674  */
675 unsigned char *rand_pool_add_begin(RAND_POOL *pool, size_t len)
676 {
677     if (len == 0)
678         return NULL;
679
680     if (len > pool->max_len - pool->len) {
681         RANDerr(RAND_F_RAND_POOL_ADD_BEGIN, RAND_R_RANDOM_POOL_OVERFLOW);
682         return NULL;
683     }
684
685     if (pool->buffer == NULL) {
686         RANDerr(RAND_F_RAND_POOL_ADD_BEGIN, ERR_R_INTERNAL_ERROR);
687         return 0;
688     }
689
690     return pool->buffer + pool->len;
691 }
692
693 /*
694  * Finish to add random bytes to the random pool in-place.
695  *
696  * Finishes an in-place update of the random pool started by
697  * rand_pool_add_begin() (see previous comment).
698  * It is expected that |len| bytes of random input have been added
699  * to the buffer which contain at least |entropy| bits of randomness.
700  * It is allowed to add less bytes than originally reserved.
701  */
702 int rand_pool_add_end(RAND_POOL *pool, size_t len, size_t entropy)
703 {
704     if (len > pool->max_len - pool->len) {
705         RANDerr(RAND_F_RAND_POOL_ADD_END, RAND_R_RANDOM_POOL_OVERFLOW);
706         return 0;
707     }
708
709     if (len > 0) {
710         pool->len += len;
711         pool->entropy += entropy;
712     }
713
714     return 1;
715 }
716
717 int RAND_set_rand_method(const RAND_METHOD *meth)
718 {
719     if (!RUN_ONCE(&rand_init, do_rand_init))
720         return 0;
721
722     CRYPTO_THREAD_write_lock(rand_meth_lock);
723 #ifndef OPENSSL_NO_ENGINE
724     ENGINE_finish(funct_ref);
725     funct_ref = NULL;
726 #endif
727     default_RAND_meth = meth;
728     CRYPTO_THREAD_unlock(rand_meth_lock);
729     return 1;
730 }
731
732 const RAND_METHOD *RAND_get_rand_method(void)
733 {
734     const RAND_METHOD *tmp_meth = NULL;
735
736     if (!RUN_ONCE(&rand_init, do_rand_init))
737         return NULL;
738
739     CRYPTO_THREAD_write_lock(rand_meth_lock);
740     if (default_RAND_meth == NULL) {
741 #ifndef OPENSSL_NO_ENGINE
742         ENGINE *e;
743
744         /* If we have an engine that can do RAND, use it. */
745         if ((e = ENGINE_get_default_RAND()) != NULL
746                 && (tmp_meth = ENGINE_get_RAND(e)) != NULL) {
747             funct_ref = e;
748             default_RAND_meth = tmp_meth;
749         } else {
750             ENGINE_finish(e);
751             default_RAND_meth = &rand_meth;
752         }
753 #else
754         default_RAND_meth = &rand_meth;
755 #endif
756     }
757     tmp_meth = default_RAND_meth;
758     CRYPTO_THREAD_unlock(rand_meth_lock);
759     return tmp_meth;
760 }
761
762 #ifndef OPENSSL_NO_ENGINE
763 int RAND_set_rand_engine(ENGINE *engine)
764 {
765     const RAND_METHOD *tmp_meth = NULL;
766
767     if (!RUN_ONCE(&rand_init, do_rand_init))
768         return 0;
769
770     if (engine != NULL) {
771         if (!ENGINE_init(engine))
772             return 0;
773         tmp_meth = ENGINE_get_RAND(engine);
774         if (tmp_meth == NULL) {
775             ENGINE_finish(engine);
776             return 0;
777         }
778     }
779     CRYPTO_THREAD_write_lock(rand_engine_lock);
780     /* This function releases any prior ENGINE so call it first */
781     RAND_set_rand_method(tmp_meth);
782     funct_ref = engine;
783     CRYPTO_THREAD_unlock(rand_engine_lock);
784     return 1;
785 }
786 #endif
787
788 void RAND_seed(const void *buf, int num)
789 {
790     const RAND_METHOD *meth = RAND_get_rand_method();
791
792     if (meth->seed != NULL)
793         meth->seed(buf, num);
794 }
795
796 void RAND_add(const void *buf, int num, double randomness)
797 {
798     const RAND_METHOD *meth = RAND_get_rand_method();
799
800     if (meth->add != NULL)
801         meth->add(buf, num, randomness);
802 }
803
804 /*
805  * This function is not part of RAND_METHOD, so if we're not using
806  * the default method, then just call RAND_bytes().  Otherwise make
807  * sure we're instantiated and use the private DRBG.
808  */
809 int RAND_priv_bytes(unsigned char *buf, int num)
810 {
811     const RAND_METHOD *meth = RAND_get_rand_method();
812     RAND_DRBG *drbg;
813     int ret;
814
815     if (meth != RAND_OpenSSL())
816         return RAND_bytes(buf, num);
817
818     drbg = RAND_DRBG_get0_private();
819     if (drbg == NULL)
820         return 0;
821
822     ret = RAND_DRBG_bytes(drbg, buf, num);
823     return ret;
824 }
825
826 int RAND_bytes(unsigned char *buf, int num)
827 {
828     const RAND_METHOD *meth = RAND_get_rand_method();
829
830     if (meth->bytes != NULL)
831         return meth->bytes(buf, num);
832     RANDerr(RAND_F_RAND_BYTES, RAND_R_FUNC_NOT_IMPLEMENTED);
833     return -1;
834 }
835
836 #if OPENSSL_API_COMPAT < 0x10100000L
837 int RAND_pseudo_bytes(unsigned char *buf, int num)
838 {
839     const RAND_METHOD *meth = RAND_get_rand_method();
840
841     if (meth->pseudorand != NULL)
842         return meth->pseudorand(buf, num);
843     return -1;
844 }
845 #endif
846
847 int RAND_status(void)
848 {
849     const RAND_METHOD *meth = RAND_get_rand_method();
850
851     if (meth->status != NULL)
852         return meth->status();
853     return 0;
854 }