providers/implementations/rands/test_rng.c

   1 /*
   2  * Copyright 2020-2023 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (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 <string.h>
  11 #include <stdlib.h>
  12 #include <openssl/core_dispatch.h>
  13 #include <openssl/e_os2.h>
  14 #include <openssl/params.h>
  15 #include <openssl/core_names.h>
  16 #include <openssl/evp.h>
  17 #include <openssl/err.h>
  18 #include <openssl/randerr.h>
  19 #include "prov/providercommon.h"
  20 #include "prov/provider_ctx.h"
  21 #include "prov/provider_util.h"
  22 #include "prov/implementations.h"
  23
  24 static OSSL_FUNC_rand_newctx_fn test_rng_new;
  25 static OSSL_FUNC_rand_freectx_fn test_rng_free;
  26 static OSSL_FUNC_rand_instantiate_fn test_rng_instantiate;
  27 static OSSL_FUNC_rand_uninstantiate_fn test_rng_uninstantiate;
  28 static OSSL_FUNC_rand_generate_fn test_rng_generate;
  29 static OSSL_FUNC_rand_reseed_fn test_rng_reseed;
  30 static OSSL_FUNC_rand_nonce_fn test_rng_nonce;
  31 static OSSL_FUNC_rand_settable_ctx_params_fn test_rng_settable_ctx_params;
  32 static OSSL_FUNC_rand_set_ctx_params_fn test_rng_set_ctx_params;
  33 static OSSL_FUNC_rand_gettable_ctx_params_fn test_rng_gettable_ctx_params;
  34 static OSSL_FUNC_rand_get_ctx_params_fn test_rng_get_ctx_params;
  35 static OSSL_FUNC_rand_verify_zeroization_fn test_rng_verify_zeroization;
  36 static OSSL_FUNC_rand_enable_locking_fn test_rng_enable_locking;
  37 static OSSL_FUNC_rand_lock_fn test_rng_lock;
  38 static OSSL_FUNC_rand_unlock_fn test_rng_unlock;
  39 static OSSL_FUNC_rand_get_seed_fn test_rng_get_seed;
  40
  41 typedef struct {
  42     void *provctx;
  43     unsigned int generate;
  44     int state;
  45     unsigned int strength;
  46     size_t max_request;
  47     unsigned char *entropy, *nonce;
  48     size_t entropy_len, entropy_pos, nonce_len;
  49     CRYPTO_RWLOCK *lock;
  50     uint32_t seed;
  51 } PROV_TEST_RNG;
  52
  53 static void *test_rng_new(void *provctx, void *parent,
  54                           const OSSL_DISPATCH *parent_dispatch)
  55 {
  56     PROV_TEST_RNG *t;
  57
  58     t = OPENSSL_zalloc(sizeof(*t));
  59     if (t == NULL)
  60         return NULL;
  61
  62     t->max_request = INT_MAX;
  63     t->provctx = provctx;
  64     t->state = EVP_RAND_STATE_UNINITIALISED;
  65     return t;
  66 }
  67
  68 static void test_rng_free(void *vtest)
  69 {
  70     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
  71
  72     if (t == NULL)
  73         return;
  74     OPENSSL_free(t->entropy);
  75     OPENSSL_free(t->nonce);
  76     CRYPTO_THREAD_lock_free(t->lock);
  77     OPENSSL_free(t);
  78 }
  79
  80 static int test_rng_instantiate(void *vtest, unsigned int strength,
  81                                 int prediction_resistance,
  82                                 const unsigned char *pstr, size_t pstr_len,
  83                                 const OSSL_PARAM params[])
  84 {
  85     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
  86
  87     if (!test_rng_set_ctx_params(t, params) || strength > t->strength)
  88         return 0;
  89
  90     t->state = EVP_RAND_STATE_READY;
  91     t->entropy_pos = 0;
  92     t->seed = 221953166;    /* Value doesn't matter, so long as it isn't zero */
  93
  94     return 1;
  95 }
  96
  97 static int test_rng_uninstantiate(void *vtest)
  98 {
  99     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 100
 101     t->entropy_pos = 0;
 102     t->state = EVP_RAND_STATE_UNINITIALISED;
 103     return 1;
 104 }
 105
 106 static unsigned char gen_byte(PROV_TEST_RNG *t)
 107 {
 108     uint32_t n;
 109
 110     /*
 111      * Implement the 32 bit xorshift as suggested by George Marsaglia in:
 112      *      https://doi.org/10.18637/jss.v008.i14
 113      *
 114      * This is a very fast PRNG so there is no need to extract bytes one at a
 115      * time and use the entire value each time.
 116      */
 117     n = t->seed;
 118     n ^= n << 13;
 119     n ^= n >> 17;
 120     n ^= n << 5;
 121     t->seed = n;
 122
 123     return n & 0xff;
 124 }
 125
 126 static int test_rng_generate(void *vtest, unsigned char *out, size_t outlen,
 127                              unsigned int strength, int prediction_resistance,
 128                              const unsigned char *adin, size_t adin_len)
 129 {
 130     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 131     size_t i;
 132
 133     if (strength > t->strength)
 134         return 0;
 135     if (t->generate) {
 136         for (i = 0; i < outlen; i++)
 137             out[i] = gen_byte(t);
 138     } else {
 139         if (t->entropy_len - t->entropy_pos < outlen)
 140             return 0;
 141
 142         memcpy(out, t->entropy + t->entropy_pos, outlen);
 143         t->entropy_pos += outlen;
 144     }
 145     return 1;
 146 }
 147
 148 static int test_rng_reseed(ossl_unused void *vtest,
 149                            ossl_unused int prediction_resistance,
 150                            ossl_unused const unsigned char *ent,
 151                            ossl_unused size_t ent_len,
 152                            ossl_unused const unsigned char *adin,
 153                            ossl_unused size_t adin_len)
 154 {
 155     return 1;
 156 }
 157
 158 static size_t test_rng_nonce(void *vtest, unsigned char *out,
 159                              unsigned int strength, size_t min_noncelen,
 160                              ossl_unused size_t max_noncelen)
 161 {
 162     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 163     size_t i;
 164
 165     if (strength > t->strength)
 166         return 0;
 167
 168     if (t->generate) {
 169         for (i = 0; i < min_noncelen; i++)
 170             out[i] = gen_byte(t);
 171         return min_noncelen;
 172     }
 173
 174     if (t->nonce == NULL)
 175         return 0;
 176     if (out != NULL)
 177         memcpy(out, t->nonce, t->nonce_len);
 178     return t->nonce_len;
 179 }
 180
 181 static int test_rng_get_ctx_params(void *vtest, OSSL_PARAM params[])
 182 {
 183     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 184     OSSL_PARAM *p;
 185
 186     p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STATE);
 187     if (p != NULL && !OSSL_PARAM_set_int(p, t->state))
 188         return 0;
 189
 190     p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STRENGTH);
 191     if (p != NULL && !OSSL_PARAM_set_int(p, t->strength))
 192         return 0;
 193
 194     p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_MAX_REQUEST);
 195     if (p != NULL && !OSSL_PARAM_set_size_t(p, t->max_request))
 196         return 0;
 197
 198     p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_GENERATE);
 199     if (p != NULL && OSSL_PARAM_set_uint(p, t->generate))
 200         return 0;
 201     return 1;
 202 }
 203
 204 static const OSSL_PARAM *test_rng_gettable_ctx_params(ossl_unused void *vtest,
 205                                                       ossl_unused void *provctx)
 206 {
 207     static const OSSL_PARAM known_gettable_ctx_params[] = {
 208         OSSL_PARAM_int(OSSL_RAND_PARAM_STATE, NULL),
 209         OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
 210         OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
 211         OSSL_PARAM_uint(OSSL_RAND_PARAM_GENERATE, NULL),
 212         OSSL_PARAM_END
 213     };
 214     return known_gettable_ctx_params;
 215 }
 216
 217 static int test_rng_set_ctx_params(void *vtest, const OSSL_PARAM params[])
 218 {
 219     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 220     const OSSL_PARAM *p;
 221     void *ptr = NULL;
 222     size_t size = 0;
 223
 224     if (params == NULL)
 225         return 1;
 226
 227     p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_STRENGTH);
 228     if (p != NULL && !OSSL_PARAM_get_uint(p, &t->strength))
 229         return 0;
 230
 231     p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_ENTROPY);
 232     if (p != NULL) {
 233         if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size))
 234             return 0;
 235         OPENSSL_free(t->entropy);
 236         t->entropy = ptr;
 237         t->entropy_len = size;
 238         t->entropy_pos = 0;
 239         ptr = NULL;
 240     }
 241
 242     p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_NONCE);
 243     if (p != NULL) {
 244         if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size))
 245             return 0;
 246         OPENSSL_free(t->nonce);
 247         t->nonce = ptr;
 248         t->nonce_len = size;
 249     }
 250
 251     p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_MAX_REQUEST);
 252     if (p != NULL && !OSSL_PARAM_get_size_t(p, &t->max_request))
 253         return 0;
 254
 255     p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_GENERATE);
 256     if (p != NULL && !OSSL_PARAM_get_uint(p, &t->generate))
 257         return 0;
 258     return 1;
 259 }
 260
 261 static const OSSL_PARAM *test_rng_settable_ctx_params(ossl_unused void *vtest,
 262                                                       ossl_unused void *provctx)
 263 {
 264     static const OSSL_PARAM known_settable_ctx_params[] = {
 265         OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, NULL, 0),
 266         OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_NONCE, NULL, 0),
 267         OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
 268         OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
 269         OSSL_PARAM_uint(OSSL_RAND_PARAM_GENERATE, NULL),
 270         OSSL_PARAM_END
 271     };
 272     return known_settable_ctx_params;
 273 }
 274
 275 static int test_rng_verify_zeroization(ossl_unused void *vtest)
 276 {
 277     return 1;
 278 }
 279
 280 static size_t test_rng_get_seed(void *vtest, unsigned char **pout,
 281                                 int entropy, size_t min_len, size_t max_len,
 282                                 ossl_unused int prediction_resistance,
 283                                 ossl_unused const unsigned char *adin,
 284                                 ossl_unused size_t adin_len)
 285 {
 286     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 287
 288     *pout = t->entropy;
 289     return  t->entropy_len > max_len ? max_len : t->entropy_len;
 290 }
 291
 292 static int test_rng_enable_locking(void *vtest)
 293 {
 294     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 295
 296     if (t != NULL && t->lock == NULL) {
 297         t->lock = CRYPTO_THREAD_lock_new();
 298         if (t->lock == NULL) {
 299             ERR_raise(ERR_LIB_PROV, RAND_R_FAILED_TO_CREATE_LOCK);
 300             return 0;
 301         }
 302     }
 303     return 1;
 304 }
 305
 306 static int test_rng_lock(void *vtest)
 307 {
 308     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 309
 310     if (t == NULL || t->lock == NULL)
 311         return 1;
 312     return CRYPTO_THREAD_write_lock(t->lock);
 313 }
 314
 315 static void test_rng_unlock(void *vtest)
 316 {
 317     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 318
 319     if (t != NULL && t->lock != NULL)
 320         CRYPTO_THREAD_unlock(t->lock);
 321 }
 322
 323 const OSSL_DISPATCH ossl_test_rng_functions[] = {
 324     { OSSL_FUNC_RAND_NEWCTX, (void(*)(void))test_rng_new },
 325     { OSSL_FUNC_RAND_FREECTX, (void(*)(void))test_rng_free },
 326     { OSSL_FUNC_RAND_INSTANTIATE,
 327       (void(*)(void))test_rng_instantiate },
 328     { OSSL_FUNC_RAND_UNINSTANTIATE,
 329       (void(*)(void))test_rng_uninstantiate },
 330     { OSSL_FUNC_RAND_GENERATE, (void(*)(void))test_rng_generate },
 331     { OSSL_FUNC_RAND_RESEED, (void(*)(void))test_rng_reseed },
 332     { OSSL_FUNC_RAND_NONCE, (void(*)(void))test_rng_nonce },
 333     { OSSL_FUNC_RAND_ENABLE_LOCKING, (void(*)(void))test_rng_enable_locking },
 334     { OSSL_FUNC_RAND_LOCK, (void(*)(void))test_rng_lock },
 335     { OSSL_FUNC_RAND_UNLOCK, (void(*)(void))test_rng_unlock },
 336     { OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS,
 337       (void(*)(void))test_rng_settable_ctx_params },
 338     { OSSL_FUNC_RAND_SET_CTX_PARAMS, (void(*)(void))test_rng_set_ctx_params },
 339     { OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS,
 340       (void(*)(void))test_rng_gettable_ctx_params },
 341     { OSSL_FUNC_RAND_GET_CTX_PARAMS, (void(*)(void))test_rng_get_ctx_params },
 342     { OSSL_FUNC_RAND_VERIFY_ZEROIZATION,
 343       (void(*)(void))test_rng_verify_zeroization },
 344     { OSSL_FUNC_RAND_GET_SEED, (void(*)(void))test_rng_get_seed },
 345     OSSL_DISPATCH_END
 346 };