providers/implementations/rands/drbg_hash.c

   1 /*
   2  * Copyright 2011-2020 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 <assert.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <openssl/sha.h>
  14 #include <openssl/crypto.h>
  15 #include <openssl/err.h>
  16 #include <openssl/rand.h>
  17 #include <openssl/core_dispatch.h>
  18 #include "internal/thread_once.h"
  19 #include "prov/providercommon.h"
  20 #include "prov/provider_ctx.h"
  21 #include "prov/provider_util.h"
  22 #include "prov/implementations.h"
  23 #include "prov/providercommonerr.h"
  24 #include "drbg_local.h"
  25
  26 static OSSL_FUNC_rand_newctx_fn drbg_hash_new_wrapper;
  27 static OSSL_FUNC_rand_freectx_fn drbg_hash_free;
  28 static OSSL_FUNC_rand_instantiate_fn drbg_hash_instantiate_wrapper;
  29 static OSSL_FUNC_rand_uninstantiate_fn drbg_hash_uninstantiate_wrapper;
  30 static OSSL_FUNC_rand_generate_fn drbg_hash_generate_wrapper;
  31 static OSSL_FUNC_rand_reseed_fn drbg_hash_reseed_wrapper;
  32 static OSSL_FUNC_rand_settable_ctx_params_fn drbg_hash_settable_ctx_params;
  33 static OSSL_FUNC_rand_set_ctx_params_fn drbg_hash_set_ctx_params;
  34 static OSSL_FUNC_rand_gettable_ctx_params_fn drbg_hash_gettable_ctx_params;
  35 static OSSL_FUNC_rand_get_ctx_params_fn drbg_hash_get_ctx_params;
  36 static OSSL_FUNC_rand_verify_zeroization_fn drbg_hash_verify_zeroization;
  37
  38 /* 888 bits from SP800-90Ar1 10.1 table 2 */
  39 #define HASH_PRNG_MAX_SEEDLEN    (888/8)
  40
  41 /* 440 bits from SP800-90Ar1 10.1 table 2 */
  42 #define HASH_PRNG_SMALL_SEEDLEN   (440/8)
  43
  44 /* Determine what seedlen to use based on the block length */
  45 #define MAX_BLOCKLEN_USING_SMALL_SEEDLEN (256/8)
  46 #define INBYTE_IGNORE ((unsigned char)0xFF)
  47
  48 typedef struct rand_drbg_hash_st {
  49     PROV_DIGEST digest;
  50     EVP_MD_CTX *ctx;
  51     size_t blocklen;
  52     unsigned char V[HASH_PRNG_MAX_SEEDLEN];
  53     unsigned char C[HASH_PRNG_MAX_SEEDLEN];
  54     /* Temporary value storage: should always exceed max digest length */
  55     unsigned char vtmp[HASH_PRNG_MAX_SEEDLEN];
  56 } PROV_DRBG_HASH;
  57
  58 /*
  59  * SP800-90Ar1 10.3.1 Derivation function using a Hash Function (Hash_df).
  60  * The input string used is composed of:
  61  *    inbyte - An optional leading byte (ignore if equal to INBYTE_IGNORE)
  62  *    in - input string 1 (A Non NULL value).
  63  *    in2 - optional input string (Can be NULL).
  64  *    in3 - optional input string (Can be NULL).
  65  *    These are concatenated as part of the DigestUpdate process.
  66  */
  67 static int hash_df(PROV_DRBG *drbg, unsigned char *out,
  68                    const unsigned char inbyte,
  69                    const unsigned char *in, size_t inlen,
  70                    const unsigned char *in2, size_t in2len,
  71                    const unsigned char *in3, size_t in3len)
  72 {
  73     PROV_DRBG_HASH *hash = (PROV_DRBG_HASH *)drbg->data;
  74     EVP_MD_CTX *ctx = hash->ctx;
  75     unsigned char *vtmp = hash->vtmp;
  76     /* tmp = counter || num_bits_returned || [inbyte] */
  77     unsigned char tmp[1 + 4 + 1];
  78     int tmp_sz = 0;
  79     size_t outlen = drbg->seedlen;
  80     size_t num_bits_returned = outlen * 8;
  81     /*
  82      * No need to check outlen size here, as the standard only ever needs
  83      * seedlen bytes which is always less than the maximum permitted.
  84      */
  85
  86     /* (Step 3) counter = 1 (tmp[0] is the 8 bit counter) */
  87     tmp[tmp_sz++] = 1;
  88     /* tmp[1..4] is the fixed 32 bit no_of_bits_to_return */
  89     tmp[tmp_sz++] = (unsigned char)((num_bits_returned >> 24) & 0xff);
  90     tmp[tmp_sz++] = (unsigned char)((num_bits_returned >> 16) & 0xff);
  91     tmp[tmp_sz++] = (unsigned char)((num_bits_returned >> 8) & 0xff);
  92     tmp[tmp_sz++] = (unsigned char)(num_bits_returned & 0xff);
  93     /* Tack the additional input byte onto the end of tmp if it exists */
  94     if (inbyte != INBYTE_IGNORE)
  95         tmp[tmp_sz++] = inbyte;
  96
  97     /* (Step 4) */
  98     for (;;) {
  99         /*
 100          * (Step 4.1) out = out || Hash(tmp || in || [in2] || [in3])
 101          *            (where tmp = counter || num_bits_returned || [inbyte])
 102          */
 103         if (!(EVP_DigestInit_ex(ctx, ossl_prov_digest_md(&hash->digest), NULL)
 104                 && EVP_DigestUpdate(ctx, tmp, tmp_sz)
 105                 && EVP_DigestUpdate(ctx, in, inlen)
 106                 && (in2 == NULL || EVP_DigestUpdate(ctx, in2, in2len))
 107                 && (in3 == NULL || EVP_DigestUpdate(ctx, in3, in3len))))
 108             return 0;
 109
 110         if (outlen < hash->blocklen) {
 111             if (!EVP_DigestFinal(ctx, vtmp, NULL))
 112                 return 0;
 113             memcpy(out, vtmp, outlen);
 114             OPENSSL_cleanse(vtmp, hash->blocklen);
 115             break;
 116         } else if(!EVP_DigestFinal(ctx, out, NULL)) {
 117             return 0;
 118         }
 119
 120         outlen -= hash->blocklen;
 121         if (outlen == 0)
 122             break;
 123         /* (Step 4.2) counter++ */
 124         tmp[0]++;
 125         out += hash->blocklen;
 126     }
 127     return 1;
 128 }
 129
 130 /* Helper function that just passes 2 input parameters to hash_df() */
 131 static int hash_df1(PROV_DRBG *drbg, unsigned char *out,
 132                     const unsigned char in_byte,
 133                     const unsigned char *in1, size_t in1len)
 134 {
 135     return hash_df(drbg, out, in_byte, in1, in1len, NULL, 0, NULL, 0);
 136 }
 137
 138 /*
 139  * Add 2 byte buffers together. The first elements in each buffer are the top
 140  * most bytes. The result is stored in the dst buffer.
 141  * The final carry is ignored i.e: dst =  (dst + in) mod (2^seedlen_bits).
 142  * where dst size is drbg->seedlen, and inlen <= drbg->seedlen.
 143  */
 144 static int add_bytes(PROV_DRBG *drbg, unsigned char *dst,
 145                      unsigned char *in, size_t inlen)
 146 {
 147     size_t i;
 148     int result;
 149     const unsigned char *add;
 150     unsigned char carry = 0, *d;
 151
 152     assert(drbg->seedlen >= 1 && inlen >= 1 && inlen <= drbg->seedlen);
 153
 154     d = &dst[drbg->seedlen - 1];
 155     add = &in[inlen - 1];
 156
 157     for (i = inlen; i > 0; i--, d--, add--) {
 158         result = *d + *add + carry;
 159         carry = (unsigned char)(result >> 8);
 160         *d = (unsigned char)(result & 0xff);
 161     }
 162
 163     if (carry != 0) {
 164         /* Add the carry to the top of the dst if inlen is not the same size */
 165         for (i = drbg->seedlen - inlen; i > 0; --i, d--) {
 166             *d += 1;     /* Carry can only be 1 */
 167             if (*d != 0) /* exit if carry doesnt propagate to the next byte */
 168                 break;
 169         }
 170     }
 171     return 1;
 172 }
 173
 174 /* V = (V + Hash(inbyte || V  || [additional_input]) mod (2^seedlen) */
 175 static int add_hash_to_v(PROV_DRBG *drbg, unsigned char inbyte,
 176                          const unsigned char *adin, size_t adinlen)
 177 {
 178     PROV_DRBG_HASH *hash = (PROV_DRBG_HASH *)drbg->data;
 179     EVP_MD_CTX *ctx = hash->ctx;
 180
 181     return EVP_DigestInit_ex(ctx, ossl_prov_digest_md(&hash->digest), NULL)
 182            && EVP_DigestUpdate(ctx, &inbyte, 1)
 183            && EVP_DigestUpdate(ctx, hash->V, drbg->seedlen)
 184            && (adin == NULL || EVP_DigestUpdate(ctx, adin, adinlen))
 185            && EVP_DigestFinal(ctx, hash->vtmp, NULL)
 186            && add_bytes(drbg, hash->V, hash->vtmp, hash->blocklen);
 187 }
 188
 189 /*
 190  * The Hashgen() as listed in SP800-90Ar1 10.1.1.4 Hash_DRBG_Generate_Process.
 191  *
 192  * drbg contains the current value of V.
 193  * outlen is the requested number of bytes.
 194  * out is a buffer to return the generated bits.
 195  *
 196  * The algorithm to generate the bits is:
 197  *     data = V
 198  *     w = NULL
 199  *     for (i = 1 to m) {
 200  *        W = W || Hash(data)
 201  *        data = (data + 1) mod (2^seedlen)
 202  *     }
 203  *     out = Leftmost(W, outlen)
 204  *
 205  * Returns zero if an error occurs otherwise it returns 1.
 206  */
 207 static int hash_gen(PROV_DRBG *drbg, unsigned char *out, size_t outlen)
 208 {
 209     PROV_DRBG_HASH *hash = (PROV_DRBG_HASH *)drbg->data;
 210     unsigned char one = 1;
 211
 212     if (outlen == 0)
 213         return 1;
 214     memcpy(hash->vtmp, hash->V, drbg->seedlen);
 215     for(;;) {
 216         if (!EVP_DigestInit_ex(hash->ctx, ossl_prov_digest_md(&hash->digest),
 217                                NULL)
 218                 || !EVP_DigestUpdate(hash->ctx, hash->vtmp, drbg->seedlen))
 219             return 0;
 220
 221         if (outlen < hash->blocklen) {
 222             if (!EVP_DigestFinal(hash->ctx, hash->vtmp, NULL))
 223                 return 0;
 224             memcpy(out, hash->vtmp, outlen);
 225             return 1;
 226         } else {
 227             if (!EVP_DigestFinal(hash->ctx, out, NULL))
 228                 return 0;
 229             outlen -= hash->blocklen;
 230             if (outlen == 0)
 231                 break;
 232             out += hash->blocklen;
 233         }
 234         add_bytes(drbg, hash->vtmp, &one, 1);
 235     }
 236     return 1;
 237 }
 238
 239 /*
 240  * SP800-90Ar1 10.1.1.2 Hash_DRBG_Instantiate_Process:
 241  *
 242  * ent is entropy input obtained from a randomness source of length ent_len.
 243  * nonce is a string of bytes of length nonce_len.
 244  * pstr is a personalization string received from an application. May be NULL.
 245  *
 246  * Returns zero if an error occurs otherwise it returns 1.
 247  */
 248 static int drbg_hash_instantiate(PROV_DRBG *drbg,
 249                                  const unsigned char *ent, size_t ent_len,
 250                                  const unsigned char *nonce, size_t nonce_len,
 251                                  const unsigned char *pstr, size_t pstr_len)
 252 {
 253     PROV_DRBG_HASH *hash = (PROV_DRBG_HASH *)drbg->data;
 254
 255     EVP_MD_CTX_free(hash->ctx);
 256     hash->ctx = EVP_MD_CTX_new();
 257
 258     /* (Step 1-3) V = Hash_df(entropy||nonce||pers, seedlen) */
 259     return hash->ctx != NULL
 260            && hash_df(drbg, hash->V, INBYTE_IGNORE,
 261                       ent, ent_len, nonce, nonce_len, pstr, pstr_len)
 262            /* (Step 4) C = Hash_df(0x00||V, seedlen) */
 263            && hash_df1(drbg, hash->C, 0x00, hash->V, drbg->seedlen);
 264 }
 265
 266 static int drbg_hash_instantiate_wrapper(void *vdrbg, unsigned int strength,
 267                                          int prediction_resistance,
 268                                          const unsigned char *pstr,
 269                                          size_t pstr_len)
 270 {
 271     PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
 272
 273     return ossl_prov_drbg_instantiate(drbg, strength, prediction_resistance,
 274                                       pstr, pstr_len);
 275 }
 276
 277 /*
 278  * SP800-90Ar1 10.1.1.3 Hash_DRBG_Reseed_Process:
 279  *
 280  * ent is entropy input bytes obtained from a randomness source.
 281  * addin is additional input received from an application. May be NULL.
 282  *
 283  * Returns zero if an error occurs otherwise it returns 1.
 284  */
 285 static int drbg_hash_reseed(PROV_DRBG *drbg,
 286                             const unsigned char *ent, size_t ent_len,
 287                             const unsigned char *adin, size_t adin_len)
 288 {
 289     PROV_DRBG_HASH *hash = (PROV_DRBG_HASH *)drbg->data;
 290
 291     /* (Step 1-2) V = Hash_df(0x01 || V || entropy_input || additional_input) */
 292     /* V about to be updated so use C as output instead */
 293     if (!hash_df(drbg, hash->C, 0x01, hash->V, drbg->seedlen, ent, ent_len,
 294                  adin, adin_len))
 295         return 0;
 296     memcpy(hash->V, hash->C, drbg->seedlen);
 297     /* (Step 4) C = Hash_df(0x00||V, seedlen) */
 298     return hash_df1(drbg, hash->C, 0x00, hash->V, drbg->seedlen);
 299 }
 300
 301 static int drbg_hash_reseed_wrapper(void *vdrbg, int prediction_resistance,
 302                                     const unsigned char *ent, size_t ent_len,
 303                                     const unsigned char *adin, size_t adin_len)
 304 {
 305     PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
 306
 307     return ossl_prov_drbg_reseed(drbg, prediction_resistance, ent, ent_len,
 308                                  adin, adin_len);
 309 }
 310
 311 /*
 312  * SP800-90Ar1 10.1.1.4 Hash_DRBG_Generate_Process:
 313  *
 314  * Generates pseudo random bytes using the drbg.
 315  * out is a buffer to fill with outlen bytes of pseudo random data.
 316  * addin is additional input received from an application. May be NULL.
 317  *
 318  * Returns zero if an error occurs otherwise it returns 1.
 319  */
 320 static int drbg_hash_generate(PROV_DRBG *drbg,
 321                               unsigned char *out, size_t outlen,
 322                               const unsigned char *adin, size_t adin_len)
 323 {
 324     PROV_DRBG_HASH *hash = (PROV_DRBG_HASH *)drbg->data;
 325     unsigned char counter[4];
 326     int reseed_counter = drbg->generate_counter;
 327
 328     counter[0] = (unsigned char)((reseed_counter >> 24) & 0xff);
 329     counter[1] = (unsigned char)((reseed_counter >> 16) & 0xff);
 330     counter[2] = (unsigned char)((reseed_counter >> 8) & 0xff);
 331     counter[3] = (unsigned char)(reseed_counter & 0xff);
 332
 333     return hash->ctx != NULL
 334            && (adin == NULL
 335            /* (Step 2) if adin != NULL then V = V + Hash(0x02||V||adin) */
 336                || adin_len == 0
 337                || add_hash_to_v(drbg, 0x02, adin, adin_len))
 338            /* (Step 3) Hashgen(outlen, V) */
 339            && hash_gen(drbg, out, outlen)
 340            /* (Step 4/5) H = V = (V + Hash(0x03||V) mod (2^seedlen_bits) */
 341            && add_hash_to_v(drbg, 0x03, NULL, 0)
 342            /* (Step 5) V = (V + H + C + reseed_counter) mod (2^seedlen_bits) */
 343            /* V = (V + C) mod (2^seedlen_bits) */
 344            && add_bytes(drbg, hash->V, hash->C, drbg->seedlen)
 345            /* V = (V + reseed_counter) mod (2^seedlen_bits) */
 346            && add_bytes(drbg, hash->V, counter, 4);
 347 }
 348
 349 static int drbg_hash_generate_wrapper
 350     (void *vdrbg, unsigned char *out, size_t outlen, unsigned int strength,
 351      int prediction_resistance, const unsigned char *adin, size_t adin_len)
 352 {
 353     PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
 354
 355     return ossl_prov_drbg_generate(drbg, out, outlen, strength,
 356                                    prediction_resistance, adin, adin_len);
 357 }
 358
 359 static int drbg_hash_uninstantiate(PROV_DRBG *drbg)
 360 {
 361     PROV_DRBG_HASH *hash = (PROV_DRBG_HASH *)drbg->data;
 362
 363     OPENSSL_cleanse(hash->V, sizeof(hash->V));
 364     OPENSSL_cleanse(hash->C, sizeof(hash->C));
 365     OPENSSL_cleanse(hash->vtmp, sizeof(hash->vtmp));
 366     return ossl_prov_drbg_uninstantiate(drbg);
 367 }
 368
 369 static int drbg_hash_uninstantiate_wrapper(void *vdrbg)
 370 {
 371     return drbg_hash_uninstantiate((PROV_DRBG *)vdrbg);
 372 }
 373
 374 static int drbg_hash_verify_zeroization(void *vdrbg)
 375 {
 376     PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
 377     PROV_DRBG_HASH *hash = (PROV_DRBG_HASH *)drbg->data;
 378
 379     PROV_DRBG_VERYIFY_ZEROIZATION(hash->V);
 380     PROV_DRBG_VERYIFY_ZEROIZATION(hash->C);
 381     PROV_DRBG_VERYIFY_ZEROIZATION(hash->vtmp);
 382     return 1;
 383 }
 384
 385 static int drbg_hash_new(PROV_DRBG *ctx)
 386 {
 387     PROV_DRBG_HASH *hash;
 388
 389     hash = OPENSSL_secure_zalloc(sizeof(*hash));
 390     if (hash == NULL) {
 391         ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
 392         return 0;
 393     }
 394
 395     ctx->data = hash;
 396     ctx->seedlen = HASH_PRNG_MAX_SEEDLEN;
 397     ctx->max_entropylen = DRBG_MAX_LENGTH;
 398     ctx->max_noncelen = DRBG_MAX_LENGTH;
 399     ctx->max_perslen = DRBG_MAX_LENGTH;
 400     ctx->max_adinlen = DRBG_MAX_LENGTH;
 401
 402     /* Maximum number of bits per request = 2^19  = 2^16 bytes */
 403     ctx->max_request = 1 << 16;
 404     return 1;
 405 }
 406
 407 static void *drbg_hash_new_wrapper(void *provctx, void *parent,
 408                                    const OSSL_DISPATCH *parent_dispatch)
 409 {
 410     return prov_rand_drbg_new(provctx, parent, parent_dispatch, &drbg_hash_new,
 411                               &drbg_hash_instantiate, &drbg_hash_uninstantiate,
 412                               &drbg_hash_reseed, &drbg_hash_generate);
 413 }
 414
 415 static void drbg_hash_free(void *vdrbg)
 416 {
 417     PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
 418     PROV_DRBG_HASH *hash;
 419
 420     if (drbg != NULL && (hash = (PROV_DRBG_HASH *)drbg->data) != NULL) {
 421         EVP_MD_CTX_free(hash->ctx);
 422         ossl_prov_digest_reset(&hash->digest);
 423         OPENSSL_secure_clear_free(hash, sizeof(*hash));
 424     }
 425     prov_rand_drbg_free(drbg);
 426 }
 427
 428 static int drbg_hash_get_ctx_params(void *vdrbg, OSSL_PARAM params[])
 429 {
 430     PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
 431     PROV_DRBG_HASH *hash = (PROV_DRBG_HASH *)drbg->data;
 432     const EVP_MD *md;
 433     OSSL_PARAM *p;
 434
 435     p = OSSL_PARAM_locate(params, OSSL_DRBG_PARAM_DIGEST);
 436     if (p != NULL) {
 437         md = ossl_prov_digest_md(&hash->digest);
 438         if (md == NULL || !OSSL_PARAM_set_utf8_string(p, EVP_MD_name(md)))
 439             return 0;
 440     }
 441
 442     return drbg_get_ctx_params(drbg, params);
 443 }
 444
 445 static const OSSL_PARAM *drbg_hash_gettable_ctx_params(ossl_unused void *p_ctx)
 446 {
 447     static const OSSL_PARAM known_gettable_ctx_params[] = {
 448         OSSL_PARAM_utf8_string(OSSL_DRBG_PARAM_DIGEST, NULL, 0),
 449         OSSL_PARAM_DRBG_GETTABLE_CTX_COMMON,
 450         OSSL_PARAM_END
 451     };
 452     return known_gettable_ctx_params;
 453 }
 454
 455 static int drbg_hash_set_ctx_params(void *vctx, const OSSL_PARAM params[])
 456 {
 457     PROV_DRBG *ctx = (PROV_DRBG *)vctx;
 458     PROV_DRBG_HASH *hash = (PROV_DRBG_HASH *)ctx->data;
 459     OSSL_LIB_CTX *libctx = PROV_LIBRARY_CONTEXT_OF(ctx->provctx);
 460     const EVP_MD *md;
 461
 462     if (!ossl_prov_digest_load_from_params(&hash->digest, params, libctx))
 463         return 0;
 464
 465     md = ossl_prov_digest_md(&hash->digest);
 466     if (md != NULL) {
 467         if ((EVP_MD_flags(md) & EVP_MD_FLAG_XOF) != 0) {
 468             ERR_raise(ERR_LIB_PROV, PROV_R_XOF_DIGESTS_NOT_ALLOWED);
 469             return 0;
 470         }
 471
 472         /* These are taken from SP 800-90 10.1 Table 2 */
 473         hash->blocklen = EVP_MD_size(md);
 474         /* See SP800-57 Part1 Rev4 5.6.1 Table 3 */
 475         ctx->strength = 64 * (hash->blocklen >> 3);
 476         if (ctx->strength > 256)
 477             ctx->strength = 256;
 478         if (hash->blocklen > MAX_BLOCKLEN_USING_SMALL_SEEDLEN)
 479             ctx->seedlen = HASH_PRNG_MAX_SEEDLEN;
 480         else
 481             ctx->seedlen = HASH_PRNG_SMALL_SEEDLEN;
 482
 483         ctx->min_entropylen = ctx->strength / 8;
 484         ctx->min_noncelen = ctx->min_entropylen / 2;
 485     }
 486
 487     return drbg_set_ctx_params(ctx, params);
 488 }
 489
 490 static const OSSL_PARAM *drbg_hash_settable_ctx_params(ossl_unused void *p_ctx)
 491 {
 492     static const OSSL_PARAM known_settable_ctx_params[] = {
 493         OSSL_PARAM_utf8_string(OSSL_DRBG_PARAM_PROPERTIES, NULL, 0),
 494         OSSL_PARAM_utf8_string(OSSL_DRBG_PARAM_DIGEST, NULL, 0),
 495         OSSL_PARAM_DRBG_SETTABLE_CTX_COMMON,
 496         OSSL_PARAM_END
 497     };
 498     return known_settable_ctx_params;
 499 }
 500
 501 const OSSL_DISPATCH ossl_drbg_hash_functions[] = {
 502     { OSSL_FUNC_RAND_NEWCTX, (void(*)(void))drbg_hash_new_wrapper },
 503     { OSSL_FUNC_RAND_FREECTX, (void(*)(void))drbg_hash_free },
 504     { OSSL_FUNC_RAND_INSTANTIATE,
 505       (void(*)(void))drbg_hash_instantiate_wrapper },
 506     { OSSL_FUNC_RAND_UNINSTANTIATE,
 507       (void(*)(void))drbg_hash_uninstantiate_wrapper },
 508     { OSSL_FUNC_RAND_GENERATE, (void(*)(void))drbg_hash_generate_wrapper },
 509     { OSSL_FUNC_RAND_RESEED, (void(*)(void))drbg_hash_reseed_wrapper },
 510     { OSSL_FUNC_RAND_ENABLE_LOCKING, (void(*)(void))drbg_enable_locking },
 511     { OSSL_FUNC_RAND_LOCK, (void(*)(void))drbg_lock },
 512     { OSSL_FUNC_RAND_UNLOCK, (void(*)(void))drbg_unlock },
 513     { OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS,
 514       (void(*)(void))drbg_hash_settable_ctx_params },
 515     { OSSL_FUNC_RAND_SET_CTX_PARAMS, (void(*)(void))drbg_hash_set_ctx_params },
 516     { OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS,
 517       (void(*)(void))drbg_hash_gettable_ctx_params },
 518     { OSSL_FUNC_RAND_GET_CTX_PARAMS, (void(*)(void))drbg_hash_get_ctx_params },
 519     { OSSL_FUNC_RAND_VERIFY_ZEROIZATION,
 520       (void(*)(void))drbg_hash_verify_zeroization },
 521     { 0, NULL }
 522 };