rand_lib.c 11.3 KB
Newer Older
R
Rich Salz 已提交
1
/*
R
Rich Salz 已提交
2
 * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
3
 *
R
Rich Salz 已提交
4 5 6 7
 * Licensed under the OpenSSL license (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
8 9 10 11
 */

#include <stdio.h>
#include <time.h>
12
#include "internal/cryptlib.h"
13
#include <openssl/opensslconf.h>
R
Rich Salz 已提交
14
#include "internal/rand_int.h"
R
Rich Salz 已提交
15
#include <openssl/engine.h>
16
#include "internal/thread_once.h"
R
Rich Salz 已提交
17
#include "rand_lcl.h"
18

19
#ifndef OPENSSL_NO_ENGINE
20
/* non-NULL if default_RAND_meth is ENGINE-provided */
R
Rich Salz 已提交
21 22
static ENGINE *funct_ref;
static CRYPTO_RWLOCK *rand_engine_lock;
23
#endif
R
Rich Salz 已提交
24 25 26
static CRYPTO_RWLOCK *rand_meth_lock;
static const RAND_METHOD *default_RAND_meth;
static CRYPTO_ONCE rand_init = CRYPTO_ONCE_STATIC_INIT;
R
Rich Salz 已提交
27
RAND_BYTES_BUFFER rand_bytes;
R
Rich Salz 已提交
28
int rand_fork_count;
29

R
Rich Salz 已提交
30 31 32
#ifdef OPENSSL_RAND_SEED_RDTSC
/*
 * IMPORTANT NOTE:  It is not currently possible to use this code
R
Rich Salz 已提交
33 34
 * because we are not sure about the amount of randomness it provides.
 * Some SP900 tests have been run, but there is internal skepticism.
R
Rich Salz 已提交
35 36 37 38 39 40 41 42 43 44
 * So for now this code is not used.
 */
# error "RDTSC enabled?  Should not be possible!"

/*
 * Since we get some randomness from the low-order bits of the
 * high-speec clock, it can help.  But don't return a status since
 * it's not sufficient to indicate whether or not the seeding was
 * done.
 */
45
void rand_read_tsc(RAND_poll_cb rand_add, void *arg)
R
Rich Salz 已提交
46 47 48 49
{
    unsigned char c;
    int i;

R
Rich Salz 已提交
50 51 52
    if ((OPENSSL_ia32cap_P[0] & (1 << 4)) != 0) {
        for (i = 0; i < TSC_READ_COUNT; i++) {
            c = (unsigned char)(OPENSSL_rdtsc() & 0xFF);
53
            rand_add(arg, &c, 1, 0.5);
R
Rich Salz 已提交
54
        }
R
Rich Salz 已提交
55 56 57 58 59
    }
}
#endif

#ifdef OPENSSL_RAND_SEED_RDCPU
R
Rich Salz 已提交
60 61
size_t OPENSSL_ia32_rdseed_bytes(char *buf, size_t len);
size_t OPENSSL_ia32_rdrand_bytes(char *buf, size_t len);
R
Rich Salz 已提交
62 63 64

extern unsigned int OPENSSL_ia32cap_P[];

65
int rand_read_cpu(RAND_poll_cb rand_add, void *arg)
R
Rich Salz 已提交
66
{
R
Rich Salz 已提交
67
    char buff[RANDOMNESS_NEEDED];
R
Rich Salz 已提交
68 69

    /* If RDSEED is available, use that. */
R
Rich Salz 已提交
70 71
    if ((OPENSSL_ia32cap_P[2] & (1 << 18)) != 0) {
        if (OPENSSL_ia32_rdseed_bytes(buff, sizeof(buff)) == sizeof(buff)) {
72
            rand_add(arg, buff, (int)sizeof(buff), sizeof(buff));
R
Rich Salz 已提交
73
            return 1;
R
Rich Salz 已提交
74
        }
R
Rich Salz 已提交
75 76 77 78
    }

    /* Second choice is RDRAND. */
    if ((OPENSSL_ia32cap_P[1] & (1 << (62 - 32))) != 0) {
R
Rich Salz 已提交
79
        if (OPENSSL_ia32_rdrand_bytes(buff, sizeof(buff)) == sizeof(buff)) {
80
            rand_add(arg, buff, (int)sizeof(buff), sizeof(buff));
R
Rich Salz 已提交
81
            return 1;
R
Rich Salz 已提交
82
        }
R
Rich Salz 已提交
83 84 85 86 87
    }

    return 0;
}
#endif
R
Rich Salz 已提交
88

R
Rich Salz 已提交
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114

/*
 * DRBG has two sets of callbacks; we only discuss the "entropy" one
 * here.  When the DRBG needs additional randomness bits (called entropy
 * in the NIST document), it calls the get_entropy callback which fills in
 * a pointer and returns the number of bytes. When the DRBG is finished with
 * the buffer, it calls the cleanup_entropy callback, with the value of
 * the buffer that the get_entropy callback filled in.
 *
 * Get entropy from the system, via RAND_poll if needed.  The |entropy|
 * is the bits of randomness required, and is expected to fit into a buffer
 * of |min_len|..|max__len| size.  We assume we're getting high-quality
 * randomness from the system, and that |min_len| bytes will do.
 */
size_t drbg_entropy_from_system(RAND_DRBG *drbg,
                                unsigned char **pout,
                                int entropy, size_t min_len, size_t max_len)
{
    int i;


    if (min_len > (size_t)drbg->size) {
        /* Should not happen.  See comment near RANDOMNESS_NEEDED. */
        min_len = drbg->size;
    }

115
    if (drbg->filled) {
R
Rich Salz 已提交
116 117 118 119 120
        /* Re-use what we have. */
        *pout = drbg->randomness;
        return drbg->size;
    }

R
Rich Salz 已提交
121 122 123
    drbg->randomness = drbg->secure ? OPENSSL_secure_malloc(drbg->size)
                                    : OPENSSL_malloc(drbg->size);

R
Rich Salz 已提交
124 125 126 127 128 129 130 131 132 133 134 135 136
    /* If we don't have enough, try to get more. */
    CRYPTO_THREAD_write_lock(rand_bytes.lock);
    for (i = RAND_POLL_RETRIES; rand_bytes.curr < min_len && --i >= 0; ) {
        CRYPTO_THREAD_unlock(rand_bytes.lock);
        RAND_poll();
        CRYPTO_THREAD_write_lock(rand_bytes.lock);
    }

    /* Get desired amount, but no more than we have. */
    if (min_len > rand_bytes.curr)
        min_len = rand_bytes.curr;
    if (min_len != 0) {
        memcpy(drbg->randomness, rand_bytes.buff, min_len);
137
        drbg->filled = 1;
R
Rich Salz 已提交
138 139 140 141 142 143
        /* Update amount left and shift it down. */
        rand_bytes.curr -= min_len;
        if (rand_bytes.curr != 0)
            memmove(rand_bytes.buff, &rand_bytes.buff[min_len], rand_bytes.curr);
    }
    CRYPTO_THREAD_unlock(rand_bytes.lock);
144
    *pout = drbg->randomness;
R
Rich Salz 已提交
145 146 147 148 149 150 151 152 153 154 155 156 157 158
    return min_len;
}

size_t drbg_entropy_from_parent(RAND_DRBG *drbg,
                                unsigned char **pout,
                                int entropy, size_t min_len, size_t max_len)
{
    int st;

    if (min_len > (size_t)drbg->size) {
        /* Should not happen.  See comment near RANDOMNESS_NEEDED. */
        min_len = drbg->size;
    }

R
Rich Salz 已提交
159 160 161
    drbg->randomness = drbg->secure ? OPENSSL_secure_malloc(drbg->size)
                                    : OPENSSL_malloc(drbg->size);

R
Rich Salz 已提交
162 163 164 165 166 167
    /* Get random from parent, include our state as additional input. */
    st = RAND_DRBG_generate(drbg->parent, drbg->randomness, min_len, 0,
                            (unsigned char *)drbg, sizeof(*drbg));
    if (st == 0)
        return 0;
    drbg->filled = 1;
168
    *pout = drbg->randomness;
R
Rich Salz 已提交
169 170 171 172 173 174
    return min_len;
}

void drbg_release_entropy(RAND_DRBG *drbg, unsigned char *out)
{
    drbg->filled = 0;
R
Rich Salz 已提交
175 176 177 178 179
    if (drbg->secure)
        OPENSSL_secure_clear_free(drbg->randomness, drbg->size);
    else
        OPENSSL_clear_free(drbg->randomness, drbg->size);
    drbg->randomness = NULL;
180 181 182 183 184 185 186 187 188 189 190 191 192
}


/*
 * Set up a global DRBG.
 */
static int setup_drbg(RAND_DRBG *drbg)
{
    int ret = 1;

    drbg->lock = CRYPTO_THREAD_lock_new();
    ret &= drbg->lock != NULL;
    drbg->size = RANDOMNESS_NEEDED;
R
Rich Salz 已提交
193
    drbg->secure = CRYPTO_secure_malloc_initialized();
R
Rich Salz 已提交
194
    drbg->randomness = NULL;
195 196 197 198 199 200 201 202 203 204 205 206
    /* If you change these parameters, see RANDOMNESS_NEEDED */
    ret &= RAND_DRBG_set(drbg,
                         NID_aes_128_ctr, RAND_DRBG_FLAG_CTR_USE_DF) == 1;
    ret &= RAND_DRBG_set_callbacks(drbg, drbg_entropy_from_system,
                                   drbg_release_entropy, NULL, NULL) == 1;
    return ret;
}

static void free_drbg(RAND_DRBG *drbg)
{
    CRYPTO_THREAD_lock_free(drbg->lock);
    RAND_DRBG_uninstantiate(drbg);
R
Rich Salz 已提交
207 208
}

R
Rich Salz 已提交
209 210 211 212 213
void rand_fork()
{
    rand_fork_count++;
}

R
Rich Salz 已提交
214
DEFINE_RUN_ONCE_STATIC(do_rand_init)
215
{
216
    int ret = 1;
R
Rich Salz 已提交
217

218 219
#ifndef OPENSSL_NO_ENGINE
    rand_engine_lock = CRYPTO_THREAD_lock_new();
220
    ret &= rand_engine_lock != NULL;
221 222
#endif
    rand_meth_lock = CRYPTO_THREAD_lock_new();
223
    ret &= rand_meth_lock != NULL;
R
Rich Salz 已提交
224 225 226 227 228

    rand_bytes.lock = CRYPTO_THREAD_lock_new();
    ret &= rand_bytes.lock != NULL;
    rand_bytes.curr = 0;
    rand_bytes.size = MAX_RANDOMNESS_HELD;
R
Rich Salz 已提交
229 230 231 232
    rand_bytes.secure = CRYPTO_secure_malloc_initialized();
    rand_bytes.buff = rand_bytes.secure
        ? OPENSSL_secure_malloc(rand_bytes.size)
        : OPENSSL_malloc(rand_bytes.size);
233 234 235
    ret &= rand_bytes.buff != NULL;
    ret &= setup_drbg(&rand_drbg);
    ret &= setup_drbg(&priv_drbg);
236
    return ret;
237
}
238

R
Rich Salz 已提交
239 240 241 242 243 244 245 246 247 248 249
void rand_cleanup_int(void)
{
    const RAND_METHOD *meth = default_RAND_meth;

    if (meth != NULL && meth->cleanup != NULL)
        meth->cleanup();
    RAND_set_rand_method(NULL);
#ifndef OPENSSL_NO_ENGINE
    CRYPTO_THREAD_lock_free(rand_engine_lock);
#endif
    CRYPTO_THREAD_lock_free(rand_meth_lock);
R
Rich Salz 已提交
250
    CRYPTO_THREAD_lock_free(rand_bytes.lock);
R
Rich Salz 已提交
251 252 253 254
    if (rand_bytes.secure)
        OPENSSL_secure_clear_free(rand_bytes.buff, rand_bytes.size);
    else
        OPENSSL_clear_free(rand_bytes.buff, rand_bytes.size);
255 256
    free_drbg(&rand_drbg);
    free_drbg(&priv_drbg);
R
Rich Salz 已提交
257 258 259 260 261 262 263 264 265 266 267 268 269 270
}

/*
 * RAND_poll_ex() gets a function pointer to call when it has random bytes.
 * RAND_poll() sets the function pointer to be a wrapper that calls RAND_add().
 */
static void call_rand_add(void* arg, const void *buf, int num, double r)
{
    RAND_add(buf, num, r);
}

int RAND_poll(void)
{
    return RAND_poll_ex(call_rand_add, NULL);
R
Rich Salz 已提交
271 272
}

273
int RAND_set_rand_method(const RAND_METHOD *meth)
274
{
R
Rich Salz 已提交
275
    if (!RUN_ONCE(&rand_init, do_rand_init))
276 277 278
        return 0;

    CRYPTO_THREAD_write_lock(rand_meth_lock);
279
#ifndef OPENSSL_NO_ENGINE
R
Rich Salz 已提交
280 281
    ENGINE_finish(funct_ref);
    funct_ref = NULL;
282
#endif
283
    default_RAND_meth = meth;
284
    CRYPTO_THREAD_unlock(rand_meth_lock);
285 286
    return 1;
}
287

288
const RAND_METHOD *RAND_get_rand_method(void)
289
{
290 291
    const RAND_METHOD *tmp_meth = NULL;

R
Rich Salz 已提交
292
    if (!RUN_ONCE(&rand_init, do_rand_init))
293 294 295
        return NULL;

    CRYPTO_THREAD_write_lock(rand_meth_lock);
R
Rich Salz 已提交
296
    if (default_RAND_meth == NULL) {
297
#ifndef OPENSSL_NO_ENGINE
R
Rich Salz 已提交
298 299 300 301 302
        ENGINE *e;

        /* If we have an engine that can do RAND, use it. */
        if ((e = ENGINE_get_default_RAND()) != NULL
                && (tmp_meth = ENGINE_get_RAND(e)) != NULL) {
303
            funct_ref = e;
R
Rich Salz 已提交
304 305 306
            default_RAND_meth = tmp_meth;
        } else {
            ENGINE_finish(e);
R
Rich Salz 已提交
307
            default_RAND_meth = &rand_meth;
R
Rich Salz 已提交
308 309
        }
#else
R
Rich Salz 已提交
310
        default_RAND_meth = &rand_meth;
311
#endif
312
    }
313 314 315
    tmp_meth = default_RAND_meth;
    CRYPTO_THREAD_unlock(rand_meth_lock);
    return tmp_meth;
316
}
317

318
#ifndef OPENSSL_NO_ENGINE
319
int RAND_set_rand_engine(ENGINE *engine)
320 321
{
    const RAND_METHOD *tmp_meth = NULL;
322

R
Rich Salz 已提交
323
    if (!RUN_ONCE(&rand_init, do_rand_init))
324 325
        return 0;

R
Rich Salz 已提交
326
    if (engine != NULL) {
327 328 329
        if (!ENGINE_init(engine))
            return 0;
        tmp_meth = ENGINE_get_RAND(engine);
R
Rich Salz 已提交
330
        if (tmp_meth == NULL) {
331 332 333 334
            ENGINE_finish(engine);
            return 0;
        }
    }
335
    CRYPTO_THREAD_write_lock(rand_engine_lock);
336 337 338
    /* This function releases any prior ENGINE so call it first */
    RAND_set_rand_method(tmp_meth);
    funct_ref = engine;
339
    CRYPTO_THREAD_unlock(rand_engine_lock);
340 341
    return 1;
}
342
#endif
343

344
void RAND_seed(const void *buf, int num)
345 346
{
    const RAND_METHOD *meth = RAND_get_rand_method();
R
Rich Salz 已提交
347 348

    if (meth->seed != NULL)
349 350
        meth->seed(buf, num);
}
351

R
Rich Salz 已提交
352
void RAND_add(const void *buf, int num, double randomness)
353 354
{
    const RAND_METHOD *meth = RAND_get_rand_method();
R
Rich Salz 已提交
355 356 357

    if (meth->add != NULL)
        meth->add(buf, num, randomness);
358
}
359

360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
/*
 * This function is not part of RAND_METHOD, so if we're not using
 * the default method, then just call RAND_bytes().  Otherwise make
 * sure we're instantiated and use the private DRBG.
 */
int RAND_priv_bytes(unsigned char *buf, int num)
{
    const RAND_METHOD *meth = RAND_get_rand_method();

    if (meth != RAND_OpenSSL())
        return RAND_bytes(buf, num);

    if (priv_drbg.state == DRBG_UNINITIALISED
            && RAND_DRBG_instantiate(&priv_drbg, NULL, 0) == 0)
        return 0;
    return RAND_DRBG_generate(&priv_drbg, buf, num, 0, NULL, 0);

}

379
int RAND_bytes(unsigned char *buf, int num)
380 381
{
    const RAND_METHOD *meth = RAND_get_rand_method();
R
Rich Salz 已提交
382 383

    if (meth->bytes != NULL)
384
        return meth->bytes(buf, num);
R
Rich Salz 已提交
385
    RANDerr(RAND_F_RAND_BYTES, RAND_R_FUNC_NOT_IMPLEMENTED);
R
Rich Salz 已提交
386
    return -1;
387
}
388

389
#if OPENSSL_API_COMPAT < 0x10100000L
390
int RAND_pseudo_bytes(unsigned char *buf, int num)
391 392
{
    const RAND_METHOD *meth = RAND_get_rand_method();
R
Rich Salz 已提交
393 394

    if (meth->pseudorand != NULL)
395
        return meth->pseudorand(buf, num);
R
Rich Salz 已提交
396
    return -1;
397
}
M
Matt Caswell 已提交
398
#endif
399 400

int RAND_status(void)
401 402
{
    const RAND_METHOD *meth = RAND_get_rand_method();
R
Rich Salz 已提交
403 404

    if (meth->status != NULL)
405 406 407
        return meth->status();
    return 0;
}