05aa45cd640a153f16e43f5796794e43dc39228e
[openssl.git] / crypto / rand / rand_lib.c
1 /*
2  * Copyright 1995-2016 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
19 #ifndef OPENSSL_NO_ENGINE
20 /* non-NULL if default_RAND_meth is ENGINE-provided */
21 static ENGINE *funct_ref;
22 static CRYPTO_RWLOCK *rand_engine_lock;
23 #endif
24 static CRYPTO_RWLOCK *rand_meth_lock;
25 static const RAND_METHOD *default_RAND_meth;
26 static CRYPTO_ONCE rand_init = CRYPTO_ONCE_STATIC_INIT;
27
28 #ifdef OPENSSL_RAND_SEED_RDTSC
29 /*
30  * IMPORTANT NOTE:  It is not currently possible to use this code
31  * because we are not sure about the amount of randomness.  Some
32  * SP900 tests have been run, but there is internal skepticism.
33  * So for now this code is not used.
34  */
35 # error "RDTSC enabled?  Should not be possible!"
36
37 /*
38  * Since we get some randomness from the low-order bits of the
39  * high-speec clock, it can help.  But don't return a status since
40  * it's not sufficient to indicate whether or not the seeding was
41  * done.
42  */
43 void rand_rdtsc(void)
44 {
45     unsigned char c;
46     int i;
47
48     for (i = 0; i < 10; i++) {
49         c = (unsigned char)(OPENSSL_rdtsc() & 0xFF);
50         RAND_add(&c, 1, 0.5);
51     }
52 }
53 #endif
54
55 #ifdef OPENSSL_RAND_SEED_RDCPU
56 size_t OPENSSL_ia32_rdseed(void);
57 size_t OPENSSL_ia32_rdrand(void);
58
59 extern unsigned int OPENSSL_ia32cap_P[];
60
61 int rand_rdcpu(void)
62 {
63     size_t i, s;
64
65     /* If RDSEED is available, use that. */
66     if ((OPENSSL_ia32cap_P[1] & (1 << 18)) != 0) {
67         for (i = 0; i < RANDOMNESS_NEEDED; i += sizeof(s)) {
68             s = OPENSSL_ia32_rdseed();
69             if (s == 0)
70                 break;
71             RAND_add(&s, (int)sizeof(s), sizeof(s));
72         }
73         if (i >= RANDOMNESS_NEEDED)
74             return 1;
75     }
76
77     /* Second choice is RDRAND. */
78     if ((OPENSSL_ia32cap_P[1] & (1 << (62 - 32))) != 0) {
79         for (i = 0; i < RANDOMNESS_NEEDED; i += sizeof(s)) {
80             s = OPENSSL_ia32_rdrand();
81             if (s == 0)
82                 break;
83             RAND_add(&s, (int)sizeof(s), sizeof(s));
84         }
85         if (i >= RANDOMNESS_NEEDED)
86             return 1;
87     }
88
89     return 0;
90 }
91 #endif
92
93 DEFINE_RUN_ONCE_STATIC(do_rand_init)
94 {
95     int ret = 1;
96 #ifndef OPENSSL_NO_ENGINE
97     rand_engine_lock = CRYPTO_THREAD_lock_new();
98     ret &= rand_engine_lock != NULL;
99 #endif
100     rand_meth_lock = CRYPTO_THREAD_lock_new();
101     ret &= rand_meth_lock != NULL;
102     return ret;
103 }
104
105 void rand_cleanup_int(void)
106 {
107     const RAND_METHOD *meth = default_RAND_meth;
108
109     if (meth != NULL && meth->cleanup != NULL)
110         meth->cleanup();
111     RAND_set_rand_method(NULL);
112 #ifndef OPENSSL_NO_ENGINE
113     CRYPTO_THREAD_lock_free(rand_engine_lock);
114 #endif
115     CRYPTO_THREAD_lock_free(rand_meth_lock);
116     rand_drbg_cleanup();
117 }
118
119 int RAND_set_rand_method(const RAND_METHOD *meth)
120 {
121     if (!RUN_ONCE(&rand_init, do_rand_init))
122         return 0;
123
124     CRYPTO_THREAD_write_lock(rand_meth_lock);
125 #ifndef OPENSSL_NO_ENGINE
126     ENGINE_finish(funct_ref);
127     funct_ref = NULL;
128 #endif
129     default_RAND_meth = meth;
130     CRYPTO_THREAD_unlock(rand_meth_lock);
131     return 1;
132 }
133
134 const RAND_METHOD *RAND_get_rand_method(void)
135 {
136     const RAND_METHOD *tmp_meth = NULL;
137
138     if (!RUN_ONCE(&rand_init, do_rand_init))
139         return NULL;
140
141     CRYPTO_THREAD_write_lock(rand_meth_lock);
142     if (default_RAND_meth == NULL) {
143 #ifndef OPENSSL_NO_ENGINE
144         ENGINE *e;
145
146         /* If we have an engine that can do RAND, use it. */
147         if ((e = ENGINE_get_default_RAND()) != NULL
148                 && (tmp_meth = ENGINE_get_RAND(e)) != NULL) {
149             funct_ref = e;
150             default_RAND_meth = tmp_meth;
151         } else {
152             ENGINE_finish(e);
153             default_RAND_meth = &openssl_rand_meth;
154         }
155 #else
156         default_RAND_meth = &openssl_rand_meth;
157 #endif
158     }
159     tmp_meth = default_RAND_meth;
160     CRYPTO_THREAD_unlock(rand_meth_lock);
161     return tmp_meth;
162 }
163
164 #ifndef OPENSSL_NO_ENGINE
165 int RAND_set_rand_engine(ENGINE *engine)
166 {
167     const RAND_METHOD *tmp_meth = NULL;
168
169     if (!RUN_ONCE(&rand_init, do_rand_init))
170         return 0;
171
172     if (engine != NULL) {
173         if (!ENGINE_init(engine))
174             return 0;
175         tmp_meth = ENGINE_get_RAND(engine);
176         if (tmp_meth == NULL) {
177             ENGINE_finish(engine);
178             return 0;
179         }
180     }
181     CRYPTO_THREAD_write_lock(rand_engine_lock);
182     /* This function releases any prior ENGINE so call it first */
183     RAND_set_rand_method(tmp_meth);
184     funct_ref = engine;
185     CRYPTO_THREAD_unlock(rand_engine_lock);
186     return 1;
187 }
188 #endif
189
190 void RAND_seed(const void *buf, int num)
191 {
192     const RAND_METHOD *meth = RAND_get_rand_method();
193
194     if (meth->seed != NULL)
195         meth->seed(buf, num);
196 }
197
198 void RAND_add(const void *buf, int num, double randomness)
199 {
200     const RAND_METHOD *meth = RAND_get_rand_method();
201
202     if (meth->add != NULL)
203         meth->add(buf, num, randomness);
204 }
205
206 int RAND_bytes(unsigned char *buf, int num)
207 {
208     const RAND_METHOD *meth = RAND_get_rand_method();
209
210     if (meth->bytes != NULL)
211         return meth->bytes(buf, num);
212     RANDerr(RAND_F_RAND_BYTES, RAND_R_FUNC_NOT_IMPLEMENTED);
213     return -1;
214 }
215
216 #if OPENSSL_API_COMPAT < 0x10100000L
217 int RAND_pseudo_bytes(unsigned char *buf, int num)
218 {
219     const RAND_METHOD *meth = RAND_get_rand_method();
220
221     if (meth->pseudorand != NULL)
222         return meth->pseudorand(buf, num);
223     return -1;
224 }
225 #endif
226
227 int RAND_status(void)
228 {
229     const RAND_METHOD *meth = RAND_get_rand_method();
230
231     if (meth->status != NULL)
232         return meth->status();
233     return 0;
234 }