disassociate test RNG from the DRBGs

Reviewed-by: Matt Caswell <matt@openssl.org>
Reviewed-by: Matthias St. Pierre <Matthias.St.Pierre@ncp-e.com>
(Merged from https://github.com/openssl/openssl/pull/13226)

1 files changed, 120 insertions, 161 deletions

diff --git a/providers/implementations/rands/test_rng.c b/providers/implementations/rands/test_rng.c
index e35554b56b..3f3ab236f9 100644
--- a/providers/implementations/rands/test_rng.c
+++ b/providers/implementations/rands/test_rng.c
@@ -11,114 +11,102 @@
 #include <openssl/core_dispatch.h>
 #include <openssl/e_os2.h>
 #include <openssl/params.h>
+#include <openssl/core_names.h>
+#include <openssl/evp.h>
+#include <openssl/err.h>
+#include <openssl/randerr.h>
 #include "prov/providercommon.h"
 #include "prov/provider_ctx.h"
 #include "prov/provider_util.h"
 #include "prov/implementations.h"
-#include "drbg_local.h"
 
-static OSSL_FUNC_rand_newctx_fn test_rng_new_wrapper;
+static OSSL_FUNC_rand_newctx_fn test_rng_new;
 static OSSL_FUNC_rand_freectx_fn test_rng_free;
-static OSSL_FUNC_rand_instantiate_fn test_rng_instantiate_wrapper;
-static OSSL_FUNC_rand_uninstantiate_fn test_rng_uninstantiate_wrapper;
-static OSSL_FUNC_rand_generate_fn test_rng_generate_wrapper;
-static OSSL_FUNC_rand_reseed_fn test_rng_reseed_wrapper;
+static OSSL_FUNC_rand_instantiate_fn test_rng_instantiate;
+static OSSL_FUNC_rand_uninstantiate_fn test_rng_uninstantiate;
+static OSSL_FUNC_rand_generate_fn test_rng_generate;
+static OSSL_FUNC_rand_reseed_fn test_rng_reseed;
 static OSSL_FUNC_rand_nonce_fn test_rng_nonce;
 static OSSL_FUNC_rand_settable_ctx_params_fn test_rng_settable_ctx_params;
 static OSSL_FUNC_rand_set_ctx_params_fn test_rng_set_ctx_params;
 static OSSL_FUNC_rand_gettable_ctx_params_fn test_rng_gettable_ctx_params;
 static OSSL_FUNC_rand_get_ctx_params_fn test_rng_get_ctx_params;
 static OSSL_FUNC_rand_verify_zeroization_fn test_rng_verify_zeroization;
+static OSSL_FUNC_rand_enable_locking_fn test_rng_enable_locking;
+static OSSL_FUNC_rand_lock_fn test_rng_lock;
+static OSSL_FUNC_rand_unlock_fn test_rng_unlock;
 
 typedef struct {
+    void *provctx;
+    int state;
+    unsigned int strength;
+    size_t max_request;
     unsigned char *entropy, *nonce;
     size_t entropy_len, entropy_pos, nonce_len;
-    unsigned int strength;
+    CRYPTO_RWLOCK *lock;
 } PROV_TEST_RNG;
 
-static int test_rng_new(PROV_DRBG *ctx)
+static void *test_rng_new(void *provctx, void *parent,
+                          const OSSL_DISPATCH *parent_dispatch)
 {
     PROV_TEST_RNG *t;
 
+    if (parent != NULL)
+        return NULL;
+
     t = OPENSSL_zalloc(sizeof(*t));
     if (t == NULL)
-        return 0;
-    ctx->data = t;
-    ctx->seedlen = INT_MAX;
-    ctx->max_entropylen = INT_MAX;
-    ctx->max_noncelen = INT_MAX;
-    ctx->max_perslen = INT_MAX;
-    ctx->max_adinlen = INT_MAX;
-    ctx->max_request = INT_MAX;
-    return 1;
+        return NULL;
+
+    t->max_request = INT_MAX;
+    t->provctx = provctx;
+    t->state = EVP_RAND_STATE_UNINITIALISED;
+    return t;
 }
 
-static void test_rng_free(void *vdrbg)
+static void test_rng_free(void *vtest)
 {
-    PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
-    PROV_TEST_RNG *t = (PROV_TEST_RNG *)drbg->data;
+    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 
+    if (t == NULL)
+        return;
     OPENSSL_free(t->entropy);
     OPENSSL_free(t->nonce);
-    OPENSSL_free(drbg->data);
-    ossl_rand_drbg_free(drbg);
+    CRYPTO_THREAD_lock_free(t->lock);
+    OPENSSL_free(t);
 }
 
-static int test_rng_instantiate(PROV_DRBG *drbg,
-                                const unsigned char *ent, size_t ent_len,
-                                const unsigned char *nonce, size_t nonce_len,
+static int test_rng_instantiate(void *vtest, unsigned int strength,
+                                int prediction_resistance,
                                 const unsigned char *pstr, size_t pstr_len)
 {
-    PROV_TEST_RNG *t = (PROV_TEST_RNG *)drbg->data;
+    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 
-    if (ent != NULL && (ent_len < drbg->min_entropylen
-                        || ent_len >= drbg->max_entropylen))
-        return 0;
-    if (nonce != NULL && (nonce_len < drbg->min_noncelen
-                        || nonce_len >= drbg->max_noncelen))
-        return 0;
-    if (pstr != NULL && pstr_len >= drbg->max_perslen)
+    if (strength > t->strength)
         return 0;
 
+    t->state = EVP_RAND_STATE_READY;
     t->entropy_pos = 0;
-    return 1;
-}
-
-static int test_rng_instantiate_wrapper(void *vdrbg, unsigned int strength,
-                                        int prediction_resistance,
-                                        const unsigned char *pstr,
-                                        size_t pstr_len)
-{
-    PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
-
-    if (pstr != NULL && pstr_len >= drbg->max_perslen)
-        return 0;
 
-    return ossl_prov_drbg_instantiate(drbg, strength, prediction_resistance,
-                                      pstr, pstr_len);
+    return 1;
 }
 
-static int test_rng_uninstantiate(PROV_DRBG *drbg)
+static int test_rng_uninstantiate(void *vtest)
 {
-    PROV_TEST_RNG *t = (PROV_TEST_RNG *)drbg->data;
+    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 
     t->entropy_pos = 0;
-    return ossl_prov_drbg_uninstantiate(drbg);
-}
-
-static int test_rng_uninstantiate_wrapper(void *vdrbg)
-{
-    return test_rng_uninstantiate((PROV_DRBG *)vdrbg);
+    return 1;
 }
 
-static int test_rng_generate(PROV_DRBG *drbg,
-                             unsigned char *out, size_t outlen,
+static int test_rng_generate(void *vtest, unsigned char *out, size_t outlen,
+                             unsigned int strength, int prediction_resistance,
                              const unsigned char *adin, size_t adin_len)
 {
-    PROV_TEST_RNG *t = (PROV_TEST_RNG *)drbg->data;
+    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
     size_t i;
 
-    if (t->entropy == NULL || (adin != NULL && adin_len >= drbg->max_adinlen))
+    if (strength > t->strength)
         return 0;
 
     for (i = 0; i < outlen; i++) {
@@ -129,49 +117,24 @@ static int test_rng_generate(PROV_DRBG *drbg,
     return 1;
 }
 
-static int test_rng_generate_wrapper
-    (void *vdrbg, unsigned char *out, size_t outlen,
-      unsigned int strength, int prediction_resistance,
-      const unsigned char *adin, size_t adin_len)
+static int test_rng_reseed(ossl_unused void *vtest,
+                           ossl_unused int prediction_resistance,
+                           ossl_unused const unsigned char *ent,
+                           ossl_unused size_t ent_len,
+                           ossl_unused const unsigned char *adin,
+                           ossl_unused size_t adin_len)
 {
-    PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
-
-    if (strength > drbg->strength)
-        return 0;
-    return test_rng_generate(drbg, out, outlen, adin, adin_len);
-}
-
-static int test_rng_reseed(PROV_DRBG *drbg,
-                            const unsigned char *ent, size_t ent_len,
-                            const unsigned char *adin, size_t adin_len)
-{
-    if (ent != NULL && (ent_len < drbg->min_entropylen
-                        || ent_len >= drbg->max_entropylen))
-        return 0;
-    if (adin != NULL && adin_len >= drbg->max_adinlen)
-        return 0;
-
     return 1;
 }
 
-static int test_rng_reseed_wrapper(void *vdrbg, int prediction_resistance,
-                                   const unsigned char *ent, size_t ent_len,
-                                   const unsigned char *adin, size_t adin_len)
-{
-    return test_rng_reseed((PROV_DRBG *)vdrbg, ent, ent_len, adin, adin_len);
-}
-
-static size_t test_rng_nonce(void *vdrbg, unsigned char *out,
-                             unsigned int strength, size_t min_noncelen,
-                             size_t max_noncelen)
+static size_t test_rng_nonce(void *vtest, unsigned char *out,
+                             unsigned int strength,
+                             ossl_unused size_t min_noncelen,
+                             ossl_unused size_t max_noncelen)
 {
-    PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
-    PROV_TEST_RNG *t = (PROV_TEST_RNG *)drbg->data;
+    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
 
-    if (t->nonce == NULL
-            || strength > drbg->strength
-            || min_noncelen > t->nonce_len
-            || max_noncelen < t->nonce_len)
+    if (t->nonce == NULL || strength > t->strength)
         return 0;
 
     if (out != NULL)
@@ -179,41 +142,45 @@ static size_t test_rng_nonce(void *vdrbg, unsigned char *out,
     return t->nonce_len;
 }
 
-static int test_rng_get_ctx_params(void *vdrbg, OSSL_PARAM params[])
+static int test_rng_get_ctx_params(void *vtest, OSSL_PARAM params[])
 {
-    PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
+    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
+    OSSL_PARAM *p;
 
-    return ossl_drbg_get_ctx_params(drbg, params);
+    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STATE);
+    if (p != NULL && !OSSL_PARAM_set_int(p, t->state))
+        return 0;
+
+    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STRENGTH);
+    if (p != NULL && !OSSL_PARAM_set_int(p, t->strength))
+        return 0;
+
+    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_MAX_REQUEST);
+    if (p != NULL && !OSSL_PARAM_set_size_t(p, t->max_request))
+        return 0;
+    return 1;
 }
 
 static const OSSL_PARAM *test_rng_gettable_ctx_params(ossl_unused void *provctx)
 {
     static const OSSL_PARAM known_gettable_ctx_params[] = {
-        OSSL_PARAM_DRBG_GETTABLE_CTX_COMMON,
+        OSSL_PARAM_int(OSSL_RAND_PARAM_STATE, NULL),
+        OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
+        OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
         OSSL_PARAM_END
     };
     return known_gettable_ctx_params;
 }
 
-static int set_size_t(const OSSL_PARAM *params, const char *name,
-                            size_t *val)
+static int test_rng_set_ctx_params(void *vtest, const OSSL_PARAM params[])
 {
-    const OSSL_PARAM *p = OSSL_PARAM_locate_const(params, name);
-
-    return p == NULL || OSSL_PARAM_get_size_t(p, val);
-}
-
-static int test_rng_set_ctx_params(void *vdrbg, const OSSL_PARAM params[])
-{
-    PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
-    PROV_TEST_RNG *t = (PROV_TEST_RNG *)drbg->data;
+    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
     const OSSL_PARAM *p;
     void *ptr = NULL;
     size_t size = 0;
-    unsigned int uint;
 
     p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_STRENGTH);
-    if (p != NULL && !OSSL_PARAM_get_uint(p, &drbg->strength))
+    if (p != NULL && !OSSL_PARAM_get_uint(p, &t->strength))
         return 0;
 
     p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_ENTROPY);
@@ -236,32 +203,11 @@ static int test_rng_set_ctx_params(void *vdrbg, const OSSL_PARAM params[])
         t->nonce_len = size;
     }
 
-    p = OSSL_PARAM_locate_const(params, OSSL_DRBG_PARAM_RESEED_COUNTER);
-    if (p != NULL) {
-        if (!OSSL_PARAM_get_uint(p, &uint))
-            return 0;
-        tsan_store(&drbg->reseed_counter, uint);
-    }
-
-    p = OSSL_PARAM_locate_const(params, OSSL_DRBG_PARAM_RESEED_TIME);
-    if (p != NULL && !OSSL_PARAM_get_time_t(p, &drbg->reseed_time))
+    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_MAX_REQUEST);
+    if (p != NULL  && !OSSL_PARAM_get_size_t(p, &t->max_request))
         return 0;
 
-    if (!set_size_t(params, OSSL_RAND_PARAM_MAX_REQUEST, &drbg->max_request)
-            || !set_size_t(params, OSSL_DRBG_PARAM_MIN_ENTROPYLEN,
-                           &drbg->min_entropylen)
-            || !set_size_t(params, OSSL_DRBG_PARAM_MAX_ENTROPYLEN,
-                           &drbg->max_entropylen)
-            || !set_size_t(params, OSSL_DRBG_PARAM_MIN_NONCELEN,
-                           &drbg->min_noncelen)
-            || !set_size_t(params, OSSL_DRBG_PARAM_MAX_NONCELEN,
-                           &drbg->max_noncelen)
-            || !set_size_t(params, OSSL_DRBG_PARAM_MAX_PERSLEN,
-                           &drbg->max_perslen)
-            || !set_size_t(params, OSSL_DRBG_PARAM_MAX_ADINLEN,
-                           &drbg->max_adinlen))
-        return 0;
-    return ossl_drbg_set_ctx_params(drbg, params);
+    return 1;
 }
 
 static const OSSL_PARAM *test_rng_settable_ctx_params(ossl_unused void *provctx)
@@ -271,47 +217,60 @@ static const OSSL_PARAM *test_rng_settable_ctx_params(ossl_unused void *provctx)
         OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_NONCE, NULL, 0),
         OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
         OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
-        OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MIN_ENTROPYLEN, NULL),
-        OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_ENTROPYLEN, NULL),
-        OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MIN_NONCELEN, NULL),
-        OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_NONCELEN, NULL),
-        OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_PERSLEN, NULL),
-        OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_ADINLEN, NULL),
-        OSSL_PARAM_uint(OSSL_DRBG_PARAM_RESEED_COUNTER, NULL),
-        OSSL_PARAM_time_t(OSSL_DRBG_PARAM_RESEED_TIME, NULL),
-        OSSL_PARAM_DRBG_SETTABLE_CTX_COMMON,
         OSSL_PARAM_END
     };
     return known_settable_ctx_params;
 }
 
-static int test_rng_verify_zeroization(void *vdrbg)
+static int test_rng_verify_zeroization(ossl_unused void *vtest)
 {
     return 1;
 }
 
-static void *test_rng_new_wrapper(void *provctx, void *parent,
-                                   const OSSL_DISPATCH *parent_dispatch)
+static int test_rng_enable_locking(void *vtest)
 {
-    return ossl_rand_drbg_new(provctx, parent, parent_dispatch,
-                              &test_rng_new, &test_rng_instantiate,
-                              &test_rng_uninstantiate, &test_rng_reseed,
-                              &test_rng_generate);
+    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
+
+    if (t != NULL && t->lock == NULL) {
+        t->lock = CRYPTO_THREAD_lock_new();
+        if (t->lock == NULL) {
+            ERR_raise(ERR_LIB_PROV, RAND_R_FAILED_TO_CREATE_LOCK);
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static int test_rng_lock(void *vtest)
+{
+    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
+
+    if (t == NULL || t->lock == NULL)
+        return 1;
+    return CRYPTO_THREAD_write_lock(t->lock);
+}
+
+static void test_rng_unlock(void *vtest)
+{
+    PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
+
+    if (t != NULL && t->lock != NULL)
+        CRYPTO_THREAD_unlock(t->lock);
 }
 
 const OSSL_DISPATCH ossl_test_rng_functions[] = {
-    { OSSL_FUNC_RAND_NEWCTX, (void(*)(void))test_rng_new_wrapper },
+    { OSSL_FUNC_RAND_NEWCTX, (void(*)(void))test_rng_new },
     { OSSL_FUNC_RAND_FREECTX, (void(*)(void))test_rng_free },
     { OSSL_FUNC_RAND_INSTANTIATE,
-      (void(*)(void))test_rng_instantiate_wrapper },
+      (void(*)(void))test_rng_instantiate },
     { OSSL_FUNC_RAND_UNINSTANTIATE,
-      (void(*)(void))test_rng_uninstantiate_wrapper },
-    { OSSL_FUNC_RAND_GENERATE, (void(*)(void))test_rng_generate_wrapper },
-    { OSSL_FUNC_RAND_RESEED, (void(*)(void))test_rng_reseed_wrapper },
+      (void(*)(void))test_rng_uninstantiate },
+    { OSSL_FUNC_RAND_GENERATE, (void(*)(void))test_rng_generate },
+    { OSSL_FUNC_RAND_RESEED, (void(*)(void))test_rng_reseed },
     { OSSL_FUNC_RAND_NONCE, (void(*)(void))test_rng_nonce },
-    { OSSL_FUNC_RAND_ENABLE_LOCKING, (void(*)(void))ossl_drbg_enable_locking },
-    { OSSL_FUNC_RAND_LOCK, (void(*)(void))ossl_drbg_lock },
-    { OSSL_FUNC_RAND_UNLOCK, (void(*)(void))ossl_drbg_unlock },
+    { OSSL_FUNC_RAND_ENABLE_LOCKING, (void(*)(void))test_rng_enable_locking },
+    { OSSL_FUNC_RAND_LOCK, (void(*)(void))test_rng_lock },
+    { OSSL_FUNC_RAND_UNLOCK, (void(*)(void))test_rng_unlock },
     { OSSL_FUNC_RAND_SETTABLE_CTX_PARAMS,
       (void(*)(void))test_rng_settable_ctx_params },
     { OSSL_FUNC_RAND_SET_CTX_PARAMS, (void(*)(void))test_rng_set_ctx_params },