legacy ciphers: use generated param name decoders

Reviewed-by: Shane Lontis <shane.lontis@oracle.com>
Reviewed-by: Tomas Mraz <tomas@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/28616)

diff --git a/providers/implementations/ciphers/build.info b/providers/implementations/ciphers/build.info
index 7351766eb3f9dbbc1d9d713ca67d43c924364ca1..624bbb605e3a0a3541456fb64db920fc9ce27667 100644 (file)
--- a/providers/implementations/ciphers/build.info
+++ b/providers/implementations/ciphers/build.info
@@ -91,8 +91,7 @@ SOURCE[$COMMON_GOAL]=\
         ciphercommon_ccm.c ciphercommon_ccm_hw.c
 
 INCLUDE[cipher_aes_cbc_hmac_sha.o cipher_aes_cbc_hmac_sha_etm.o \
-        ciphercommon.o cipher_chacha20_poly1305.o \
-        cipher_des.o cipher_rc2.o cipher_rc4_hmac_md5.o cipher_rc5.o]=.
+        ciphercommon.o cipher_chacha20_poly1305.o cipher_rc4_hmac_md5.o]=.
 
 IF[{- !$disabled{des} -}]
   SOURCE[$TDES_1_GOAL]=cipher_tdes.c cipher_tdes_common.c cipher_tdes_hw.c

diff --git a/providers/implementations/ciphers/cipher_null.c.in b/providers/implementations/ciphers/cipher_null.c.in
index 7e934093ce5aaaaad356833310ba40ac0c0030f4..3a64dfe646be7f9c2e031e19ecf271670318914f 100644 (file)
--- a/providers/implementations/ciphers/cipher_null.c.in
+++ b/providers/implementations/ciphers/cipher_null.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 <openssl/crypto.h>
@@ -105,55 +108,55 @@ static int null_get_params(OSSL_PARAM params[])
     return ossl_cipher_generic_get_params(params, 0, 0, 0, 8, 0);
 }
 
-static const OSSL_PARAM null_known_gettable_ctx_params[] = {
-    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
-    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
-    { OSSL_CIPHER_PARAM_TLS_MAC, OSSL_PARAM_OCTET_PTR, NULL, 0, OSSL_PARAM_UNMODIFIED },
-    OSSL_PARAM_END
-};
+{- produce_param_decoder('null_get_ctx_params',
+                         (['OSSL_CIPHER_PARAM_KEYLEN',  'keylen', 'size_t'],
+                          ['OSSL_CIPHER_PARAM_IVLEN',   'ivlen',  'size_t'],
+                          ['OSSL_CIPHER_PARAM_TLS_MAC', 'mac',    'octet_ptr'],
+                         )); -}
 
 static OSSL_FUNC_cipher_gettable_ctx_params_fn null_gettable_ctx_params;
 static const OSSL_PARAM *null_gettable_ctx_params(ossl_unused void *cctx,
                                                   ossl_unused void *provctx)
 {
-    return null_known_gettable_ctx_params;
+    return null_get_ctx_params_list;
 }
 
 static OSSL_FUNC_cipher_get_ctx_params_fn null_get_ctx_params;
 static int null_get_ctx_params(void *vctx, OSSL_PARAM params[])
 {
     PROV_CIPHER_NULL_CTX *ctx = (PROV_CIPHER_NULL_CTX *)vctx;
-    OSSL_PARAM *p;
+    struct null_get_ctx_params_st p;
+
+    if (ctx == NULL || !null_get_ctx_params_decoder(params, &p))
+        return 0;
 
-    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
-    if (p != NULL && !OSSL_PARAM_set_size_t(p, 0)) {
+    if (p.ivlen != NULL && !OSSL_PARAM_set_size_t(p.ivlen, 0)) {
         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
         return 0;
     }
-    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
-    if (p != NULL && !OSSL_PARAM_set_size_t(p, 0)) {
+
+    if (p.keylen != NULL && !OSSL_PARAM_set_size_t(p.keylen, 0)) {
         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
         return 0;
     }
-    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_TLS_MAC);
-    if (p != NULL
-        && !OSSL_PARAM_set_octet_ptr(p, ctx->tlsmac, ctx->tlsmacsize)) {
+
+    if (p.mac != NULL
+        && !OSSL_PARAM_set_octet_ptr(p.mac, ctx->tlsmac, ctx->tlsmacsize)) {
         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
         return 0;
     }
     return 1;
 }
 
-static const OSSL_PARAM null_known_settable_ctx_params[] = {
-    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL),
-    OSSL_PARAM_END
-};
+{- produce_param_decoder('null_set_ctx_params',
+                         (['OSSL_CIPHER_PARAM_TLS_MAC_SIZE', 'macsize', 'size_t'],
+                         )); -}
 
 static OSSL_FUNC_cipher_settable_ctx_params_fn null_settable_ctx_params;
 static const OSSL_PARAM *null_settable_ctx_params(ossl_unused void *cctx,
                                                   ossl_unused void *provctx)
 {
-    return null_known_settable_ctx_params;
+    return null_set_ctx_params_list;
 }
 
 
@@ -161,14 +164,15 @@ static OSSL_FUNC_cipher_set_ctx_params_fn null_set_ctx_params;
 static int null_set_ctx_params(void *vctx, const OSSL_PARAM params[])
 {
     PROV_CIPHER_NULL_CTX *ctx = (PROV_CIPHER_NULL_CTX *)vctx;
-    const OSSL_PARAM *p;
+    struct null_set_ctx_params_st p;
 
-    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS_MAC_SIZE);
-    if (p != NULL) {
-        if (!OSSL_PARAM_get_size_t(p, &ctx->tlsmacsize)) {
-            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
-            return 0;
-        }
+    if (ctx == NULL || !null_set_ctx_params_decoder(params, &p))
+        return 0;
+
+    if (p.macsize != NULL
+            && !OSSL_PARAM_get_size_t(p.macsize, &ctx->tlsmacsize)) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
+        return 0;
     }
 
     return 1;

diff --git a/providers/implementations/ciphers/cipher_rc4_hmac_md5.c.in b/providers/implementations/ciphers/cipher_rc4_hmac_md5.c.in
index ec18777143bbad5b05d38f44e8b131cb8921c126..1685aba70247248bc107bce6c601bd910e91cebe 100644 (file)
--- a/providers/implementations/ciphers/cipher_rc4_hmac_md5.c.in
+++ b/providers/implementations/ciphers/cipher_rc4_hmac_md5.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);
+-}
 
 /* Dispatch functions for RC4_HMAC_MD5 cipher */
 
@@ -99,66 +102,68 @@ static int rc4_hmac_md5_dinit(void *ctx, const unsigned char *key,
     return rc4_hmac_md5_set_ctx_params(ctx, params);
 }
 
-static const OSSL_PARAM rc4_hmac_md5_known_gettable_ctx_params[] = {
-    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
-    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
-    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL),
-    OSSL_PARAM_END
-};
-const OSSL_PARAM *rc4_hmac_md5_gettable_ctx_params(ossl_unused void *cctx,
-                                                   ossl_unused void *provctx)
+{- produce_param_decoder('rc4_hmac_md5_get_ctx_params',
+                         (['OSSL_CIPHER_PARAM_KEYLEN',            'keylen', 'size_t'],
+                          ['OSSL_CIPHER_PARAM_IVLEN',             'ivlen',  'size_t'],
+                          ['OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD', 'pad',    'size_t'],
+                         )); -}
+
+static const OSSL_PARAM *rc4_hmac_md5_gettable_ctx_params(ossl_unused void *cctx,
+                                                          ossl_unused void *provctx)
 {
-    return rc4_hmac_md5_known_gettable_ctx_params;
+    return rc4_hmac_md5_get_ctx_params_list;
 }
 
 static int rc4_hmac_md5_get_ctx_params(void *vctx, OSSL_PARAM params[])
 {
     PROV_RC4_HMAC_MD5_CTX *ctx = (PROV_RC4_HMAC_MD5_CTX *)vctx;
-    OSSL_PARAM *p;
+    struct rc4_hmac_md5_get_ctx_params_st p;
+
+    if (ctx == NULL || !rc4_hmac_md5_get_ctx_params_decoder(params, &p))
+        return 0;
 
-    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_KEYLEN);
-    if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->base.keylen)) {
+    if (p.keylen != NULL && !OSSL_PARAM_set_size_t(p.keylen, ctx->base.keylen)) {
         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
         return 0;
     }
 
-    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_IVLEN);
-    if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->base.ivlen)) {
+    if (p.ivlen != NULL && !OSSL_PARAM_set_size_t(p.ivlen, ctx->base.ivlen)) {
         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
         return 0;
     }
-    p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD);
-    if (p != NULL && !OSSL_PARAM_set_size_t(p, ctx->tls_aad_pad_sz)) {
+
+    if (p.pad != NULL && !OSSL_PARAM_set_size_t(p.pad, ctx->tls_aad_pad_sz)) {
         ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
         return 0;
     }
     return 1;
 }
 
-static const OSSL_PARAM rc4_hmac_md5_known_settable_ctx_params[] = {
-    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
-    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
-    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0),
-    OSSL_PARAM_END
-};
-const OSSL_PARAM *rc4_hmac_md5_settable_ctx_params(ossl_unused void *cctx,
-                                                   ossl_unused void *provctx)
+{- produce_param_decoder('rc4_hmac_md5_set_ctx_params',
+                         (['OSSL_CIPHER_PARAM_KEYLEN',        'keylen', 'size_t'],
+                          ['OSSL_CIPHER_PARAM_IVLEN',         'ivlen',  'size_t'],
+                          ['OSSL_CIPHER_PARAM_AEAD_TLS1_AAD', 'aad',    'octet_string'],
+                          ['OSSL_CIPHER_PARAM_AEAD_MAC_KEY',  'mackey', 'octet_string'],
+                          ['OSSL_CIPHER_PARAM_TLS_VERSION',   'tlsver', 'uint'],
+                         )); -}
+
+static const OSSL_PARAM *rc4_hmac_md5_settable_ctx_params(ossl_unused void *cctx,
+                                                          ossl_unused void *provctx)
 {
-    return rc4_hmac_md5_known_settable_ctx_params;
+    return rc4_hmac_md5_set_ctx_params_list;
 }
 
 static int rc4_hmac_md5_set_ctx_params(void *vctx, const OSSL_PARAM params[])
 {
     PROV_RC4_HMAC_MD5_CTX *ctx = (PROV_RC4_HMAC_MD5_CTX *)vctx;
-    const OSSL_PARAM *p;
+    struct rc4_hmac_md5_set_ctx_params_st p;
     size_t sz;
 
-    if (ossl_param_is_empty(params))
-        return 1;
+    if (ctx == NULL || !rc4_hmac_md5_set_ctx_params_decoder(params, &p))
+        return 0;
 
-    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_KEYLEN);
-    if (p != NULL) {
-        if (!OSSL_PARAM_get_size_t(p, &sz)) {
+   if (p.keylen != NULL) {
+        if (!OSSL_PARAM_get_size_t(p.keylen, &sz)) {
             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
             return 0;
         }
@@ -168,9 +173,8 @@ static int rc4_hmac_md5_set_ctx_params(void *vctx, const OSSL_PARAM params[])
         }
     }
 
-    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_IVLEN);
-    if (p != NULL) {
-        if (!OSSL_PARAM_get_size_t(p, &sz)) {
+    if (p.ivlen != NULL) {
+        if (!OSSL_PARAM_get_size_t(p.ivlen, &sz)) {
             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
             return 0;
         }
@@ -180,33 +184,32 @@ static int rc4_hmac_md5_set_ctx_params(void *vctx, const OSSL_PARAM params[])
         }
     }
 
-    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_TLS1_AAD);
-    if (p != NULL) {
-        if (p->data_type != OSSL_PARAM_OCTET_STRING) {
+    if (p.aad != NULL) {
+        if (p.aad->data_type != OSSL_PARAM_OCTET_STRING) {
             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
             return 0;
         }
-        sz = GET_HW(ctx)->tls_init(&ctx->base, p->data, p->data_size);
+        sz = GET_HW(ctx)->tls_init(&ctx->base, p.aad->data, p.aad->data_size);
         if (sz == 0) {
             ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_DATA);
             return 0;
         }
         ctx->tls_aad_pad_sz = sz;
     }
-    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_AEAD_MAC_KEY);
-    if (p != NULL) {
-        if (p->data_type != OSSL_PARAM_OCTET_STRING) {
+
+    if (p.mackey != NULL) {
+        if (p.mackey->data_type != OSSL_PARAM_OCTET_STRING) {
             ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
             return 0;
         }
-        GET_HW(ctx)->init_mackey(&ctx->base, p->data, p->data_size);
+        GET_HW(ctx)->init_mackey(&ctx->base, p.mackey->data,
+                                 p.mackey->data_size);
     }
-    p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_TLS_VERSION);
-    if (p != NULL) {
-        if (!OSSL_PARAM_get_uint(p, &ctx->base.tlsversion)) {
-            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
-            return 0;
-        }
+
+    if (p.tlsver != NULL
+            && !OSSL_PARAM_get_uint(p.tlsver, &ctx->base.tlsversion)) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
+        return 0;
     }
 
     return 1;