chacha20: update to use improved parameter handling

Reviewed-by: Shane Lontis <shane.lontis@oracle.com>
Reviewed-by: Richard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/27847)

diff --git a/providers/implementations/ciphers/cipher_chacha20_poly1305.c.in b/providers/implementations/ciphers/cipher_chacha20_poly1305.c.in
index 60d0a044f94dc59fe7cf43760a4353516292e2b1..890f9ad75af8b81dd6a340940200d8526c4caf48 100644 (file)
--- a/providers/implementations/ciphers/cipher_chacha20_poly1305.c.in
+++ b/providers/implementations/ciphers/cipher_chacha20_poly1305.c.in
@@ -7,7 +7,7 @@
  * https://www.openssl.org/source/license.html
  */
 {-
-use OpenSSL::paramnames qw(produce_param_list);
+use OpenSSL::paramnames qw(produce_param_decoder);
 -}
 
 /* Dispatch functions for chacha20_poly1305 cipher */
@@ -17,7 +17,6 @@ use OpenSSL::paramnames qw(produce_param_list);
 #include "cipher_chacha20_poly1305.h"
 #include "prov/implementations.h"
 #include "prov/providercommon.h"
-#include "internal/param_names.h"
 
 #define CHACHA20_POLY1305_KEYLEN CHACHA_KEY_SIZE
 #define CHACHA20_POLY1305_BLKLEN 1
@@ -41,8 +40,6 @@ static OSSL_FUNC_cipher_settable_ctx_params_fn chacha20_poly1305_settable_ctx_pa
 #define chacha20_poly1305_gettable_params ossl_cipher_generic_gettable_params
 #define chacha20_poly1305_update chacha20_poly1305_cipher
 
-static int chacha20_poly1305_get_ctx_params_find_pidx(const char *);
-
 static void *chacha20_poly1305_newctx(void *provctx)
 {
     PROV_CHACHA20_POLY1305_CTX *ctx;
@@ -103,181 +100,164 @@ static int chacha20_poly1305_get_params(OSSL_PARAM params[])
                                           CHACHA20_POLY1305_IVLEN * 8);
 }
 
+{- produce_param_decoder('chacha20_poly1305_get_ctx_params',
+                         (['CIPHER_PARAM_KEYLEN',            'keylen', 'size_t'],
+                          ['CIPHER_PARAM_IVLEN',             'ivlen',  'size_t'],
+                          ['CIPHER_PARAM_AEAD_TAGLEN',       'taglen', 'size_t'],
+                          ['CIPHER_PARAM_AEAD_TAG',          'tag',    'octet_string'],
+                          ['CIPHER_PARAM_AEAD_TLS1_AAD_PAD', 'pad',    'size_t'],
+                         )); -}
+
 static int chacha20_poly1305_get_ctx_params(void *vctx, OSSL_PARAM params[])
 {
     PROV_CHACHA20_POLY1305_CTX *ctx = (PROV_CHACHA20_POLY1305_CTX *)vctx;
-    OSSL_PARAM *p;
+    struct chacha20_poly1305_get_ctx_params_st p;
 
-    for (p = params; p->key != NULL; p++)
-        switch (chacha20_poly1305_get_ctx_params_find_pidx(p->key)) {
-        default:
-            break;
+    p = chacha20_poly1305_get_ctx_params_decoder(params);
 
-        case PIDX_CIPHER_PARAM_IVLEN:
-            if (!OSSL_PARAM_set_size_t(p, CHACHA20_POLY1305_IVLEN)) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
-                return 0;
-            }
-            break;
+    if (p.ivlen != NULL
+            && !OSSL_PARAM_set_size_t(p.ivlen, CHACHA20_POLY1305_IVLEN)) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
+        return 0;
+    }
 
-        case PIDX_CIPHER_PARAM_KEYLEN:
-            if (!OSSL_PARAM_set_size_t(p, CHACHA20_POLY1305_KEYLEN)) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
-                return 0;
-            }
-            break;
+    if (p.keylen != NULL
+            && !OSSL_PARAM_set_size_t(p.keylen, CHACHA20_POLY1305_KEYLEN)) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
+        return 0;
+    }
 
-        case PIDX_CIPHER_PARAM_AEAD_TAGLEN:
-            if (!OSSL_PARAM_set_size_t(p, ctx->tag_len)) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
-                return 0;
-            }
-            break;
+    if (p.taglen != NULL
+            && !OSSL_PARAM_set_size_t(p.taglen, ctx->tag_len)) {
+        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
+        return 0;
+    }
 
-        case PIDX_CIPHER_PARAM_AEAD_TLS1_AAD_PAD:
-            if (!OSSL_PARAM_set_size_t(p, ctx->tls_aad_pad_sz)) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
-                return 0;
-            }
-            break;
+    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;
+    }
 
-        case PIDX_CIPHER_PARAM_AEAD_TAG:
-            if (p->data_type != OSSL_PARAM_OCTET_STRING) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
-                return 0;
-            }
-            if (!ctx->base.enc) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_SET);
-                return 0;
-            }
-            if (p->data_size == 0 || p->data_size > POLY1305_BLOCK_SIZE) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAG_LENGTH);
-                return 0;
-            }
-            memcpy(p->data, ctx->tag, p->data_size);
-            break;
+    if (p.tag != NULL) {
+        if (p.tag->data_type != OSSL_PARAM_OCTET_STRING) {
+            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
+            return 0;
         }
+        if (!ctx->base.enc) {
+            ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_SET);
+            return 0;
+        }
+        if (p.tag->data_size == 0 || p.tag->data_size > POLY1305_BLOCK_SIZE) {
+            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAG_LENGTH);
+            return 0;
+        }
+        memcpy(p.tag->data, ctx->tag, p.tag->data_size);
+    }
     return 1;
 }
 
-
-/* Machine generated by util/perl/OpenSSL/paramnames.pm */
-{- produce_param_list('static', 'chacha20_poly1305_known_gettable_ctx_params',
-                      'static', 'chacha20_poly1305_get_ctx_params_find_pidx',
-                      (['CIPHER_PARAM_KEYLEN',                  'size_t'],
-                       ['CIPHER_PARAM_IVLEN',                   'size_t'],
-                       ['CIPHER_PARAM_AEAD_TAGLEN',             'size_t'],
-                       ['CIPHER_PARAM_AEAD_TAG',                'octet_string'],
-                       ['CIPHER_PARAM_AEAD_TLS1_AAD_PAD',       'size_t'],
-                      )); -}
-/* End of machine generated */
-
 static const OSSL_PARAM *chacha20_poly1305_gettable_ctx_params
     (ossl_unused void *cctx, ossl_unused void *provctx)
 {
-    return chacha20_poly1305_known_gettable_ctx_params;
+    return chacha20_poly1305_get_ctx_params_ettable;
 }
 
-/* Machine generated by util/perl/OpenSSL/paramnames.pm */
-{- produce_param_list('static', 'chacha20_poly1305_known_settable_ctx_params',
-                      'static', 'chacha20_poly1305_set_ctx_params_find_pidx',
-                      (['CIPHER_PARAM_KEYLEN',                  'size_t'],
-                       ['CIPHER_PARAM_IVLEN',                   'size_t'],
-                       ['CIPHER_PARAM_AEAD_TAG',                'octet_string'],
-                       ['CIPHER_PARAM_AEAD_TLS1_AAD',           'octet_string'],
-                       ['CIPHER_PARAM_AEAD_TLS1_IV_FIXED',      'octet_string'],
-                      )); -}
-/* End of machine generated */
+{- produce_param_decoder('chacha20_poly1305_set_ctx_params',
+                         (['CIPHER_PARAM_KEYLEN',             'keylen', 'size_t'],
+                          ['CIPHER_PARAM_IVLEN',              'ivlen',  'size_t'],
+                          ['CIPHER_PARAM_AEAD_TAG',           'tag',    'octet_string'],
+                          ['CIPHER_PARAM_AEAD_TLS1_AAD',      'aad',    'octet_string'],
+                          ['CIPHER_PARAM_AEAD_TLS1_IV_FIXED', 'fixed',  'octet_string'],
+                         )); -}
 
 static const OSSL_PARAM *chacha20_poly1305_settable_ctx_params(
         ossl_unused void *cctx, ossl_unused void *provctx
     )
 {
-    return chacha20_poly1305_known_settable_ctx_params;
+    return chacha20_poly1305_set_ctx_params_ettable;
 }
 
 static int chacha20_poly1305_set_ctx_params(void *vctx,
                                             const OSSL_PARAM params[])
 {
-    const OSSL_PARAM *p;
     size_t len;
     PROV_CHACHA20_POLY1305_CTX *ctx = (PROV_CHACHA20_POLY1305_CTX *)vctx;
     PROV_CIPHER_HW_CHACHA20_POLY1305 *hw =
         (PROV_CIPHER_HW_CHACHA20_POLY1305 *)ctx->base.hw;
+    struct chacha20_poly1305_set_ctx_params_st p;
 
     if (ossl_param_is_empty(params))
         return 1;
 
-    for (p = params; p->key != NULL; p++)
-        switch (chacha20_poly1305_set_ctx_params_find_pidx(p->key)) {
-        default:
-            break;
+    p = chacha20_poly1305_set_ctx_params_decoder(params);
 
-        case PIDX_CIPHER_PARAM_KEYLEN:
-            if (!OSSL_PARAM_get_size_t(p, &len)) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
-                return 0;
-            }
-            if (len != CHACHA20_POLY1305_KEYLEN) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
-                return 0;
-            }
-            break;
 
-        case PIDX_CIPHER_PARAM_IVLEN:
-            if (!OSSL_PARAM_get_size_t(p, &len)) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
-                return 0;
-            }
-            if (len != CHACHA20_POLY1305_MAX_IVLEN) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
-                return 0;
-            }
-            break;
+    if (p.keylen != NULL) {
+        if (!OSSL_PARAM_get_size_t(p.keylen, &len)) {
+            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
+            return 0;
+        }
+        if (len != CHACHA20_POLY1305_KEYLEN) {
+            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH);
+            return 0;
+        }
+    }
 
-        case PIDX_CIPHER_PARAM_AEAD_TAG:
-            if (p->data_type != OSSL_PARAM_OCTET_STRING) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
-                return 0;
-            }
-            if (p->data_size == 0 || p->data_size > POLY1305_BLOCK_SIZE) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAG_LENGTH);
-                return 0;
-            }
-            if (p->data != NULL) {
-                if (ctx->base.enc) {
-                    ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_NEEDED);
-                    return 0;
-                }
-                memcpy(ctx->tag, p->data, p->data_size);
-            }
-            ctx->tag_len = p->data_size;
-            break;
+    if (p.ivlen != NULL) {
+        if (!OSSL_PARAM_get_size_t(p.ivlen, &len)) {
+            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
+            return 0;
+        }
+        if (len != CHACHA20_POLY1305_MAX_IVLEN) {
+            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
+            return 0;
+        }
+    }
 
-        case PIDX_CIPHER_PARAM_AEAD_TLS1_AAD:
-            if (p->data_type != OSSL_PARAM_OCTET_STRING) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
-                return 0;
-            }
-            len = hw->tls_init(&ctx->base, p->data, p->data_size);
-            if (len == 0) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_DATA);
+    if (p.tag != NULL) {
+        if (p.tag->data_type != OSSL_PARAM_OCTET_STRING) {
+            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
+            return 0;
+        }
+        if (p.tag->data_size == 0 || p.tag->data_size > POLY1305_BLOCK_SIZE) {
+            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_TAG_LENGTH);
+            return 0;
+        }
+        if (p.tag->data != NULL) {
+            if (ctx->base.enc) {
+                ERR_raise(ERR_LIB_PROV, PROV_R_TAG_NOT_NEEDED);
                 return 0;
             }
-            ctx->tls_aad_pad_sz = len;
-            break;
+            memcpy(ctx->tag, p.tag->data, p.tag->data_size);
+        }
+        ctx->tag_len = p.tag->data_size;
+    }
 
-        case PIDX_CIPHER_PARAM_AEAD_TLS1_IV_FIXED:
-            if (p->data_type != OSSL_PARAM_OCTET_STRING) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
-                return 0;
-            }
-            if (hw->tls_iv_set_fixed(&ctx->base, p->data, p->data_size) == 0) {
-                ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
-                return 0;
-            }
-            break;
+    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;
+        }
+        len = hw->tls_init(&ctx->base, p.aad->data, p.aad->data_size);
+        if (len == 0) {
+            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_DATA);
+            return 0;
+        }
+        ctx->tls_aad_pad_sz = len;
+    }
+
+    if (p.fixed != NULL) {
+        if (p.fixed->data_type != OSSL_PARAM_OCTET_STRING) {
+            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
+            return 0;
         }
+        if (hw->tls_iv_set_fixed(&ctx->base, p.fixed->data,
+                                 p.fixed->data_size) == 0) {
+            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_IV_LENGTH);
+            return 0;
+        }
+    }
     return 1;
 }