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 } PROV_TEST_RNG;
  51
  52 static void *test_rng_new(void *provctx, void *parent,
  53                           const OSSL_DISPATCH *parent_dispatch)
  54 {
  55     PROV_TEST_RNG *t;
  56
  57     t = OPENSSL_zalloc(sizeof(*t));
  58     if (t == NULL)
  59         return NULL;
  60
  61     t->max_request = INT_MAX;
  62     t->provctx = provctx;
  63     t->state = EVP_RAND_STATE_UNINITIALISED;
  64     return t;
  65 }
  66
  67 static void test_rng_free(void *vtest)
  68 {
  69     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
  70
  71     if (t == NULL)
  72         return;
  73     OPENSSL_free(t->entropy);
  74     OPENSSL_free(t->nonce);
  75     CRYPTO_THREAD_lock_free(t->lock);
  76     OPENSSL_free(t);
  77 }
  78
  79 static int test_rng_instantiate(void *vtest, unsigned int strength,
  80                                 int prediction_resistance,
  81                                 const unsigned char *pstr, size_t pstr_len,
  82                                 const OSSL_PARAM params[])
  83 {
  84     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
  85
  86     if (!test_rng_set_ctx_params(t, params) || strength > t->strength)
  87         return 0;
  88
  89     t->state = EVP_RAND_STATE_READY;
  90     t->entropy_pos = 0;
  91
  92     return 1;
  93 }
  94
  95 static int test_rng_uninstantiate(void *vtest)
  96 {
  97     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
  98
  99     t->entropy_pos = 0;
 100     t->state = EVP_RAND_STATE_UNINITIALISED;
 101     return 1;
 102 }
 103
 104 static unsigned char gen_byte(PROV_TEST_RNG *t)
 105 {
 106     return rand() & 0xff;
 107 }
 108
 109 static int test_rng_generate(void *vtest, unsigned char *out, size_t outlen,
 110                              unsigned int strength, int prediction_resistance,
 111                              const unsigned char *adin, size_t adin_len)
 112 {
 113     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 114     size_t i;
 115
 116     if (strength > t->strength)
 117         return 0;
 118     if (t->generate) {
 119         for (i = 0; i < outlen; i++)
 120             out[i] = gen_byte(t);
 121     } else {
 122         if (t->entropy_len - t->entropy_pos < outlen)
 123             return 0;
 124
 125         memcpy(out, t->entropy + t->entropy_pos, outlen);
 126         t->entropy_pos += outlen;
 127     }
 128     return 1;
 129 }
 130
 131 static int test_rng_reseed(ossl_unused void *vtest,
 132                            ossl_unused int prediction_resistance,
 133                            ossl_unused const unsigned char *ent,
 134                            ossl_unused size_t ent_len,
 135                            ossl_unused const unsigned char *adin,
 136                            ossl_unused size_t adin_len)
 137 {
 138     return 1;
 139 }
 140
 141 static size_t test_rng_nonce(void *vtest, unsigned char *out,
 142                              unsigned int strength, size_t min_noncelen,
 143                              ossl_unused size_t max_noncelen)
 144 {
 145     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 146     size_t i;
 147
 148     if (strength > t->strength)
 149         return 0;
 150
 151     if (t->generate) {
 152         for (i = 0; i < min_noncelen; i++)
 153             out[i] = gen_byte(t);
 154         return min_noncelen;
 155     }
 156
 157     if (t->nonce == NULL)
 158         return 0;
 159     if (out != NULL)
 160         memcpy(out, t->nonce, t->nonce_len);
 161     return t->nonce_len;
 162 }
 163
 164 static int test_rng_get_ctx_params(void *vtest, OSSL_PARAM params[])
 165 {
 166     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 167     OSSL_PARAM *p;
 168
 169     p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STATE);
 170     if (p != NULL && !OSSL_PARAM_set_int(p, t->state))
 171         return 0;
 172
 173     p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STRENGTH);
 174     if (p != NULL && !OSSL_PARAM_set_int(p, t->strength))
 175         return 0;
 176
 177     p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_MAX_REQUEST);
 178     if (p != NULL && !OSSL_PARAM_set_size_t(p, t->max_request))
 179         return 0;
 180
 181     p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_GENERATE);
 182     if (p != NULL && OSSL_PARAM_set_uint(p, t->generate))
 183         return 0;
 184     return 1;
 185 }
 186
 187 static const OSSL_PARAM *test_rng_gettable_ctx_params(ossl_unused void *vtest,
 188                                                       ossl_unused void *provctx)
 189 {
 190     static const OSSL_PARAM known_gettable_ctx_params[] = {
 191         OSSL_PARAM_int(OSSL_RAND_PARAM_STATE, NULL),
 192         OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
 193         OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
 194         OSSL_PARAM_uint(OSSL_RAND_PARAM_GENERATE, NULL),
 195         OSSL_PARAM_END
 196     };
 197     return known_gettable_ctx_params;
 198 }
 199
 200 static int test_rng_set_ctx_params(void *vtest, const OSSL_PARAM params[])
 201 {
 202     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 203     const OSSL_PARAM *p;
 204     void *ptr = NULL;
 205     size_t size = 0;
 206
 207     if (params == NULL)
 208         return 1;
 209
 210     p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_STRENGTH);
 211     if (p != NULL && !OSSL_PARAM_get_uint(p, &t->strength))
 212         return 0;
 213
 214     p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_ENTROPY);
 215     if (p != NULL) {
 216         if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size))
 217             return 0;
 218         OPENSSL_free(t->entropy);
 219         t->entropy = ptr;
 220         t->entropy_len = size;
 221         t->entropy_pos = 0;
 222         ptr = NULL;
 223     }
 224
 225     p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_NONCE);
 226     if (p != NULL) {
 227         if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size))
 228             return 0;
 229         OPENSSL_free(t->nonce);
 230         t->nonce = ptr;
 231         t->nonce_len = size;
 232     }
 233
 234     p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_MAX_REQUEST);
 235     if (p != NULL && !OSSL_PARAM_get_size_t(p, &t->max_request))
 236         return 0;
 237
 238     p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_GENERATE);
 239     if (p != NULL && !OSSL_PARAM_get_uint(p, &t->generate))
 240         return 0;
 241     return 1;
 242 }
 243
 244 static const OSSL_PARAM *test_rng_settable_ctx_params(ossl_unused void *vtest,
 245                                                       ossl_unused void *provctx)
 246 {
 247     static const OSSL_PARAM known_settable_ctx_params[] = {
 248         OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, NULL, 0),
 249         OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_NONCE, NULL, 0),
 250         OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
 251         OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
 252         OSSL_PARAM_uint(OSSL_RAND_PARAM_GENERATE, NULL),
 253         OSSL_PARAM_END
 254     };
 255     return known_settable_ctx_params;
 256 }
 257
 258 static int test_rng_verify_zeroization(ossl_unused void *vtest)
 259 {
 260     return 1;
 261 }
 262
 263 static size_t test_rng_get_seed(void *vtest, unsigned char **pout,
 264                                 int entropy, size_t min_len, size_t max_len,
 265                                 ossl_unused int prediction_resistance,
 266                                 ossl_unused const unsigned char *adin,
 267                                 ossl_unused size_t adin_len)
 268 {
 269     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 270
 271     *pout = t->entropy;
 272     return  t->entropy_len > max_len ? max_len : t->entropy_len;
 273 }
 274
 275 static int test_rng_enable_locking(void *vtest)
 276 {
 277     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 278
 279     if (t != NULL && t->lock == NULL) {
 280         t->lock = CRYPTO_THREAD_lock_new();
 281         if (t->lock == NULL) {
 282             ERR_raise(ERR_LIB_PROV, RAND_R_FAILED_TO_CREATE_LOCK);
 283             return 0;
 284         }
 285     }
 286     return 1;
 287 }
 288
 289 static int test_rng_lock(void *vtest)
 290 {
 291     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 292
 293     if (t == NULL || t->lock == NULL)
 294         return 1;
 295     return CRYPTO_THREAD_write_lock(t->lock);
 296 }
 297
 298 static void test_rng_unlock(void *vtest)
 299 {
 300     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 301
 302     if (t != NULL && t->lock != NULL)
 303         CRYPTO_THREAD_unlock(t->lock);
 304 }
 305
 306 const OSSL_DISPATCH ossl_test_rng_functions[] = {
 307     { OSSL_FUNC_RAND_NEWCTX, (void(*)(void))test_rng_new },
 308     { OSSL_FUNC_RAND_FREECTX, (void(*)(void))test_rng_free },
 309     { OSSL_FUNC_RAND_INSTANTIATE,
 310       (void(*)(void))test_rng_instantiate },
 311     { OSSL_FUNC_RAND_UNINSTANTIATE,
 312       (void(*)(void))test_rng_uninstantiate },
 313     { OSSL_FUNC_RAND_GENERATE, (void(*)(void))test_rng_generate },
 314     { OSSL_FUNC_RAND_RESEED, (void(*)(void))test_rng_reseed },
 315     { OSSL_FUNC_RAND_NONCE, (void(*)(void))test_rng_nonce },
 316     { OSSL_FUNC_RAND_ENABLE_LOCKING, (void(*)(void))test_rng_enable_locking },
 317     { OSSL_FUNC_RAND_LOCK, (void(*)(void))test_rng_lock },
 318     { OSSL_FUNC_RAND_UNLOCK, (void(*)(void))test_rng_unlock },
 319     { OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS,
 320       (void(*)(void))test_rng_settable_ctx_params },
 321     { OSSL_FUNC_RAND_SET_CTX_PARAMS, (void(*)(void))test_rng_set_ctx_params },
 322     { OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS,
 323       (void(*)(void))test_rng_gettable_ctx_params },
 324     { OSSL_FUNC_RAND_GET_CTX_PARAMS, (void(*)(void))test_rng_get_ctx_params },
 325     { OSSL_FUNC_RAND_VERIFY_ZEROIZATION,
 326       (void(*)(void))test_rng_verify_zeroization },
 327     { OSSL_FUNC_RAND_GET_SEED, (void(*)(void))test_rng_get_seed },
 328     OSSL_DISPATCH_END
 329 };