]> git.ipfire.org Git - thirdparty/openssl.git/commitdiff
pkcs12kdf: convert to generated OSSL_PARAM parser
authorPauli <ppzgs1@gmail.com>
Wed, 2 Jul 2025 06:37:26 +0000 (16:37 +1000)
committerTomas Mraz <tomas@openssl.org>
Thu, 31 Jul 2025 18:20:48 +0000 (20:20 +0200)
Reviewed-by: Shane Lontis <shane.lontis@oracle.com>
Reviewed-by: Tomas Mraz <tomas@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/27923)

providers/implementations/kdfs/pkcs12kdf.c.in

index b4ca4fff475dcaa91ad405d798943b61f59cb3fb..80da82c60a518f683e59e9096afd4573356761e1 100644 (file)
@@ -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 <openssl/trace.h>
 #include <stdlib.h>
@@ -15,6 +18,7 @@
 #include <openssl/kdf.h>
 #include <openssl/core_names.h>
 #include <openssl/proverr.h>
+#include "internal/common.h"
 #include "internal/cryptlib.h"
 #include "internal/numbers.h"
 #include "crypto/evp.h"
@@ -239,68 +243,71 @@ static int kdf_pkcs12_derive(void *vctx, unsigned char *key, size_t keylen,
                             ctx->id, ctx->iter, md, key, keylen);
 }
 
+{- produce_param_decoder('pkcs12_set_ctx_params',
+                         (['KDF_PARAM_PROPERTIES',  'propq',    'utf8_string'],
+                          ['ALG_PARAM_ENGINE',      'engine',   'utf8_string'],
+                          ['KDF_PARAM_DIGEST',      'digest',   'utf8_string'],
+                          ['KDF_PARAM_PASSWORD',    'pw',       'octet_string'],
+                          ['KDF_PARAM_SALT',        'salt',     'octet_string'],
+                          ['KDF_PARAM_ITER',        'iter',     'uint64'],
+                          ['KDF_PARAM_PKCS12_ID',   'p12id',    'int'],
+                         )); -}
+
 static int kdf_pkcs12_set_ctx_params(void *vctx, const OSSL_PARAM params[])
 {
-    const OSSL_PARAM *p;
+    struct pkcs12_set_ctx_params_st p;
     KDF_PKCS12 *ctx = vctx;
     OSSL_LIB_CTX *provctx = PROV_LIBCTX_OF(ctx->provctx);
 
-    if (ossl_param_is_empty(params))
-        return 1;
+    if (ctx == NULL || !pkcs12_set_ctx_params_decoder(params, &p))
+        return 0;
 
-    if (!ossl_prov_digest_load_from_params(&ctx->digest, params, provctx))
+    if (!ossl_prov_digest_load(&ctx->digest, p.digest,
+                               p.propq, p.engine, provctx))
         return 0;
 
-    if ((p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_PASSWORD)) != NULL)
-        if (!pkcs12kdf_set_membuf(&ctx->pass, &ctx->pass_len, p))
-            return 0;
+    if (p.pw != NULL && !pkcs12kdf_set_membuf(&ctx->pass, &ctx->pass_len, p.pw))
+        return 0;
 
-    if ((p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_SALT)) != NULL)
-        if (!pkcs12kdf_set_membuf(&ctx->salt, &ctx->salt_len, p))
-            return 0;
+    if (p.salt != NULL
+            && !pkcs12kdf_set_membuf(&ctx->salt, &ctx->salt_len, p.salt))
+        return 0;
 
-    if ((p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_PKCS12_ID)) != NULL)
-        if (!OSSL_PARAM_get_int(p, &ctx->id))
-            return 0;
+    if (p.p12id != NULL && !OSSL_PARAM_get_int(p.p12id, &ctx->id))
+        return 0;
 
-    if ((p = OSSL_PARAM_locate_const(params, OSSL_KDF_PARAM_ITER)) != NULL)
-        if (!OSSL_PARAM_get_uint64(p, &ctx->iter))
-            return 0;
+    if (p.iter != NULL && !OSSL_PARAM_get_uint64(p.iter, &ctx->iter))
+        return 0;
     return 1;
 }
 
 static const OSSL_PARAM *kdf_pkcs12_settable_ctx_params(
         ossl_unused void *ctx, ossl_unused void *provctx)
 {
-    static const OSSL_PARAM known_settable_ctx_params[] = {
-        OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_PROPERTIES, NULL, 0),
-        OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_DIGEST, NULL, 0),
-        OSSL_PARAM_octet_string(OSSL_KDF_PARAM_PASSWORD, NULL, 0),
-        OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SALT, NULL, 0),
-        OSSL_PARAM_uint64(OSSL_KDF_PARAM_ITER, NULL),
-        OSSL_PARAM_int(OSSL_KDF_PARAM_PKCS12_ID, NULL),
-        OSSL_PARAM_END
-    };
-    return known_settable_ctx_params;
+    return pkcs12_set_ctx_params_list;
 }
 
+{- produce_param_decoder('pkcs12_get_ctx_params',
+                         (['KDF_PARAM_SIZE',                    'size', 'size_t'],
+                         )); -}
+
 static int kdf_pkcs12_get_ctx_params(void *vctx, OSSL_PARAM params[])
 {
-    OSSL_PARAM *p;
+    struct pkcs12_get_ctx_params_st p;
+    KDF_PKCS12 *ctx = vctx;
 
-    if ((p = OSSL_PARAM_locate(params, OSSL_KDF_PARAM_SIZE)) != NULL)
-        return OSSL_PARAM_set_size_t(p, SIZE_MAX);
-    return -2;
+    if (ctx == NULL || !pkcs12_get_ctx_params_decoder(params, &p))
+        return 0;
+
+    if (p.size != NULL && !OSSL_PARAM_set_size_t(p.size, SIZE_MAX))
+        return 0;
+    return 1;
 }
 
 static const OSSL_PARAM *kdf_pkcs12_gettable_ctx_params(
         ossl_unused void *ctx, ossl_unused void *provctx)
 {
-    static const OSSL_PARAM known_gettable_ctx_params[] = {
-        OSSL_PARAM_size_t(OSSL_KDF_PARAM_SIZE, NULL),
-        OSSL_PARAM_END
-    };
-    return known_gettable_ctx_params;
+    return pkcs12_get_ctx_params_list;
 }
 
 const OSSL_DISPATCH ossl_kdf_pkcs12_functions[] = {