test rand: update to use generated param handling

Reviewed-by: Paul Yang <paulyang.inf@gmail.com>
Reviewed-by: Shane Lontis <shane.lontis@oracle.com>
Reviewed-by: Matt Caswell <matt@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/28143)

diff --git a/providers/implementations/rands/test_rng.c.in b/providers/implementations/rands/test_rng.c.in
index aa407806fbbec19db86e188f6d0825320c24bb16..3c76c3fea106d134c50b0281d788d0abd8b8d26c 100644 (file)
--- a/providers/implementations/rands/test_rng.c.in
+++ b/providers/implementations/rands/test_rng.c.in
@@ -6,6 +6,9 @@
  * in the file LICENSE in the source distribution or at
  * https://www.openssl.org/source/license.html
  */
+{-
+use OpenSSL::paramnames qw(produce_param_decoder);
+-}
 
 #include <string.h>
 #include <stdlib.h>
@@ -15,7 +18,9 @@
 #include <openssl/core_names.h>
 #include <openssl/evp.h>
 #include <openssl/err.h>
+#include <openssl/proverr.h>
 #include <openssl/randerr.h>
+#include "internal/common.h"
 #include "prov/securitycheck.h"
 #include "prov/providercommon.h"
 #include "prov/provider_ctx.h"
@@ -180,66 +185,71 @@ static size_t test_rng_nonce(void *vtest, unsigned char *out,
     return i;
 }
 
+{- produce_param_decoder('test_rng_get_ctx_params',
+                         (['RAND_PARAM_STATE',                   'state',  'int'],
+                          ['RAND_PARAM_STRENGTH',                'str',    'uint'],
+                          ['RAND_PARAM_MAX_REQUEST',             'maxreq', 'size_t'],
+                          ['RAND_PARAM_GENERATE',                'gen',    'uint'],
+                          ['RAND_PARAM_FIPS_APPROVED_INDICATOR', 'ind',    'int'],
+                         )); -}
+
 static int test_rng_get_ctx_params(void *vtest, OSSL_PARAM params[])
 {
     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
-    OSSL_PARAM *p;
+    struct test_rng_get_ctx_params_st p;
 
-    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STATE);
-    if (p != NULL && !OSSL_PARAM_set_int(p, t->state))
+    if (t == NULL || !test_rng_get_ctx_params_decoder(params, &p))
         return 0;
 
-    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_STRENGTH);
-    if (p != NULL && !OSSL_PARAM_set_int(p, t->strength))
+    if (p.state != NULL && !OSSL_PARAM_set_int(p.state, t->state))
         return 0;
 
-    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_MAX_REQUEST);
-    if (p != NULL && !OSSL_PARAM_set_size_t(p, t->max_request))
+    if (p.str != NULL && !OSSL_PARAM_set_uint(p.str, t->strength))
         return 0;
 
-    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_GENERATE);
-    if (p != NULL && !OSSL_PARAM_set_uint(p, t->generate))
+    if (p.maxreq != NULL && !OSSL_PARAM_set_size_t(p.maxreq, t->max_request))
         return 0;
 
-#ifdef FIPS_MODULE
-    p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR);
-    if (p != NULL && !OSSL_PARAM_set_int(p, 0))
+    if (p.gen != NULL && !OSSL_PARAM_set_uint(p.gen, t->generate))
         return 0;
+
+#ifdef FIPS_MODULE
+    if (p.ind != NULL && !OSSL_PARAM_set_int(p.ind, 0))
+         return 0;
 #endif  /* FIPS_MODULE */
+
     return 1;
 }
 
 static const OSSL_PARAM *test_rng_gettable_ctx_params(ossl_unused void *vtest,
                                                       ossl_unused void *provctx)
 {
-    static const OSSL_PARAM known_gettable_ctx_params[] = {
-        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_uint(OSSL_RAND_PARAM_GENERATE, NULL),
-        OSSL_FIPS_IND_GETTABLE_CTX_PARAM()
-        OSSL_PARAM_END
-    };
-    return known_gettable_ctx_params;
+    return test_rng_get_ctx_params_list;
 }
 
+{- produce_param_decoder('test_rng_set_ctx_params',
+                         (['RAND_PARAM_TEST_ENTROPY',   'ent',    'octet_string'],
+                          ['RAND_PARAM_TEST_NONCE',     'nonce',  'octet_string'],
+                          ['RAND_PARAM_STRENGTH',       'str',    'uint'],
+                          ['RAND_PARAM_MAX_REQUEST',    'maxreq', 'size_t'],
+                          ['RAND_PARAM_GENERATE',       'gen',    'uint'],
+                         )); -}
+
 static int test_rng_set_ctx_params(void *vtest, const OSSL_PARAM params[])
 {
     PROV_TEST_RNG *t = (PROV_TEST_RNG *)vtest;
-    const OSSL_PARAM *p;
+    struct test_rng_set_ctx_params_st p;
     void *ptr = NULL;
     size_t size = 0;
 
-    if (ossl_param_is_empty(params))
-        return 1;
+    if (t == NULL || !test_rng_set_ctx_params_decoder(params, &p))
+        return 0;
 
-    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_STRENGTH);
-    if (p != NULL && !OSSL_PARAM_get_uint(p, &t->strength))
+    if (p.str != NULL && !OSSL_PARAM_get_uint(p.str, &t->strength))
         return 0;
 
-    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_ENTROPY);
-    if (p != NULL) {
-        if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size))
+    if (p.ent != NULL) {
+        if (!OSSL_PARAM_get_octet_string(p.ent, &ptr, 0, &size))
             return 0;
         OPENSSL_free(t->entropy);
         t->entropy = ptr;
@@ -248,21 +258,18 @@ static int test_rng_set_ctx_params(void *vtest, const OSSL_PARAM params[])
         ptr = NULL;
     }
 
-    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_TEST_NONCE);
-    if (p != NULL) {
-        if (!OSSL_PARAM_get_octet_string(p, &ptr, 0, &size))
+    if (p.nonce != NULL) {
+        if (!OSSL_PARAM_get_octet_string(p.nonce, &ptr, 0, &size))
             return 0;
         OPENSSL_free(t->nonce);
         t->nonce = ptr;
         t->nonce_len = size;
     }
 
-    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_MAX_REQUEST);
-    if (p != NULL && !OSSL_PARAM_get_size_t(p, &t->max_request))
+    if (p.maxreq != NULL && !OSSL_PARAM_get_size_t(p.maxreq, &t->max_request))
         return 0;
 
-    p = OSSL_PARAM_locate_const(params, OSSL_RAND_PARAM_GENERATE);
-    if (p != NULL && !OSSL_PARAM_get_uint(p, &t->generate))
+    if (p.gen != NULL && !OSSL_PARAM_get_uint(p.gen, &t->generate))
         return 0;
     return 1;
 }
@@ -270,15 +277,7 @@ static int test_rng_set_ctx_params(void *vtest, const OSSL_PARAM params[])
 static const OSSL_PARAM *test_rng_settable_ctx_params(ossl_unused void *vtest,
                                                       ossl_unused void *provctx)
 {
-    static const OSSL_PARAM known_settable_ctx_params[] = {
-        OSSL_PARAM_octet_string(OSSL_RAND_PARAM_TEST_ENTROPY, NULL, 0),
-        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_uint(OSSL_RAND_PARAM_GENERATE, NULL),
-        OSSL_PARAM_END
-    };
-    return known_settable_ctx_params;
+    return test_rng_set_ctx_params_list;
 }
 
 static int test_rng_verify_zeroization(ossl_unused void *vtest)