Commit d1ba5857c0 for openssl.org
commit d1ba5857c0fc88086559aa8ecb8a54223e6e70ca
Author: Pauli <paul.dale@oracle.com>
Date: Fri Sep 12 19:03:12 2025 +1000
Add OSSL_ prefix back onto param names
Reviewed-by: Matt Caswell <matt@openssl.org>
Reviewed-by: Tomas Mraz <tomas@openssl.org>
Reviewed-by: Dmitry Belyavskiy <beldmit@gmail.com>
(Merged from https://github.com/openssl/openssl/pull/28529)
diff --git a/providers/implementations/asymciphers/rsa_enc.c.in b/providers/implementations/asymciphers/rsa_enc.c.in
index 6d1e97d934..6fcb6f74f5 100644
--- a/providers/implementations/asymciphers/rsa_enc.c.in
+++ b/providers/implementations/asymciphers/rsa_enc.c.in
@@ -369,15 +369,15 @@ static void *rsa_dupctx(void *vprsactx)
}
{- produce_param_decoder('rsa_get_ctx_params',
- (['ASYM_CIPHER_PARAM_OAEP_DIGEST', 'oaep', 'utf8_string'],
- ['ASYM_CIPHER_PARAM_PAD_MODE', 'pad', 'utf8_string'],
- ['ASYM_CIPHER_PARAM_PAD_MODE', 'pad', 'int'],
- ['ASYM_CIPHER_PARAM_MGF1_DIGEST', 'mgf1', 'utf8_string'],
- ['ASYM_CIPHER_PARAM_OAEP_LABEL', 'label', 'octet_ptr'],
- ['ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION', 'tlsver', 'uint'],
- ['ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION', 'negver', 'uint'],
- ['ASYM_CIPHER_PARAM_IMPLICIT_REJECTION', 'imrej', 'uint'],
- ['ASYM_CIPHER_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST', 'oaep', 'utf8_string'],
+ ['OSSL_ASYM_CIPHER_PARAM_PAD_MODE', 'pad', 'utf8_string'],
+ ['OSSL_ASYM_CIPHER_PARAM_PAD_MODE', 'pad', 'int'],
+ ['OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST', 'mgf1', 'utf8_string'],
+ ['OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL', 'label', 'octet_ptr'],
+ ['OSSL_ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION', 'tlsver', 'uint'],
+ ['OSSL_ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION', 'negver', 'uint'],
+ ['OSSL_ASYM_CIPHER_PARAM_IMPLICIT_REJECTION', 'imrej', 'uint'],
+ ['OSSL_ASYM_CIPHER_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int rsa_get_ctx_params(void *vprsactx, OSSL_PARAM *params)
@@ -459,18 +459,18 @@ static const OSSL_PARAM *rsa_gettable_ctx_params(ossl_unused void *vprsactx,
}
{- produce_param_decoder('rsa_set_ctx_params',
- (['ASYM_CIPHER_PARAM_OAEP_DIGEST', 'oaep', 'utf8_string'],
- ['ASYM_CIPHER_PARAM_OAEP_DIGEST_PROPS', 'oaep_pq', 'utf8_string'],
- ['ASYM_CIPHER_PARAM_PAD_MODE', 'pad', 'utf8_string'],
- ['ASYM_CIPHER_PARAM_PAD_MODE', 'pad', 'int'],
- ['ASYM_CIPHER_PARAM_MGF1_DIGEST', 'mgf1', 'utf8_string'],
- ['ASYM_CIPHER_PARAM_MGF1_DIGEST_PROPS', 'mgf1_pq', 'utf8_string'],
- ['ASYM_CIPHER_PARAM_OAEP_LABEL', 'label', 'octet_string'],
- ['ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION', 'tlsver', 'uint'],
- ['ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION', 'negver', 'uint'],
- ['ASYM_CIPHER_PARAM_IMPLICIT_REJECTION', 'imrej', 'uint'],
- ['ASYM_CIPHER_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
- ['ASYM_CIPHER_PARAM_FIPS_RSA_PKCS15_PAD_DISABLED', 'ind_pad', 'int', 'fips'],
+ (['OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST', 'oaep', 'utf8_string'],
+ ['OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST_PROPS', 'oaep_pq', 'utf8_string'],
+ ['OSSL_ASYM_CIPHER_PARAM_PAD_MODE', 'pad', 'utf8_string'],
+ ['OSSL_ASYM_CIPHER_PARAM_PAD_MODE', 'pad', 'int'],
+ ['OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST', 'mgf1', 'utf8_string'],
+ ['OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST_PROPS', 'mgf1_pq', 'utf8_string'],
+ ['OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL', 'label', 'octet_string'],
+ ['OSSL_ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION', 'tlsver', 'uint'],
+ ['OSSL_ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION', 'negver', 'uint'],
+ ['OSSL_ASYM_CIPHER_PARAM_IMPLICIT_REJECTION', 'imrej', 'uint'],
+ ['OSSL_ASYM_CIPHER_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ ['OSSL_ASYM_CIPHER_PARAM_FIPS_RSA_PKCS15_PAD_DISABLED', 'ind_pad', 'int', 'fips'],
)); -}
static int rsa_set_ctx_params(void *vprsactx, const OSSL_PARAM params[])
diff --git a/providers/implementations/asymciphers/sm2_enc.c.in b/providers/implementations/asymciphers/sm2_enc.c.in
index 21bc746b57..a8271a8341 100644
--- a/providers/implementations/asymciphers/sm2_enc.c.in
+++ b/providers/implementations/asymciphers/sm2_enc.c.in
@@ -159,7 +159,7 @@ static void *sm2_dupctx(void *vpsm2ctx)
}
{- produce_param_decoder('sm2_get_ctx_params',
- (['ASYM_CIPHER_PARAM_DIGEST', 'digest', 'utf8_string'],
+ (['OSSL_ASYM_CIPHER_PARAM_DIGEST', 'digest', 'utf8_string'],
)); -}
static int sm2_get_ctx_params(void *vpsm2ctx, OSSL_PARAM *params)
@@ -188,9 +188,9 @@ static const OSSL_PARAM *sm2_gettable_ctx_params(ossl_unused void *vpsm2ctx,
}
{- produce_param_decoder('sm2_set_ctx_params',
- (['ASYM_CIPHER_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['ASYM_CIPHER_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ASYM_CIPHER_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ (['OSSL_ASYM_CIPHER_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_ASYM_CIPHER_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ASYM_CIPHER_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
)); -}
static int sm2_set_ctx_params(void *vpsm2ctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/ciphers/cipher_chacha20_poly1305.c.in b/providers/implementations/ciphers/cipher_chacha20_poly1305.c.in
index deb5c2046e..8a474395dd 100644
--- a/providers/implementations/ciphers/cipher_chacha20_poly1305.c.in
+++ b/providers/implementations/ciphers/cipher_chacha20_poly1305.c.in
@@ -101,11 +101,11 @@ static int chacha20_poly1305_get_params(OSSL_PARAM params[])
}
{- 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'],
+ (['OSSL_CIPHER_PARAM_KEYLEN', 'keylen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_IVLEN', 'ivlen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_AEAD_TAGLEN', 'taglen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_AEAD_TAG', 'tag', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD', 'pad', 'size_t'],
)); -}
static int chacha20_poly1305_get_ctx_params(void *vctx, OSSL_PARAM params[])
@@ -165,11 +165,11 @@ static const OSSL_PARAM *chacha20_poly1305_gettable_ctx_params
}
{- 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'],
+ (['OSSL_CIPHER_PARAM_KEYLEN', 'keylen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_IVLEN', 'ivlen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_AEAD_TAG', 'tag', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_AEAD_TLS1_AAD', 'aad', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED', 'fixed', 'octet_string'],
)); -}
static const OSSL_PARAM *chacha20_poly1305_settable_ctx_params(
diff --git a/providers/implementations/ciphers/ciphercommon.c.in b/providers/implementations/ciphers/ciphercommon.c.in
index 77412a841b..b0d88f89d8 100644
--- a/providers/implementations/ciphers/ciphercommon.c.in
+++ b/providers/implementations/ciphers/ciphercommon.c.in
@@ -29,16 +29,16 @@ use OpenSSL::paramnames qw(produce_param_decoder);
* Generic cipher functions for OSSL_PARAM gettables and settables
*/
{- produce_param_decoder('ossl_cipher_generic_get_params',
- (['CIPHER_PARAM_MODE', 'mode', 'uint'],
- ['CIPHER_PARAM_KEYLEN', 'keylen', 'size_t'],
- ['CIPHER_PARAM_IVLEN', 'ivlen', 'size_t'],
- ['CIPHER_PARAM_BLOCK_SIZE', 'bsize', 'size_t'],
- ['CIPHER_PARAM_AEAD', 'aead', 'int' ],
- ['CIPHER_PARAM_CUSTOM_IV', 'custiv', 'int' ],
- ['CIPHER_PARAM_CTS', 'cts', 'int' ],
- ['CIPHER_PARAM_TLS1_MULTIBLOCK', 'mb', 'int' ],
- ['CIPHER_PARAM_HAS_RAND_KEY', 'rand', 'int' ],
- ['CIPHER_PARAM_ENCRYPT_THEN_MAC', 'etm', 'int' ],
+ (['OSSL_CIPHER_PARAM_MODE', 'mode', 'uint'],
+ ['OSSL_CIPHER_PARAM_KEYLEN', 'keylen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_IVLEN', 'ivlen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_BLOCK_SIZE', 'bsize', 'size_t'],
+ ['OSSL_CIPHER_PARAM_AEAD', 'aead', 'int' ],
+ ['OSSL_CIPHER_PARAM_CUSTOM_IV', 'custiv', 'int' ],
+ ['OSSL_CIPHER_PARAM_CTS', 'cts', 'int' ],
+ ['OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK', 'mb', 'int' ],
+ ['OSSL_CIPHER_PARAM_HAS_RAND_KEY', 'rand', 'int' ],
+ ['OSSL_CIPHER_PARAM_ENCRYPT_THEN_MAC', 'etm', 'int' ],
)); -}
const OSSL_PARAM *ossl_cipher_generic_gettable_params(ossl_unused void *provctx)
@@ -107,13 +107,13 @@ int ossl_cipher_generic_get_params(OSSL_PARAM params[], unsigned int md,
#define cipher_generic_get_ctx_params_st ossl_cipher_get_ctx_param_list_st
{- produce_param_decoder('cipher_generic_get_ctx_params',
- (['CIPHER_PARAM_KEYLEN', 'keylen', 'size_t'],
- ['CIPHER_PARAM_IVLEN', 'ivlen', 'size_t'],
- ['CIPHER_PARAM_PADDING', 'pad', 'uint'],
- ['CIPHER_PARAM_NUM', 'num', 'uint' ],
- ['CIPHER_PARAM_IV', 'iv', 'octet_string' ],
- ['CIPHER_PARAM_UPDATED_IV', 'updiv', 'octet_string' ],
- ['CIPHER_PARAM_TLS_MAC', 'tlsmac', 'octet_string' ],
+ (['OSSL_CIPHER_PARAM_KEYLEN', 'keylen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_IVLEN', 'ivlen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_PADDING', 'pad', 'uint'],
+ ['OSSL_CIPHER_PARAM_NUM', 'num', 'uint' ],
+ ['OSSL_CIPHER_PARAM_IV', 'iv', 'octet_string' ],
+ ['OSSL_CIPHER_PARAM_UPDATED_IV', 'updiv', 'octet_string' ],
+ ['OSSL_CIPHER_PARAM_TLS_MAC', 'tlsmac', 'octet_string' ],
)); -}
const OSSL_PARAM *ossl_cipher_generic_gettable_ctx_params
@@ -125,11 +125,11 @@ const OSSL_PARAM *ossl_cipher_generic_gettable_ctx_params
#define cipher_generic_set_ctx_params_st ossl_cipher_set_ctx_param_list_st
{- produce_param_decoder('cipher_generic_set_ctx_params',
- (['CIPHER_PARAM_PADDING', 'pad', 'uint'],
- ['CIPHER_PARAM_NUM', 'num', 'uint'],
- ['CIPHER_PARAM_USE_BITS', 'bits', 'uint'],
- ['CIPHER_PARAM_TLS_VERSION', 'tlsvers', 'uint'],
- ['CIPHER_PARAM_TLS_MAC_SIZE', 'tlsmacsize', 'size_t'],
+ (['OSSL_CIPHER_PARAM_PADDING', 'pad', 'uint'],
+ ['OSSL_CIPHER_PARAM_NUM', 'num', 'uint'],
+ ['OSSL_CIPHER_PARAM_USE_BITS', 'bits', 'uint'],
+ ['OSSL_CIPHER_PARAM_TLS_VERSION', 'tlsvers', 'uint'],
+ ['OSSL_CIPHER_PARAM_TLS_MAC_SIZE', 'tlsmacsize', 'size_t'],
)); -}
const OSSL_PARAM *ossl_cipher_generic_settable_ctx_params
@@ -144,12 +144,12 @@ const OSSL_PARAM *ossl_cipher_generic_settable_ctx_params
#define cipher_var_keylen_set_ctx_params_st ossl_cipher_set_ctx_param_list_st
{- produce_param_decoder('cipher_var_keylen_set_ctx_params',
- (['CIPHER_PARAM_PADDING', 'pad', 'uint'],
- ['CIPHER_PARAM_NUM', 'num', 'uint'],
- ['CIPHER_PARAM_USE_BITS', 'bits', 'uint'],
- ['CIPHER_PARAM_TLS_VERSION', 'tlsvers', 'uint'],
- ['CIPHER_PARAM_TLS_MAC_SIZE', 'tlsmacsize', 'size_t'],
- ['CIPHER_PARAM_KEYLEN', 'keylen', 'size_t'],
+ (['OSSL_CIPHER_PARAM_PADDING', 'pad', 'uint'],
+ ['OSSL_CIPHER_PARAM_NUM', 'num', 'uint'],
+ ['OSSL_CIPHER_PARAM_USE_BITS', 'bits', 'uint'],
+ ['OSSL_CIPHER_PARAM_TLS_VERSION', 'tlsvers', 'uint'],
+ ['OSSL_CIPHER_PARAM_TLS_MAC_SIZE', 'tlsmacsize', 'size_t'],
+ ['OSSL_CIPHER_PARAM_KEYLEN', 'keylen', 'size_t'],
)); -}
const OSSL_PARAM *ossl_cipher_var_keylen_settable_ctx_params
diff --git a/providers/implementations/ciphers/ciphercommon_ccm.c.in b/providers/implementations/ciphers/ciphercommon_ccm.c.in
index 8ff30b9bed..56bfb6d3dc 100644
--- a/providers/implementations/ciphers/ciphercommon_ccm.c.in
+++ b/providers/implementations/ciphers/ciphercommon_ccm.c.in
@@ -70,10 +70,10 @@ static size_t ccm_get_ivlen(PROV_CCM_CTX *ctx)
}
{- produce_param_decoder('ossl_cipher_ccm_set_ctx_params',
- (['CIPHER_PARAM_AEAD_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'],
+ (['OSSL_CIPHER_PARAM_AEAD_IVLEN', 'ivlen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_AEAD_TAG', 'tag', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_AEAD_TLS1_AAD', 'aad', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED', 'fixed', 'octet_string'],
)); -}
const OSSL_PARAM *ossl_ccm_settable_ctx_params(
@@ -156,13 +156,13 @@ int ossl_ccm_set_ctx_params(void *vctx, const OSSL_PARAM params[])
}
{- produce_param_decoder('ossl_cipher_ccm_get_ctx_params',
- (['CIPHER_PARAM_KEYLEN', 'keylen', 'size_t'],
- ['CIPHER_PARAM_IVLEN', 'ivlen', 'size_t'],
- ['CIPHER_PARAM_AEAD_TAGLEN', 'taglen', 'size_t'],
- ['CIPHER_PARAM_IV', 'iv', 'octet_string'],
- ['CIPHER_PARAM_UPDATED_IV', 'updiv', 'octet_string'],
- ['CIPHER_PARAM_AEAD_TAG', 'tag', 'octet_string'],
- ['CIPHER_PARAM_AEAD_TLS1_AAD_PAD', 'pad', 'size_t'],
+ (['OSSL_CIPHER_PARAM_KEYLEN', 'keylen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_IVLEN', 'ivlen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_AEAD_TAGLEN', 'taglen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_IV', 'iv', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_UPDATED_IV', 'updiv', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_AEAD_TAG', 'tag', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD', 'pad', 'size_t'],
)); -}
const OSSL_PARAM *ossl_ccm_gettable_ctx_params(
diff --git a/providers/implementations/ciphers/ciphercommon_gcm.c.in b/providers/implementations/ciphers/ciphercommon_gcm.c.in
index 27bd48bd69..4964f15e67 100644
--- a/providers/implementations/ciphers/ciphercommon_gcm.c.in
+++ b/providers/implementations/ciphers/ciphercommon_gcm.c.in
@@ -144,15 +144,15 @@ static int setivinv(PROV_GCM_CTX *ctx, unsigned char *in, size_t inl)
}
{- produce_param_decoder('ossl_cipher_gcm_get_ctx_params',
- (['CIPHER_PARAM_KEYLEN', 'keylen', 'size_t'],
- ['CIPHER_PARAM_IVLEN', 'ivlen', 'size_t'],
- ['CIPHER_PARAM_AEAD_TAGLEN', 'taglen', 'size_t'],
- ['CIPHER_PARAM_IV', 'iv', 'octet_string'],
- ['CIPHER_PARAM_UPDATED_IV', 'updiv', 'octet_string'],
- ['CIPHER_PARAM_AEAD_TAG', 'tag', 'octet_string'],
- ['CIPHER_PARAM_AEAD_TLS1_AAD_PAD', 'pad', 'size_t'],
- ['CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN', 'ivgen', 'octet_string'],
- ['CIPHER_PARAM_AEAD_IV_GENERATED', 'gen', 'uint'],
+ (['OSSL_CIPHER_PARAM_KEYLEN', 'keylen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_IVLEN', 'ivlen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_AEAD_TAGLEN', 'taglen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_IV', 'iv', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_UPDATED_IV', 'updiv', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_AEAD_TAG', 'tag', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD', 'pad', 'size_t'],
+ ['OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN', 'ivgen', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_AEAD_IV_GENERATED', 'gen', 'uint'],
)); -}
const OSSL_PARAM *ossl_gcm_gettable_ctx_params(
@@ -251,11 +251,11 @@ int ossl_gcm_get_ctx_params(void *vctx, OSSL_PARAM params[])
{- produce_param_decoder
('ossl_cipher_gcm_set_ctx_params',
- (['CIPHER_PARAM_AEAD_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'],
- ['CIPHER_PARAM_AEAD_TLS1_SET_IV_INV', 'inviv', 'octet_string'],
+ (['OSSL_CIPHER_PARAM_AEAD_IVLEN', 'ivlen', 'size_t'],
+ ['OSSL_CIPHER_PARAM_AEAD_TAG', 'tag', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_AEAD_TLS1_AAD', 'aad', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED', 'fixed', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV', 'inviv', 'octet_string'],
)); -}
const OSSL_PARAM *ossl_gcm_settable_ctx_params(
diff --git a/providers/implementations/digests/blake2_prov.c.in b/providers/implementations/digests/blake2_prov.c.in
index 3651f8783e..5ec80bf177 100644
--- a/providers/implementations/digests/blake2_prov.c.in
+++ b/providers/implementations/digests/blake2_prov.c.in
@@ -24,7 +24,7 @@ static OSSL_FUNC_digest_gettable_ctx_params_fn blake_gettable_ctx_params;
static OSSL_FUNC_digest_settable_ctx_params_fn blake_settable_ctx_params;
{- produce_param_decoder('blake_get_ctx_params',
- (['DIGEST_PARAM_SIZE', 'size', 'uint'],
+ (['OSSL_DIGEST_PARAM_SIZE', 'size', 'uint'],
)); -}
static const OSSL_PARAM *blake_gettable_ctx_params(ossl_unused void *ctx,
@@ -34,7 +34,7 @@ static const OSSL_PARAM *blake_gettable_ctx_params(ossl_unused void *ctx,
}
{- produce_param_decoder('blake_set_ctx_params',
- (['DIGEST_PARAM_SIZE', 'size', 'uint'],
+ (['OSSL_DIGEST_PARAM_SIZE', 'size', 'uint'],
)); -}
static const OSSL_PARAM *blake_settable_ctx_params(ossl_unused void *ctx,
diff --git a/providers/implementations/digests/digestcommon.c.in b/providers/implementations/digests/digestcommon.c.in
index 5dd3f032b4..ad9cec04be 100644
--- a/providers/implementations/digests/digestcommon.c.in
+++ b/providers/implementations/digests/digestcommon.c.in
@@ -17,10 +17,10 @@ use OpenSSL::paramnames qw(produce_param_decoder);
#include "internal/common.h"
{- produce_param_decoder('digest_default_get_params',
- (['DIGEST_PARAM_BLOCK_SIZE', 'bsize', 'size_t'],
- ['DIGEST_PARAM_SIZE', 'size', 'size_t'],
- ['DIGEST_PARAM_XOF', 'xof', 'int'],
- ['DIGEST_PARAM_ALGID_ABSENT', 'aldid', 'int'],
+ (['OSSL_DIGEST_PARAM_BLOCK_SIZE', 'bsize', 'size_t'],
+ ['OSSL_DIGEST_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_DIGEST_PARAM_XOF', 'xof', 'int'],
+ ['OSSL_DIGEST_PARAM_ALGID_ABSENT', 'aldid', 'int'],
)); -}
int ossl_digest_default_get_params(OSSL_PARAM params[], size_t blksz,
diff --git a/providers/implementations/digests/sha3_prov.c.in b/providers/implementations/digests/sha3_prov.c.in
index 20e2959a3d..ef1701ff0f 100644
--- a/providers/implementations/digests/sha3_prov.c.in
+++ b/providers/implementations/digests/sha3_prov.c.in
@@ -587,8 +587,8 @@ static void *keccak_dupctx(void *ctx)
}
{- produce_param_decoder('shake_get_ctx_params',
- (['DIGEST_PARAM_XOFLEN', 'xoflen', 'size_t'],
- ['DIGEST_PARAM_SIZE', 'size', 'size_t'],
+ (['OSSL_DIGEST_PARAM_XOFLEN', 'xoflen', 'size_t'],
+ ['OSSL_DIGEST_PARAM_SIZE', 'size', 'size_t'],
)); -}
static const OSSL_PARAM *shake_gettable_ctx_params(ossl_unused void *ctx,
@@ -618,8 +618,8 @@ static int shake_get_ctx_params(void *vctx, OSSL_PARAM params[])
}
{- produce_param_decoder('shake_set_ctx_params',
- (['DIGEST_PARAM_XOFLEN', 'xoflen', 'size_t'],
- ['DIGEST_PARAM_SIZE', 'xoflen', 'size_t'],
+ (['OSSL_DIGEST_PARAM_XOFLEN', 'xoflen', 'size_t'],
+ ['OSSL_DIGEST_PARAM_SIZE', 'xoflen', 'size_t'],
)); -}
static const OSSL_PARAM *shake_settable_ctx_params(ossl_unused void *ctx,
diff --git a/providers/implementations/encode_decode/decode_der2key.c.in b/providers/implementations/encode_decode/decode_der2key.c.in
index d3258ddf1a..22e7ad5803 100644
--- a/providers/implementations/encode_decode/decode_der2key.c.in
+++ b/providers/implementations/encode_decode/decode_der2key.c.in
@@ -173,7 +173,7 @@ der2key_newctx(void *provctx, const struct keytype_desc_st *desc)
}
{- produce_param_decoder('der2key_set_ctx_params',
- (['DECODER_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ (['OSSL_DECODER_PARAM_PROPERTIES', 'propq', 'utf8_string'],
)); -}
static const OSSL_PARAM *der2key_settable_ctx_params(ossl_unused void *provctx)
diff --git a/providers/implementations/encode_decode/decode_epki2pki.c.in b/providers/implementations/encode_decode/decode_epki2pki.c.in
index 3e684a8cfe..3c3b794d86 100644
--- a/providers/implementations/encode_decode/decode_epki2pki.c.in
+++ b/providers/implementations/encode_decode/decode_epki2pki.c.in
@@ -59,7 +59,7 @@ static void epki2pki_freectx(void *vctx)
}
{- produce_param_decoder('epki2pki_set_ctx_params',
- (['DECODER_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ (['OSSL_DECODER_PARAM_PROPERTIES', 'propq', 'utf8_string'],
)); -}
static const OSSL_PARAM *epki2pki_settable_ctx_params(ossl_unused void *provctx)
diff --git a/providers/implementations/encode_decode/decode_pem2der.c.in b/providers/implementations/encode_decode/decode_pem2der.c.in
index 8bb94525ab..7512da1309 100644
--- a/providers/implementations/encode_decode/decode_pem2der.c.in
+++ b/providers/implementations/encode_decode/decode_pem2der.c.in
@@ -79,8 +79,8 @@ static void pem2der_freectx(void *vctx)
}
{- produce_param_decoder('pem2der_set_ctx_params',
- (['DECODER_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['OBJECT_PARAM_DATA_STRUCTURE', 'ds', 'utf8_string'],
+ (['OSSL_DECODER_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_OBJECT_PARAM_DATA_STRUCTURE', 'ds', 'utf8_string'],
)); -}
static const OSSL_PARAM *pem2der_settable_ctx_params(ossl_unused void *provctx)
diff --git a/providers/implementations/encode_decode/decode_pvk2key.c.in b/providers/implementations/encode_decode/decode_pvk2key.c.in
index bfa5a2ee3d..8dfd57bb0d 100644
--- a/providers/implementations/encode_decode/decode_pvk2key.c.in
+++ b/providers/implementations/encode_decode/decode_pvk2key.c.in
@@ -89,7 +89,7 @@ static void pvk2key_freectx(void *vctx)
}
{- produce_param_decoder('pvk2key_set_ctx_params',
- (['DECODER_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ (['OSSL_DECODER_PARAM_PROPERTIES', 'propq', 'utf8_string'],
)); -}
static const OSSL_PARAM *pvk2key_settable_ctx_params(ossl_unused void *provctx)
diff --git a/providers/implementations/encode_decode/decode_spki2typespki.c.in b/providers/implementations/encode_decode/decode_spki2typespki.c.in
index f84035fb18..210f2f5efd 100644
--- a/providers/implementations/encode_decode/decode_spki2typespki.c.in
+++ b/providers/implementations/encode_decode/decode_spki2typespki.c.in
@@ -58,7 +58,7 @@ static void spki2typespki_freectx(void *vctx)
}
{- produce_param_decoder('spki2typespki_set_ctx_params',
- (['DECODER_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ (['OSSL_DECODER_PARAM_PROPERTIES', 'propq', 'utf8_string'],
)); -}
static const OSSL_PARAM *spki2typespki_settable_ctx_params(ossl_unused void *provctx)
diff --git a/providers/implementations/encode_decode/encode_key2any.c.in b/providers/implementations/encode_decode/encode_key2any.c.in
index d9faeea3e7..d293f2256e 100644
--- a/providers/implementations/encode_decode/encode_key2any.c.in
+++ b/providers/implementations/encode_decode/encode_key2any.c.in
@@ -1138,9 +1138,9 @@ static void key2any_freectx(void *vctx)
}
{- produce_param_decoder('key2any_set_ctx_params',
- (['ENCODER_PARAM_CIPHER', 'cipher', 'utf8_string'],
- ['ENCODER_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ENCODER_PARAM_SAVE_PARAMETERS', 'svprm', 'int'],
+ (['OSSL_ENCODER_PARAM_CIPHER', 'cipher', 'utf8_string'],
+ ['OSSL_ENCODER_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ENCODER_PARAM_SAVE_PARAMETERS', 'svprm', 'int'],
)); -}
static const OSSL_PARAM *key2any_settable_ctx_params(ossl_unused void *provctx)
diff --git a/providers/implementations/encode_decode/encode_key2ms.c.in b/providers/implementations/encode_decode/encode_key2ms.c.in
index 319fc279a3..ec3f3050a7 100644
--- a/providers/implementations/encode_decode/encode_key2ms.c.in
+++ b/providers/implementations/encode_decode/encode_key2ms.c.in
@@ -94,7 +94,7 @@ static void key2ms_freectx(void *vctx)
}
{- produce_param_decoder('key2pvk_set_ctx_params',
- (['ENCODER_PARAM_ENCRYPT_LEVEL', 'enclvl', 'int'],
+ (['OSSL_ENCODER_PARAM_ENCRYPT_LEVEL', 'enclvl', 'int'],
)); -}
static const OSSL_PARAM *key2pvk_settable_ctx_params(ossl_unused void *provctx)
diff --git a/providers/implementations/exchange/dh_exch.c.in b/providers/implementations/exchange/dh_exch.c.in
index 779b2cec96..0aa4c85bb9 100644
--- a/providers/implementations/exchange/dh_exch.c.in
+++ b/providers/implementations/exchange/dh_exch.c.in
@@ -342,15 +342,15 @@ err:
}
{- produce_param_decoder('dh_set_ctx_params',
- (['EXCHANGE_PARAM_PAD', 'pad', 'int'],
- ['EXCHANGE_PARAM_KDF_TYPE', 'kdf', 'utf8_string'],
- ['EXCHANGE_PARAM_KDF_DIGEST', 'digest', 'utf8_string'],
- ['EXCHANGE_PARAM_KDF_DIGEST_PROPS', 'propq', 'utf8_string'],
- ['EXCHANGE_PARAM_KDF_OUTLEN', 'len', 'size_t'],
- ['EXCHANGE_PARAM_KDF_UKM', 'ukm', 'octet_string'],
- ['KDF_PARAM_CEK_ALG', 'cekalg', 'utf8_string'],
- ['EXCHANGE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
- ['EXCHANGE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
+ (['OSSL_EXCHANGE_PARAM_PAD', 'pad', 'int'],
+ ['OSSL_EXCHANGE_PARAM_KDF_TYPE', 'kdf', 'utf8_string'],
+ ['OSSL_EXCHANGE_PARAM_KDF_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_EXCHANGE_PARAM_KDF_DIGEST_PROPS', 'propq', 'utf8_string'],
+ ['OSSL_EXCHANGE_PARAM_KDF_OUTLEN', 'len', 'size_t'],
+ ['OSSL_EXCHANGE_PARAM_KDF_UKM', 'ukm', 'octet_string'],
+ ['OSSL_KDF_PARAM_CEK_ALG', 'cekalg', 'utf8_string'],
+ ['OSSL_EXCHANGE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ ['OSSL_EXCHANGE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
)); -}
static int dh_set_ctx_params(void *vpdhctx, const OSSL_PARAM params[])
@@ -466,12 +466,12 @@ static const OSSL_PARAM *dh_settable_ctx_params(ossl_unused void *vpdhctx,
}
{- produce_param_decoder('dh_get_ctx_params',
- (['EXCHANGE_PARAM_KDF_TYPE', 'kdf', 'utf8_string'],
- ['EXCHANGE_PARAM_KDF_DIGEST', 'digest', 'utf8_string'],
- ['EXCHANGE_PARAM_KDF_OUTLEN', 'len', 'size_t'],
- ['EXCHANGE_PARAM_KDF_UKM', 'ukm', 'octet_ptr'],
- ['KDF_PARAM_CEK_ALG', 'cekalg', 'utf8_string'],
- ['ALG_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_EXCHANGE_PARAM_KDF_TYPE', 'kdf', 'utf8_string'],
+ ['OSSL_EXCHANGE_PARAM_KDF_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_EXCHANGE_PARAM_KDF_OUTLEN', 'len', 'size_t'],
+ ['OSSL_EXCHANGE_PARAM_KDF_UKM', 'ukm', 'octet_ptr'],
+ ['OSSL_KDF_PARAM_CEK_ALG', 'cekalg', 'utf8_string'],
+ ['OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static const OSSL_PARAM *dh_gettable_ctx_params(ossl_unused void *vpdhctx,
diff --git a/providers/implementations/exchange/ecdh_exch.c.in b/providers/implementations/exchange/ecdh_exch.c.in
index 69cae378aa..43e1b78d58 100644
--- a/providers/implementations/exchange/ecdh_exch.c.in
+++ b/providers/implementations/exchange/ecdh_exch.c.in
@@ -249,15 +249,15 @@ void *ecdh_dupctx(void *vpecdhctx)
}
{- produce_param_decoder('ecdh_set_ctx_params',
- (['EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE', 'mode', 'int'],
- ['EXCHANGE_PARAM_KDF_TYPE', 'kdf', 'utf8_string'],
- ['EXCHANGE_PARAM_KDF_DIGEST', 'digest', 'utf8_string'],
- ['EXCHANGE_PARAM_KDF_DIGEST_PROPS', 'propq', 'utf8_string'],
- ['EXCHANGE_PARAM_KDF_OUTLEN', 'len', 'size_t'],
- ['EXCHANGE_PARAM_KDF_UKM', 'ukm', 'octet_string'],
- ['EXCHANGE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
- ['EXCHANGE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
- ['EXCHANGE_PARAM_FIPS_ECDH_COFACTOR_CHECK', 'ind_cofac', 'int', 'fips'],
+ (['OSSL_EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE', 'mode', 'int'],
+ ['OSSL_EXCHANGE_PARAM_KDF_TYPE', 'kdf', 'utf8_string'],
+ ['OSSL_EXCHANGE_PARAM_KDF_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_EXCHANGE_PARAM_KDF_DIGEST_PROPS', 'propq', 'utf8_string'],
+ ['OSSL_EXCHANGE_PARAM_KDF_OUTLEN', 'len', 'size_t'],
+ ['OSSL_EXCHANGE_PARAM_KDF_UKM', 'ukm', 'octet_string'],
+ ['OSSL_EXCHANGE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ ['OSSL_EXCHANGE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
+ ['OSSL_EXCHANGE_PARAM_FIPS_ECDH_COFACTOR_CHECK', 'ind_cofac', 'int', 'fips'],
)); -}
static
@@ -366,12 +366,12 @@ const OSSL_PARAM *ecdh_settable_ctx_params(ossl_unused void *vpecdhctx,
}
{- produce_param_decoder('ecdh_get_ctx_params',
- (['EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE', 'mode', 'int'],
- ['EXCHANGE_PARAM_KDF_TYPE', 'kdf', 'utf8_string'],
- ['EXCHANGE_PARAM_KDF_DIGEST', 'digest', 'utf8_string'],
- ['EXCHANGE_PARAM_KDF_OUTLEN', 'len', 'size_t'],
- ['EXCHANGE_PARAM_KDF_UKM', 'ukm', 'octet_ptr'],
- ['ALG_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE', 'mode', 'int'],
+ ['OSSL_EXCHANGE_PARAM_KDF_TYPE', 'kdf', 'utf8_string'],
+ ['OSSL_EXCHANGE_PARAM_KDF_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_EXCHANGE_PARAM_KDF_OUTLEN', 'len', 'size_t'],
+ ['OSSL_EXCHANGE_PARAM_KDF_UKM', 'ukm', 'octet_ptr'],
+ ['OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static
diff --git a/providers/implementations/exchange/ecx_exch.c.in b/providers/implementations/exchange/ecx_exch.c.in
index 9ffb98252c..5fa6595ced 100644
--- a/providers/implementations/exchange/ecx_exch.c.in
+++ b/providers/implementations/exchange/ecx_exch.c.in
@@ -182,7 +182,7 @@ static void *ecx_dupctx(void *vecxctx)
#ifdef FIPS_MODULE
{- produce_param_decoder('ecx_get_ctx_params',
- (['ALG_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
#endif
diff --git a/providers/implementations/include/prov/blake2_params.inc.in b/providers/implementations/include/prov/blake2_params.inc.in
index cca0dcff56..37d9f158ba 100644
--- a/providers/implementations/include/prov/blake2_params.inc.in
+++ b/providers/implementations/include/prov/blake2_params.inc.in
@@ -14,14 +14,14 @@ use OpenSSL::paramnames qw(produce_param_decoder);
#include "internal/common.h"
{- produce_param_decoder('blake2_get_ctx',
- (['MAC_PARAM_SIZE', 'size', 'size_t'],
- ['MAC_PARAM_BLOCK_SIZE', 'bsize', 'size_t'],
+ (['OSSL_MAC_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_MAC_PARAM_BLOCK_SIZE', 'bsize', 'size_t'],
)); -}
{- produce_param_decoder('blake2_mac_set_ctx',
- (['MAC_PARAM_SIZE', 'size', 'size_t'],
- ['MAC_PARAM_KEY', 'key', 'octet_string'],
- ['MAC_PARAM_CUSTOM', 'cust', 'octet_string'],
- ['MAC_PARAM_SALT', 'salt', 'octet_string'],
+ (['OSSL_MAC_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_MAC_PARAM_KEY', 'key', 'octet_string'],
+ ['OSSL_MAC_PARAM_CUSTOM', 'cust', 'octet_string'],
+ ['OSSL_MAC_PARAM_SALT', 'salt', 'octet_string'],
)); -}
diff --git a/providers/implementations/kdfs/argon2.c.in b/providers/implementations/kdfs/argon2.c.in
index fc65074d3e..3b99b5b548 100644
--- a/providers/implementations/kdfs/argon2.c.in
+++ b/providers/implementations/kdfs/argon2.c.in
@@ -1395,18 +1395,18 @@ static int set_property_query(KDF_ARGON2 *ctx, const char *propq)
}
{- produce_param_decoder('argon2_set_ctx_params',
- (['KDF_PARAM_PASSWORD', 'pw', 'octet_string'],
- ['KDF_PARAM_SALT', 'salt', 'octet_string'],
- ['KDF_PARAM_SECRET', 'secret', 'octet_string'],
- ['KDF_PARAM_ARGON2_AD', 'ad', 'octet_string'],
- ['KDF_PARAM_SIZE', 'size', 'uint32'],
- ['KDF_PARAM_ITER', 'iter', 'uint32'],
- ['KDF_PARAM_THREADS', 'thrds', 'uint32'],
- ['KDF_PARAM_ARGON2_LANES', 'lanes', 'uint32'],
- ['KDF_PARAM_ARGON2_MEMCOST', 'mem', 'uint32'],
- ['KDF_PARAM_EARLY_CLEAN', 'eclean', 'uint32'],
- ['KDF_PARAM_ARGON2_VERSION', 'vers', 'uint32'],
- ['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ (['OSSL_KDF_PARAM_PASSWORD', 'pw', 'octet_string'],
+ ['OSSL_KDF_PARAM_SALT', 'salt', 'octet_string'],
+ ['OSSL_KDF_PARAM_SECRET', 'secret', 'octet_string'],
+ ['OSSL_KDF_PARAM_ARGON2_AD', 'ad', 'octet_string'],
+ ['OSSL_KDF_PARAM_SIZE', 'size', 'uint32'],
+ ['OSSL_KDF_PARAM_ITER', 'iter', 'uint32'],
+ ['OSSL_KDF_PARAM_THREADS', 'thrds', 'uint32'],
+ ['OSSL_KDF_PARAM_ARGON2_LANES', 'lanes', 'uint32'],
+ ['OSSL_KDF_PARAM_ARGON2_MEMCOST', 'mem', 'uint32'],
+ ['OSSL_KDF_PARAM_EARLY_CLEAN', 'eclean', 'uint32'],
+ ['OSSL_KDF_PARAM_ARGON2_VERSION', 'vers', 'uint32'],
+ ['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
)); -}
static int argon2_set_ctx_params(KDF_ARGON2 *ctx, const OSSL_PARAM params[],
@@ -1502,7 +1502,7 @@ static const OSSL_PARAM *kdf_argon2_settable_ctx_params(ossl_unused void *ctx,
}
{- produce_param_decoder('argon2_get_ctx_params',
- (['KDF_PARAM_SIZE', 'size', 'size_t'],
+ (['OSSL_KDF_PARAM_SIZE', 'size', 'size_t'],
)); -}
static int kdf_argon2_get_ctx_params(void *vctx, OSSL_PARAM params[])
diff --git a/providers/implementations/kdfs/hkdf.c.in b/providers/implementations/kdfs/hkdf.c.in
index 3e0bbb53f3..5f118bb9ca 100644
--- a/providers/implementations/kdfs/hkdf.c.in
+++ b/providers/implementations/kdfs/hkdf.c.in
@@ -355,15 +355,15 @@ static int hkdf_common_set_ctx_params
#define hkdf_set_ctx_params_st hkdf_all_set_ctx_params_st
{- produce_param_decoder('hkdf_set_ctx_params',
- (['KDF_PARAM_MODE', 'mode', 'utf8_string'],
- ['KDF_PARAM_MODE', 'mode', 'int'],
- ['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['KDF_PARAM_KEY', 'key', 'octet_string'],
- ['KDF_PARAM_SALT', 'salt', 'octet_string'],
- ['KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
- ['KDF_PARAM_INFO', 'info', 'octet_string', HKDF_MAX_INFOS],
+ (['OSSL_KDF_PARAM_MODE', 'mode', 'utf8_string'],
+ ['OSSL_KDF_PARAM_MODE', 'mode', 'int'],
+ ['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_KDF_PARAM_KEY', 'key', 'octet_string'],
+ ['OSSL_KDF_PARAM_SALT', 'salt', 'octet_string'],
+ ['OSSL_KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ ['OSSL_KDF_PARAM_INFO', 'info', 'octet_string', HKDF_MAX_INFOS],
)); -}
static int kdf_hkdf_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -396,13 +396,13 @@ static const OSSL_PARAM *kdf_hkdf_settable_ctx_params(ossl_unused void *ctx,
}
{- produce_param_decoder('hkdf_get_ctx_params',
- (['KDF_PARAM_SIZE', 'size', 'size_t'],
- ['KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['KDF_PARAM_MODE', 'mode', 'utf8_string'],
- ['KDF_PARAM_MODE', 'mode', 'int'],
- ['KDF_PARAM_SALT', 'salt', 'octet_string'],
- ['KDF_PARAM_INFO', 'info', 'octet_string'],
- ['KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_KDF_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_KDF_PARAM_MODE', 'mode', 'utf8_string'],
+ ['OSSL_KDF_PARAM_MODE', 'mode', 'int'],
+ ['OSSL_KDF_PARAM_SALT', 'salt', 'octet_string'],
+ ['OSSL_KDF_PARAM_INFO', 'info', 'octet_string'],
+ ['OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static const OSSL_PARAM *hkdf_gettable_ctx_params(ossl_unused void *ctx,
@@ -523,13 +523,13 @@ static void *kdf_hkdf_fixed_digest_new(void *provctx, const char *digest)
#define hkdf_fixed_digest_set_ctx_params_st hkdf_all_set_ctx_params_st
{- produce_param_decoder('hkdf_fixed_digest_set_ctx_params',
- (['KDF_PARAM_MODE', 'mode', 'utf8_string'],
- ['KDF_PARAM_MODE', 'mode', 'int'],
- ['KDF_PARAM_DIGEST', 'digest', 'utf8_string', 'hidden'],
- ['KDF_PARAM_KEY', 'key', 'octet_string'],
- ['KDF_PARAM_SALT', 'salt', 'octet_string'],
- ['KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
- ['KDF_PARAM_INFO', 'info', 'octet_string', HKDF_MAX_INFOS],
+ (['OSSL_KDF_PARAM_MODE', 'mode', 'utf8_string'],
+ ['OSSL_KDF_PARAM_MODE', 'mode', 'int'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_KEY', 'key', 'octet_string'],
+ ['OSSL_KDF_PARAM_SALT', 'salt', 'octet_string'],
+ ['OSSL_KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ ['OSSL_KDF_PARAM_INFO', 'info', 'octet_string', HKDF_MAX_INFOS],
)); -}
static int kdf_hkdf_fixed_digest_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -1008,18 +1008,18 @@ static int kdf_tls1_3_derive(void *vctx, unsigned char *key, size_t keylen,
#define kdf_tls1_3_set_ctx_params_st hkdf_all_set_ctx_params_st
{- produce_param_decoder('kdf_tls1_3_set_ctx_params',
- (['KDF_PARAM_MODE', 'mode', 'utf8_string'],
- ['KDF_PARAM_MODE', 'mode', 'int'],
- ['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['KDF_PARAM_KEY', 'key', 'octet_string'],
- ['KDF_PARAM_SALT', 'salt', 'octet_string'],
- ['KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
- ['KDF_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
- ['KDF_PARAM_PREFIX', 'prefix', 'octet_string'],
- ['KDF_PARAM_LABEL', 'label', 'octet_string'],
- ['KDF_PARAM_DATA', 'data', 'octet_string'],
+ (['OSSL_KDF_PARAM_MODE', 'mode', 'utf8_string'],
+ ['OSSL_KDF_PARAM_MODE', 'mode', 'int'],
+ ['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_KDF_PARAM_KEY', 'key', 'octet_string'],
+ ['OSSL_KDF_PARAM_SALT', 'salt', 'octet_string'],
+ ['OSSL_KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ ['OSSL_KDF_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
+ ['OSSL_KDF_PARAM_PREFIX', 'prefix', 'octet_string'],
+ ['OSSL_KDF_PARAM_LABEL', 'label', 'octet_string'],
+ ['OSSL_KDF_PARAM_DATA', 'data', 'octet_string'],
)); -}
static int kdf_tls1_3_set_ctx_params(void *vctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/kdfs/hmacdrbg_kdf.c.in b/providers/implementations/kdfs/hmacdrbg_kdf.c.in
index 4629872d9a..64fd2b4f2c 100644
--- a/providers/implementations/kdfs/hmacdrbg_kdf.c.in
+++ b/providers/implementations/kdfs/hmacdrbg_kdf.c.in
@@ -141,8 +141,8 @@ static int hmac_drbg_kdf_derive(void *vctx, unsigned char *out, size_t outlen,
}
{- produce_param_decoder('hmac_drbg_kdf_get_ctx_params',
- (['KDF_PARAM_MAC', 'mac', 'utf8_string'],
- ['KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ (['OSSL_KDF_PARAM_MAC', 'mac', 'utf8_string'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
)); -}
static int hmac_drbg_kdf_get_ctx_params(void *vctx, OSSL_PARAM params[])
@@ -180,11 +180,11 @@ static const OSSL_PARAM *hmac_drbg_kdf_gettable_ctx_params(
}
{- produce_param_decoder('hmac_drbg_kdf_set_ctx_params',
- (['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['KDF_PARAM_HMACDRBG_ENTROPY', 'ent', 'octet_string'],
- ['KDF_PARAM_HMACDRBG_NONCE', 'nonce', 'octet_string'],
+ (['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_KDF_PARAM_HMACDRBG_ENTROPY', 'ent', 'octet_string'],
+ ['OSSL_KDF_PARAM_HMACDRBG_NONCE', 'nonce', 'octet_string'],
)); -}
static int hmac_drbg_kdf_set_ctx_params(void *vctx,
diff --git a/providers/implementations/kdfs/kbkdf.c.in b/providers/implementations/kdfs/kbkdf.c.in
index 69c3796491..8131e8a56a 100644
--- a/providers/implementations/kdfs/kbkdf.c.in
+++ b/providers/implementations/kdfs/kbkdf.c.in
@@ -369,20 +369,20 @@ done:
}
{- produce_param_decoder('kbkdf_set_ctx_params',
- (['KDF_PARAM_INFO', 'info', 'octet_string', KBKDF_MAX_INFOS],
- ['KDF_PARAM_SALT', 'salt', 'octet_string'],
- ['KDF_PARAM_KEY', 'key', 'octet_string'],
- ['KDF_PARAM_SEED', 'seed', 'octet_string'],
- ['KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['KDF_PARAM_CIPHER', 'cipher', 'utf8_string'],
- ['KDF_PARAM_MAC', 'mac', 'utf8_string'],
- ['KDF_PARAM_MODE', 'mode', 'utf8_string'],
- ['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['KDF_PARAM_KBKDF_USE_L', 'use_l', 'int'],
- ['KDF_PARAM_KBKDF_USE_SEPARATOR', 'sep', 'int'],
- ['KDF_PARAM_KBKDF_R', 'r', 'int'],
- ['KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ (['OSSL_KDF_PARAM_INFO', 'info', 'octet_string', KBKDF_MAX_INFOS],
+ ['OSSL_KDF_PARAM_SALT', 'salt', 'octet_string'],
+ ['OSSL_KDF_PARAM_KEY', 'key', 'octet_string'],
+ ['OSSL_KDF_PARAM_SEED', 'seed', 'octet_string'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_KDF_PARAM_CIPHER', 'cipher', 'utf8_string'],
+ ['OSSL_KDF_PARAM_MAC', 'mac', 'utf8_string'],
+ ['OSSL_KDF_PARAM_MODE', 'mode', 'utf8_string'],
+ ['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_KBKDF_USE_L', 'use_l', 'int'],
+ ['OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR', 'sep', 'int'],
+ ['OSSL_KDF_PARAM_KBKDF_R', 'r', 'int'],
+ ['OSSL_KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
)); -}
static int kbkdf_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -486,8 +486,8 @@ static const OSSL_PARAM *kbkdf_settable_ctx_params(ossl_unused void *ctx,
}
{- produce_param_decoder('kbkdf_get_ctx_params',
- (['KDF_PARAM_SIZE', 'size', 'size_t'],
- ['KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_KDF_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int kbkdf_get_ctx_params(void *vctx, OSSL_PARAM params[])
diff --git a/providers/implementations/kdfs/krb5kdf.c.in b/providers/implementations/kdfs/krb5kdf.c.in
index 25fb96b003..03878b0b3f 100644
--- a/providers/implementations/kdfs/krb5kdf.c.in
+++ b/providers/implementations/kdfs/krb5kdf.c.in
@@ -155,11 +155,11 @@ static int krb5kdf_derive(void *vctx, unsigned char *key, size_t keylen,
}
{- produce_param_decoder('krb5kdf_set_ctx_params',
- (['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['KDF_PARAM_CIPHER', 'cipher', 'utf8_string'],
- ['KDF_PARAM_KEY', 'key', 'octet_string'],
- ['KDF_PARAM_CONSTANT', 'cnst', 'octet_string'],
+ (['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_CIPHER', 'cipher', 'utf8_string'],
+ ['OSSL_KDF_PARAM_KEY', 'key', 'octet_string'],
+ ['OSSL_KDF_PARAM_CONSTANT', 'cnst', 'octet_string'],
)); -}
static int krb5kdf_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -193,7 +193,7 @@ static const OSSL_PARAM *krb5kdf_settable_ctx_params(ossl_unused void *ctx,
}
{- produce_param_decoder('krb5kdf_get_ctx_params',
- (['KDF_PARAM_SIZE', 'size', 'size_t'],
+ (['OSSL_KDF_PARAM_SIZE', 'size', 'size_t'],
)); -}
static int krb5kdf_get_ctx_params(void *vctx, OSSL_PARAM params[])
diff --git a/providers/implementations/kdfs/pbkdf1.c.in b/providers/implementations/kdfs/pbkdf1.c.in
index 12b7b6f8de..3441d33cb4 100644
--- a/providers/implementations/kdfs/pbkdf1.c.in
+++ b/providers/implementations/kdfs/pbkdf1.c.in
@@ -228,12 +228,12 @@ static int kdf_pbkdf1_derive(void *vctx, unsigned char *key, size_t keylen,
}
{- produce_param_decoder('pbkdf1_set_ctx_params',
- (['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['KDF_PARAM_PASSWORD', 'pw', 'octet_string'],
- ['KDF_PARAM_SALT', 'salt', 'octet_string'],
- ['KDF_PARAM_ITER', 'iter', 'uint64'],
+ (['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_KDF_PARAM_PASSWORD', 'pw', 'octet_string'],
+ ['OSSL_KDF_PARAM_SALT', 'salt', 'octet_string'],
+ ['OSSL_KDF_PARAM_ITER', 'iter', 'uint64'],
)); -}
static int kdf_pbkdf1_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -269,7 +269,7 @@ static const OSSL_PARAM *kdf_pbkdf1_settable_ctx_params(ossl_unused void *ctx,
}
{- produce_param_decoder('pbkdf1_get_ctx_params',
- (['KDF_PARAM_SIZE', 'size', 'size_t'],
+ (['OSSL_KDF_PARAM_SIZE', 'size', 'size_t'],
)); -}
static int kdf_pbkdf1_get_ctx_params(void *vctx, OSSL_PARAM params[])
diff --git a/providers/implementations/kdfs/pbkdf2.c.in b/providers/implementations/kdfs/pbkdf2.c.in
index cdffbfc90c..ea62550279 100644
--- a/providers/implementations/kdfs/pbkdf2.c.in
+++ b/providers/implementations/kdfs/pbkdf2.c.in
@@ -283,13 +283,13 @@ static int kdf_pbkdf2_derive(void *vctx, unsigned char *key, size_t keylen,
}
{- produce_param_decoder('pbkdf2_set_ctx_params',
- (['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['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_PKCS5', 'pkcs5', 'int'],
+ (['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_KDF_PARAM_PASSWORD', 'pw', 'octet_string'],
+ ['OSSL_KDF_PARAM_SALT', 'salt', 'octet_string'],
+ ['OSSL_KDF_PARAM_ITER', 'iter', 'uint64'],
+ ['OSSL_KDF_PARAM_PKCS5', 'pkcs5', 'int'],
)); -}
static int kdf_pbkdf2_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -357,8 +357,8 @@ static const OSSL_PARAM *kdf_pbkdf2_settable_ctx_params(ossl_unused void *ctx,
}
{- produce_param_decoder('pbkdf2_get_ctx_params',
- (['KDF_PARAM_SIZE', 'size', 'size_t'],
- ['KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_KDF_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int kdf_pbkdf2_get_ctx_params(void *vctx, OSSL_PARAM params[])
diff --git a/providers/implementations/kdfs/pkcs12kdf.c.in b/providers/implementations/kdfs/pkcs12kdf.c.in
index ff216d8ff5..1495bcd2a6 100644
--- a/providers/implementations/kdfs/pkcs12kdf.c.in
+++ b/providers/implementations/kdfs/pkcs12kdf.c.in
@@ -244,13 +244,13 @@ static int kdf_pkcs12_derive(void *vctx, unsigned char *key, size_t keylen,
}
{- produce_param_decoder('pkcs12_set_ctx_params',
- (['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['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'],
+ (['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_KDF_PARAM_PASSWORD', 'pw', 'octet_string'],
+ ['OSSL_KDF_PARAM_SALT', 'salt', 'octet_string'],
+ ['OSSL_KDF_PARAM_ITER', 'iter', 'uint64'],
+ ['OSSL_KDF_PARAM_PKCS12_ID', 'p12id', 'int'],
)); -}
static int kdf_pkcs12_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -290,7 +290,7 @@ static const OSSL_PARAM *kdf_pkcs12_settable_ctx_params(
}
{- produce_param_decoder('pkcs12_get_ctx_params',
- (['KDF_PARAM_SIZE', 'size', 'size_t'],
+ (['OSSL_KDF_PARAM_SIZE', 'size', 'size_t'],
)); -}
static int kdf_pkcs12_get_ctx_params(void *vctx, OSSL_PARAM params[])
diff --git a/providers/implementations/kdfs/pvkkdf.c.in b/providers/implementations/kdfs/pvkkdf.c.in
index 37073de235..59a67f0e13 100644
--- a/providers/implementations/kdfs/pvkkdf.c.in
+++ b/providers/implementations/kdfs/pvkkdf.c.in
@@ -182,11 +182,11 @@ static int kdf_pvk_derive(void *vctx, unsigned char *key, size_t keylen,
}
{- produce_param_decoder('pvk_set_ctx_params',
- (['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['KDF_PARAM_PASSWORD', 'pass', 'octet_string'],
- ['KDF_PARAM_SALT', 'salt', 'octet_string'],
+ (['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_KDF_PARAM_PASSWORD', 'pass', 'octet_string'],
+ ['OSSL_KDF_PARAM_SALT', 'salt', 'octet_string'],
)); -}
static int kdf_pvk_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -220,7 +220,7 @@ static const OSSL_PARAM *kdf_pvk_settable_ctx_params(ossl_unused void *ctx,
}
{- produce_param_decoder('pvk_get_ctx_params',
- (['KDF_PARAM_SIZE', 'size', 'size_t'],
+ (['OSSL_KDF_PARAM_SIZE', 'size', 'size_t'],
)); -}
static int kdf_pvk_get_ctx_params(void *vctx, OSSL_PARAM params[])
diff --git a/providers/implementations/kdfs/scrypt.c.in b/providers/implementations/kdfs/scrypt.c.in
index 0543d1f594..4462b60dad 100644
--- a/providers/implementations/kdfs/scrypt.c.in
+++ b/providers/implementations/kdfs/scrypt.c.in
@@ -219,13 +219,13 @@ static int is_power_of_two(uint64_t value)
}
{- produce_param_decoder('scrypt_set_ctx_params',
- (['KDF_PARAM_PASSWORD', 'pw', 'octet_string'],
- ['KDF_PARAM_SALT', 'salt', 'octet_string'],
- ['KDF_PARAM_SCRYPT_N', 'n', 'uint64'],
- ['KDF_PARAM_SCRYPT_R', 'r', 'uint32'],
- ['KDF_PARAM_SCRYPT_P', 'p', 'uint32'],
- ['KDF_PARAM_SCRYPT_MAXMEM', 'maxmem', 'uint64'],
- ['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ (['OSSL_KDF_PARAM_PASSWORD', 'pw', 'octet_string'],
+ ['OSSL_KDF_PARAM_SALT', 'salt', 'octet_string'],
+ ['OSSL_KDF_PARAM_SCRYPT_N', 'n', 'uint64'],
+ ['OSSL_KDF_PARAM_SCRYPT_R', 'r', 'uint32'],
+ ['OSSL_KDF_PARAM_SCRYPT_P', 'p', 'uint32'],
+ ['OSSL_KDF_PARAM_SCRYPT_MAXMEM', 'maxmem', 'uint64'],
+ ['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
)); -}
static int kdf_scrypt_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -285,7 +285,7 @@ static const OSSL_PARAM *kdf_scrypt_settable_ctx_params(ossl_unused void *ctx,
}
{- produce_param_decoder('scrypt_get_ctx_params',
- (['KDF_PARAM_SIZE', 'size', 'size_t'],
+ (['OSSL_KDF_PARAM_SIZE', 'size', 'size_t'],
)); -}
static int kdf_scrypt_get_ctx_params(void *vctx, OSSL_PARAM params[])
diff --git a/providers/implementations/kdfs/sshkdf.c.in b/providers/implementations/kdfs/sshkdf.c.in
index 8e09a65ebb..8ef5b688eb 100644
--- a/providers/implementations/kdfs/sshkdf.c.in
+++ b/providers/implementations/kdfs/sshkdf.c.in
@@ -210,15 +210,15 @@ static int kdf_sshkdf_derive(void *vctx, unsigned char *key, size_t keylen,
}
{- produce_param_decoder('sshkdf_set_ctx_params',
- (['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['KDF_PARAM_KEY', 'key', 'octet_string'],
- ['KDF_PARAM_SSHKDF_XCGHASH', 'xcg', 'octet_string'],
- ['KDF_PARAM_SSHKDF_SESSION_ID', 'sid', 'octet_string'],
- ['KDF_PARAM_SSHKDF_TYPE', 'type', 'utf8_string'],
- ['KDF_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
- ['KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ (['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_KDF_PARAM_KEY', 'key', 'octet_string'],
+ ['OSSL_KDF_PARAM_SSHKDF_XCGHASH', 'xcg', 'octet_string'],
+ ['OSSL_KDF_PARAM_SSHKDF_SESSION_ID', 'sid', 'octet_string'],
+ ['OSSL_KDF_PARAM_SSHKDF_TYPE', 'type', 'utf8_string'],
+ ['OSSL_KDF_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
+ ['OSSL_KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
)); -}
static int kdf_sshkdf_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -298,8 +298,8 @@ static const OSSL_PARAM *kdf_sshkdf_settable_ctx_params(ossl_unused void *ctx,
}
{- produce_param_decoder('sshkdf_get_ctx_params',
- (['KDF_PARAM_SIZE', 'size', 'size_t'],
- ['KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_KDF_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int kdf_sshkdf_get_ctx_params(void *vctx, OSSL_PARAM params[])
diff --git a/providers/implementations/kdfs/sskdf.c.in b/providers/implementations/kdfs/sskdf.c.in
index 0928e0e259..3b3cada8d3 100644
--- a/providers/implementations/kdfs/sskdf.c.in
+++ b/providers/implementations/kdfs/sskdf.c.in
@@ -611,16 +611,16 @@ static int sskdf_common_set_ctx_params
#define sskdf_set_ctx_params_st sskdf_all_set_ctx_params_st
{- produce_param_decoder('sskdf_set_ctx_params',
- (['KDF_PARAM_SECRET', 'secret', 'octet_string'],
- ['KDF_PARAM_KEY', 'secret', 'octet_string'],
- ['KDF_PARAM_INFO', 'info', 'octet_string', SSKDF_MAX_INFOS],
- ['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['KDF_PARAM_MAC', 'mac', 'utf8_string'],
- ['KDF_PARAM_SALT', 'salt', 'octet_string'],
- ['KDF_PARAM_MAC_SIZE', 'size', 'size_t'],
- ['KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ (['OSSL_KDF_PARAM_SECRET', 'secret', 'octet_string'],
+ ['OSSL_KDF_PARAM_KEY', 'secret', 'octet_string'],
+ ['OSSL_KDF_PARAM_INFO', 'info', 'octet_string', SSKDF_MAX_INFOS],
+ ['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_KDF_PARAM_MAC', 'mac', 'utf8_string'],
+ ['OSSL_KDF_PARAM_SALT', 'salt', 'octet_string'],
+ ['OSSL_KDF_PARAM_MAC_SIZE', 'size', 'size_t'],
+ ['OSSL_KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
)); -}
static int sskdf_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -653,8 +653,8 @@ static const OSSL_PARAM *sskdf_settable_ctx_params(ossl_unused void *ctx,
}
{- produce_param_decoder('sskdf_get_ctx_params',
- (['KDF_PARAM_SIZE', 'size', 'size_t'],
- ['KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_KDF_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int sskdf_common_get_ctx_params(void *vctx, OSSL_PARAM params[])
@@ -685,17 +685,17 @@ static const OSSL_PARAM *sskdf_common_gettable_ctx_params
#define x963kdf_set_ctx_params_st sskdf_all_set_ctx_params_st
{- produce_param_decoder('x963kdf_set_ctx_params',
- (['KDF_PARAM_SECRET', 'secret', 'octet_string'],
- ['KDF_PARAM_KEY', 'secret', 'octet_string'],
- ['KDF_PARAM_INFO', 'info', 'octet_string', SSKDF_MAX_INFOS],
- ['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['KDF_PARAM_MAC', 'mac', 'utf8_string'],
- ['KDF_PARAM_SALT', 'salt', 'octet_string'],
- ['KDF_PARAM_MAC_SIZE', 'size', 'size_t'],
- ['KDF_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
- ['KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ (['OSSL_KDF_PARAM_SECRET', 'secret', 'octet_string'],
+ ['OSSL_KDF_PARAM_KEY', 'secret', 'octet_string'],
+ ['OSSL_KDF_PARAM_INFO', 'info', 'octet_string', SSKDF_MAX_INFOS],
+ ['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_KDF_PARAM_MAC', 'mac', 'utf8_string'],
+ ['OSSL_KDF_PARAM_SALT', 'salt', 'octet_string'],
+ ['OSSL_KDF_PARAM_MAC_SIZE', 'size', 'size_t'],
+ ['OSSL_KDF_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
+ ['OSSL_KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
)); -}
static int x963kdf_set_ctx_params(void *vctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/kdfs/tls1_prf.c.in b/providers/implementations/kdfs/tls1_prf.c.in
index f1a63eae50..8dc4e44cd6 100644
--- a/providers/implementations/kdfs/tls1_prf.c.in
+++ b/providers/implementations/kdfs/tls1_prf.c.in
@@ -287,14 +287,14 @@ static int kdf_tls1_prf_derive(void *vctx, unsigned char *key, size_t keylen,
}
{- produce_param_decoder('tls1prf_set_ctx_params',
- (['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['KDF_PARAM_SECRET', 'secret', 'octet_string'],
- ['KDF_PARAM_SEED', 'seed', 'octet_string', TLSPRF_MAX_SEEDS],
- ['KDF_PARAM_FIPS_EMS_CHECK', 'ind_e', 'int', 'fips'],
- ['KDF_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
- ['KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ (['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_KDF_PARAM_SECRET', 'secret', 'octet_string'],
+ ['OSSL_KDF_PARAM_SEED', 'seed', 'octet_string', TLSPRF_MAX_SEEDS],
+ ['OSSL_KDF_PARAM_FIPS_EMS_CHECK', 'ind_e', 'int', 'fips'],
+ ['OSSL_KDF_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
+ ['OSSL_KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
)); -}
static int kdf_tls1_prf_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -429,8 +429,8 @@ static const OSSL_PARAM *kdf_tls1_prf_settable_ctx_params(
}
{- produce_param_decoder('tls1prf_get_ctx_params',
- (['KDF_PARAM_SIZE', 'size', 'size_t'],
- ['KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_KDF_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int kdf_tls1_prf_get_ctx_params(void *vctx, OSSL_PARAM params[])
diff --git a/providers/implementations/kdfs/x942kdf.c.in b/providers/implementations/kdfs/x942kdf.c.in
index e71ab93b78..5b4dd08609 100644
--- a/providers/implementations/kdfs/x942kdf.c.in
+++ b/providers/implementations/kdfs/x942kdf.c.in
@@ -530,20 +530,20 @@ static int x942kdf_derive(void *vctx, unsigned char *key, size_t keylen,
}
{- produce_param_decoder('sshkdf_set_ctx_params',
- (['KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['KDF_PARAM_SECRET', 'secret', 'octet_string'],
- ['KDF_PARAM_KEY', 'secret', 'octet_string'],
- ['KDF_PARAM_UKM', 'uinfo', 'octet_string'],
- ['KDF_PARAM_X942_ACVPINFO', 'acvp', 'octet_string'],
- ['KDF_PARAM_X942_PARTYUINFO', 'uinfo', 'octet_string'],
- ['KDF_PARAM_X942_PARTYVINFO', 'vinfo', 'octet_string'],
- ['KDF_PARAM_X942_SUPP_PUBINFO', 'pub', 'octet_string'],
- ['KDF_PARAM_X942_SUPP_PRIVINFO', 'priv', 'octet_string'],
- ['KDF_PARAM_X942_USE_KEYBITS', 'kbits', 'int'],
- ['KDF_PARAM_CEK_ALG', 'cekalg', 'utf8_string'],
- ['KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ (['OSSL_KDF_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_KDF_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_KDF_PARAM_SECRET', 'secret', 'octet_string'],
+ ['OSSL_KDF_PARAM_KEY', 'secret', 'octet_string'],
+ ['OSSL_KDF_PARAM_UKM', 'uinfo', 'octet_string'],
+ ['OSSL_KDF_PARAM_X942_ACVPINFO', 'acvp', 'octet_string'],
+ ['OSSL_KDF_PARAM_X942_PARTYUINFO', 'uinfo', 'octet_string'],
+ ['OSSL_KDF_PARAM_X942_PARTYVINFO', 'vinfo', 'octet_string'],
+ ['OSSL_KDF_PARAM_X942_SUPP_PUBINFO', 'pub', 'octet_string'],
+ ['OSSL_KDF_PARAM_X942_SUPP_PRIVINFO', 'priv', 'octet_string'],
+ ['OSSL_KDF_PARAM_X942_USE_KEYBITS', 'kbits', 'int'],
+ ['OSSL_KDF_PARAM_CEK_ALG', 'cekalg', 'utf8_string'],
+ ['OSSL_KDF_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
)); -}
static int x942kdf_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -629,8 +629,8 @@ static const OSSL_PARAM *x942kdf_settable_ctx_params(ossl_unused void *ctx,
}
{- produce_param_decoder('sshkdf_get_ctx_params',
- (['KDF_PARAM_SIZE', 'size', 'size_t'],
- ['KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_KDF_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int x942kdf_get_ctx_params(void *vctx, OSSL_PARAM params[])
diff --git a/providers/implementations/kem/ec_kem.c.in b/providers/implementations/kem/ec_kem.c.in
index ef73e9ceb3..370ef833ad 100644
--- a/providers/implementations/kem/ec_kem.c.in
+++ b/providers/implementations/kem/ec_kem.c.in
@@ -290,8 +290,8 @@ static int eckem_auth_decapsulate_init(void *vctx, void *vecx, void *vauthpub,
{- produce_param_decoder('eckem_set_ctx_params',
- (['KEM_PARAM_OPERATION', 'op', 'utf8_string'],
- ['KEM_PARAM_IKME', 'ikme', 'octet_string'],
+ (['OSSL_KEM_PARAM_OPERATION', 'op', 'utf8_string'],
+ ['OSSL_KEM_PARAM_IKME', 'ikme', 'octet_string'],
)); -}
static int eckem_set_ctx_params(void *vctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/kem/ecx_kem.c.in b/providers/implementations/kem/ecx_kem.c.in
index 7458664e9a..bb9037dc4d 100644
--- a/providers/implementations/kem/ecx_kem.c.in
+++ b/providers/implementations/kem/ecx_kem.c.in
@@ -245,8 +245,8 @@ static int ecxkem_auth_decapsulate_init(void *vctx, void *vecx, void *vauthpub,
}
{- produce_param_decoder('ecxkem_set_ctx_params',
- (['KEM_PARAM_OPERATION', 'op', 'utf8_string'],
- ['KEM_PARAM_IKME', 'ikme', 'octet_string'],
+ (['OSSL_KEM_PARAM_OPERATION', 'op', 'utf8_string'],
+ ['OSSL_KEM_PARAM_IKME', 'ikme', 'octet_string'],
)); -}
static int ecxkem_set_ctx_params(void *vctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/kem/ml_kem_kem.c.in b/providers/implementations/kem/ml_kem_kem.c.in
index 5c361ae889..1c9a816e02 100644
--- a/providers/implementations/kem/ml_kem_kem.c.in
+++ b/providers/implementations/kem/ml_kem_kem.c.in
@@ -100,7 +100,7 @@ static int ml_kem_decapsulate_init(void *vctx, void *vkey,
}
{- produce_param_decoder('ml_kem_set_ctx_params',
- (['KEM_PARAM_IKME', 'ikme', 'octet_string'],
+ (['OSSL_KEM_PARAM_IKME', 'ikme', 'octet_string'],
)); -}
static int ml_kem_set_ctx_params(void *vctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/kem/rsa_kem.c.in b/providers/implementations/kem/rsa_kem.c.in
index 9a0d6434c1..1613dd7307 100644
--- a/providers/implementations/kem/rsa_kem.c.in
+++ b/providers/implementations/kem/rsa_kem.c.in
@@ -177,7 +177,7 @@ static int rsakem_decapsulate_init(void *vprsactx, void *vrsa,
}
{- produce_param_decoder('rsakem_get_ctx_params',
- (['KEM_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_KEM_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int rsakem_get_ctx_params(void *vprsactx, OSSL_PARAM *params)
@@ -200,8 +200,8 @@ static const OSSL_PARAM *rsakem_gettable_ctx_params(ossl_unused void *vprsactx,
}
{- produce_param_decoder('rsakem_set_ctx_params',
- (['KEM_PARAM_OPERATION', 'op', 'utf8_string'],
- ['KEM_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ (['OSSL_KEM_PARAM_OPERATION', 'op', 'utf8_string'],
+ ['OSSL_KEM_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
)); -}
static int rsakem_set_ctx_params(void *vprsactx, const OSSL_PARAM params[])
diff --git a/providers/implementations/keymgmt/dh_kmgmt.c.in b/providers/implementations/keymgmt/dh_kmgmt.c.in
index 740d38c1bf..44e8999903 100644
--- a/providers/implementations/keymgmt/dh_kmgmt.c.in
+++ b/providers/implementations/keymgmt/dh_kmgmt.c.in
@@ -334,23 +334,23 @@ struct dh_params_st {
#define dh_get_params_st dh_params_st
{- produce_param_decoder('dh_get_params',
- (['PKEY_PARAM_BITS', 'bits', 'int'],
- ['PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
- ['PKEY_PARAM_MAX_SIZE', 'maxsize', 'int'],
- ['PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
- ['PKEY_PARAM_ENCODED_PUBLIC_KEY', 'encpubkey', 'octet_string'],
- ['PKEY_PARAM_FFC_P', 'ffp.p', 'BN'],
- ['PKEY_PARAM_FFC_Q', 'ffp.q', 'BN'],
- ['PKEY_PARAM_FFC_G', 'ffp.g', 'BN'],
- ['PKEY_PARAM_FFC_COFACTOR', 'ffp.cofactor', 'BN'],
- ['PKEY_PARAM_FFC_GINDEX', 'ffp.g_index', 'int'],
- ['PKEY_PARAM_FFC_PCOUNTER', 'ffp.p_counter', 'int'],
- ['PKEY_PARAM_FFC_H', 'ffp.h', 'int'],
- ['PKEY_PARAM_DH_PRIV_LEN', 'privlen', 'int'],
- ['PKEY_PARAM_FFC_SEED', 'ffp.seed', 'octet_string'],
- ['PKEY_PARAM_GROUP_NAME', 'ffp.group_name', 'utf8_string'],
- ['PKEY_PARAM_PUB_KEY', 'pubkey', 'BN'],
- ['PKEY_PARAM_PRIV_KEY', 'privkey', 'BN'],
+ (['OSSL_PKEY_PARAM_BITS', 'bits', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
+ ['OSSL_PKEY_PARAM_MAX_SIZE', 'maxsize', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
+ ['OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY', 'encpubkey', 'octet_string'],
+ ['OSSL_PKEY_PARAM_FFC_P', 'ffp.p', 'BN'],
+ ['OSSL_PKEY_PARAM_FFC_Q', 'ffp.q', 'BN'],
+ ['OSSL_PKEY_PARAM_FFC_G', 'ffp.g', 'BN'],
+ ['OSSL_PKEY_PARAM_FFC_COFACTOR', 'ffp.cofactor', 'BN'],
+ ['OSSL_PKEY_PARAM_FFC_GINDEX', 'ffp.g_index', 'int'],
+ ['OSSL_PKEY_PARAM_FFC_PCOUNTER', 'ffp.p_counter', 'int'],
+ ['OSSL_PKEY_PARAM_FFC_H', 'ffp.h', 'int'],
+ ['OSSL_PKEY_PARAM_DH_PRIV_LEN', 'privlen', 'int'],
+ ['OSSL_PKEY_PARAM_FFC_SEED', 'ffp.seed', 'octet_string'],
+ ['OSSL_PKEY_PARAM_GROUP_NAME', 'ffp.group_name', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_PUB_KEY', 'pubkey', 'BN'],
+ ['OSSL_PKEY_PARAM_PRIV_KEY', 'privkey', 'BN'],
)); -}
static int dh_get_params(void *key, OSSL_PARAM params[])
@@ -393,7 +393,7 @@ static const OSSL_PARAM *dh_gettable_params(void *provctx)
}
{- produce_param_decoder('dh_set_params',
- (['PKEY_PARAM_ENCODED_PUBLIC_KEY', 'encpubkey', 'octet_string'],
+ (['OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY', 'encpubkey', 'octet_string'],
)); -}
static const OSSL_PARAM *dh_settable_params(void *provctx)
@@ -580,35 +580,35 @@ struct dh_gen_set_params_st {
#define dhx_gen_set_params_st dh_gen_set_params_st
{- produce_param_decoder('dhx_gen_set_params',
- (['PKEY_PARAM_FFC_TYPE', 'type', 'utf8_string'],
- ['PKEY_PARAM_GROUP_NAME', 'group_name', 'utf8_string'],
- ['PKEY_PARAM_DH_PRIV_LEN', 'privlen', 'int'],
- ['PKEY_PARAM_FFC_PBITS', 'pbits', 'size_t'],
- ['PKEY_PARAM_FFC_QBITS', 'qbits', 'size_t'],
- ['PKEY_PARAM_FFC_DIGEST', 'digest', 'utf8_string'],
- ['PKEY_PARAM_FFC_DIGEST_PROPS', 'propq', 'utf8_string'],
- ['PKEY_PARAM_FFC_GINDEX', 'g_index', 'int'],
- ['PKEY_PARAM_FFC_SEED', 'seed', 'octet_string'],
- ['PKEY_PARAM_FFC_PCOUNTER', 'p_counter', 'int'],
- ['PKEY_PARAM_FFC_H', 'h', 'int'],
- ['PKEY_PARAM_DH_GENERATOR', 'invalid param'],
+ (['OSSL_PKEY_PARAM_FFC_TYPE', 'type', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_GROUP_NAME', 'group_name', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_DH_PRIV_LEN', 'privlen', 'int'],
+ ['OSSL_PKEY_PARAM_FFC_PBITS', 'pbits', 'size_t'],
+ ['OSSL_PKEY_PARAM_FFC_QBITS', 'qbits', 'size_t'],
+ ['OSSL_PKEY_PARAM_FFC_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_FFC_DIGEST_PROPS', 'propq', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_FFC_GINDEX', 'g_index', 'int'],
+ ['OSSL_PKEY_PARAM_FFC_SEED', 'seed', 'octet_string'],
+ ['OSSL_PKEY_PARAM_FFC_PCOUNTER', 'p_counter', 'int'],
+ ['OSSL_PKEY_PARAM_FFC_H', 'h', 'int'],
+ ['OSSL_PKEY_PARAM_DH_GENERATOR', 'invalid param'],
)); -}
#define dh_gen_set_params_st dh_gen_set_params_st
{- produce_param_decoder('dh_gen_set_params',
- (['PKEY_PARAM_FFC_TYPE', 'type', 'utf8_string'],
- ['PKEY_PARAM_GROUP_NAME', 'group_name', 'utf8_string'],
- ['PKEY_PARAM_DH_PRIV_LEN', 'privlen', 'int'],
- ['PKEY_PARAM_FFC_PBITS', 'pbits', 'size_t'],
- ['PKEY_PARAM_DH_GENERATOR', 'generator', 'int'],
- ['PKEY_PARAM_FFC_GINDEX', 'invalid param'],
- ['PKEY_PARAM_FFC_PCOUNTER', 'invalid param'],
- ['PKEY_PARAM_FFC_H', 'invalid param'],
- ['PKEY_PARAM_FFC_SEED', 'invalid param'],
- ['PKEY_PARAM_FFC_QBITS', 'invalid param'],
- ['PKEY_PARAM_FFC_DIGEST', 'invalid param'],
- ['PKEY_PARAM_FFC_DIGEST_PROPS', 'invalid param'],
+ (['OSSL_PKEY_PARAM_FFC_TYPE', 'type', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_GROUP_NAME', 'group_name', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_DH_PRIV_LEN', 'privlen', 'int'],
+ ['OSSL_PKEY_PARAM_FFC_PBITS', 'pbits', 'size_t'],
+ ['OSSL_PKEY_PARAM_DH_GENERATOR', 'generator', 'int'],
+ ['OSSL_PKEY_PARAM_FFC_GINDEX', 'invalid param'],
+ ['OSSL_PKEY_PARAM_FFC_PCOUNTER', 'invalid param'],
+ ['OSSL_PKEY_PARAM_FFC_H', 'invalid param'],
+ ['OSSL_PKEY_PARAM_FFC_SEED', 'invalid param'],
+ ['OSSL_PKEY_PARAM_FFC_QBITS', 'invalid param'],
+ ['OSSL_PKEY_PARAM_FFC_DIGEST', 'invalid param'],
+ ['OSSL_PKEY_PARAM_FFC_DIGEST_PROPS', 'invalid param'],
)); -}
static int dh_gen_common_set_params(struct dh_gen_ctx *gctx,
diff --git a/providers/implementations/keymgmt/dsa_kmgmt.c.in b/providers/implementations/keymgmt/dsa_kmgmt.c.in
index d636f28a67..d329b6ab89 100644
--- a/providers/implementations/keymgmt/dsa_kmgmt.c.in
+++ b/providers/implementations/keymgmt/dsa_kmgmt.c.in
@@ -330,21 +330,21 @@ struct dsa_params_st {
#define dsa_get_params_st dsa_params_st
{- produce_param_decoder('dsa_get_params',
- (['PKEY_PARAM_BITS', 'bits', 'int'],
- ['PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
- ['PKEY_PARAM_MAX_SIZE', 'maxsize', 'int'],
- ['PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
- ['PKEY_PARAM_DEFAULT_DIGEST', 'digest', 'utf8_string'],
- ['PKEY_PARAM_FFC_P', 'ffp.p', 'BN'],
- ['PKEY_PARAM_FFC_Q', 'ffp.q', 'BN'],
- ['PKEY_PARAM_FFC_G', 'ffp.g', 'BN'],
- ['PKEY_PARAM_FFC_COFACTOR', 'ffp.cofactor', 'BN'],
- ['PKEY_PARAM_FFC_GINDEX', 'ffp.g_index', 'int'],
- ['PKEY_PARAM_FFC_PCOUNTER', 'ffp.p_counter', 'int'],
- ['PKEY_PARAM_FFC_H', 'ffp.h', 'int'],
- ['PKEY_PARAM_FFC_SEED', 'ffp.seed', 'octet_string'],
- ['PKEY_PARAM_PUB_KEY', 'pubkey', 'BN'],
- ['PKEY_PARAM_PRIV_KEY', 'privkey', 'BN'],
+ (['OSSL_PKEY_PARAM_BITS', 'bits', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
+ ['OSSL_PKEY_PARAM_MAX_SIZE', 'maxsize', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
+ ['OSSL_PKEY_PARAM_DEFAULT_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_FFC_P', 'ffp.p', 'BN'],
+ ['OSSL_PKEY_PARAM_FFC_Q', 'ffp.q', 'BN'],
+ ['OSSL_PKEY_PARAM_FFC_G', 'ffp.g', 'BN'],
+ ['OSSL_PKEY_PARAM_FFC_COFACTOR', 'ffp.cofactor', 'BN'],
+ ['OSSL_PKEY_PARAM_FFC_GINDEX', 'ffp.g_index', 'int'],
+ ['OSSL_PKEY_PARAM_FFC_PCOUNTER', 'ffp.p_counter', 'int'],
+ ['OSSL_PKEY_PARAM_FFC_H', 'ffp.h', 'int'],
+ ['OSSL_PKEY_PARAM_FFC_SEED', 'ffp.seed', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PUB_KEY', 'pubkey', 'BN'],
+ ['OSSL_PKEY_PARAM_PRIV_KEY', 'privkey', 'BN'],
)); -}
static ossl_inline int dsa_get_params(void *key, OSSL_PARAM params[])
@@ -493,16 +493,16 @@ static int dsa_set_gen_seed(struct dsa_gen_ctx *gctx, unsigned char *seed,
}
{- produce_param_decoder('dsa_gen_set_params',
- (['PKEY_PARAM_FFC_TYPE', 'type', 'utf8_string'],
- ['PKEY_PARAM_FFC_PBITS', 'pbits', 'size_t'],
- ['PKEY_PARAM_FFC_QBITS', 'qbits', 'size_t'],
- ['PKEY_PARAM_FFC_DIGEST', 'digest', 'utf8_string'],
- ['PKEY_PARAM_FFC_DIGEST_PROPS', 'propq', 'utf8_string'],
- ['PKEY_PARAM_FFC_GINDEX', 'g_index', 'int'],
- ['PKEY_PARAM_FFC_SEED', 'seed', 'octet_string'],
- ['PKEY_PARAM_FFC_PCOUNTER', 'p_counter', 'int'],
- ['PKEY_PARAM_FFC_H', 'h', 'int'],
- ['PKEY_PARAM_FIPS_SIGN_CHECK', 'ind_sign', 'int', 'fips'],
+ (['OSSL_PKEY_PARAM_FFC_TYPE', 'type', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_FFC_PBITS', 'pbits', 'size_t'],
+ ['OSSL_PKEY_PARAM_FFC_QBITS', 'qbits', 'size_t'],
+ ['OSSL_PKEY_PARAM_FFC_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_FFC_DIGEST_PROPS', 'propq', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_FFC_GINDEX', 'g_index', 'int'],
+ ['OSSL_PKEY_PARAM_FFC_SEED', 'seed', 'octet_string'],
+ ['OSSL_PKEY_PARAM_FFC_PCOUNTER', 'p_counter', 'int'],
+ ['OSSL_PKEY_PARAM_FFC_H', 'h', 'int'],
+ ['OSSL_PKEY_PARAM_FIPS_SIGN_CHECK', 'ind_sign', 'int', 'fips'],
)); -}
static int dsa_gen_set_params(void *genctx, const OSSL_PARAM params[])
@@ -581,7 +581,7 @@ static const OSSL_PARAM *dsa_gen_settable_params(ossl_unused void *genctx,
}
{- produce_param_decoder('dsa_gen_get_params',
- (['PKEY_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_PKEY_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int dsa_gen_get_params(void *genctx, OSSL_PARAM *params)
diff --git a/providers/implementations/keymgmt/ecx_kmgmt.c.in b/providers/implementations/keymgmt/ecx_kmgmt.c.in
index 932b573ff6..1a75cd1c32 100644
--- a/providers/implementations/keymgmt/ecx_kmgmt.c.in
+++ b/providers/implementations/keymgmt/ecx_kmgmt.c.in
@@ -207,8 +207,8 @@ static int ecx_match(const void *keydata1, const void *keydata2, int selection)
}
{- produce_param_decoder('ecx_imexport_types',
- (['PKEY_PARAM_PUB_KEY', 'pub', 'octet_string'],
- ['PKEY_PARAM_PRIV_KEY', 'priv', 'octet_string'],
+ (['OSSL_PKEY_PARAM_PUB_KEY', 'pub', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PRIV_KEY', 'priv', 'octet_string'],
)); -}
static int ecx_import(void *keydata, int selection, const OSSL_PARAM params[])
@@ -319,26 +319,26 @@ struct ecx_ed_common_get_params_st {
#define ecx_get_params_st ecx_ed_common_get_params_st
{- produce_param_decoder('ecx_get_params',
- (['PKEY_PARAM_BITS', 'bits', 'int'],
- ['PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
- ['PKEY_PARAM_MAX_SIZE', 'size', 'int'],
- ['PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
- ['PKEY_PARAM_PUB_KEY', 'pub', 'octet_string'],
- ['PKEY_PARAM_PRIV_KEY', 'priv', 'octet_string'],
- ['PKEY_PARAM_ENCODED_PUBLIC_KEY', 'encpub', 'octet_string'],
- ['PKEY_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_PKEY_PARAM_BITS', 'bits', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
+ ['OSSL_PKEY_PARAM_MAX_SIZE', 'size', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
+ ['OSSL_PKEY_PARAM_PUB_KEY', 'pub', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PRIV_KEY', 'priv', 'octet_string'],
+ ['OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY', 'encpub', 'octet_string'],
+ ['OSSL_PKEY_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
#define ed_get_params_st ecx_ed_common_get_params_st
{- produce_param_decoder('ed_get_params',
- (['PKEY_PARAM_BITS', 'bits', 'int'],
- ['PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
- ['PKEY_PARAM_MAX_SIZE', 'size', 'int'],
- ['PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
- ['PKEY_PARAM_PUB_KEY', 'pub', 'octet_string'],
- ['PKEY_PARAM_PRIV_KEY', 'priv', 'octet_string'],
- ['PKEY_PARAM_MANDATORY_DIGEST', 'digest', 'utf8_string'],
+ (['OSSL_PKEY_PARAM_BITS', 'bits', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
+ ['OSSL_PKEY_PARAM_MAX_SIZE', 'size', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
+ ['OSSL_PKEY_PARAM_PUB_KEY', 'pub', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PRIV_KEY', 'priv', 'octet_string'],
+ ['OSSL_PKEY_PARAM_MANDATORY_DIGEST', 'digest', 'utf8_string'],
)); -}
/* This getter is shared by ED25519, ED448, X25519 and X448 */
@@ -454,8 +454,8 @@ static int set_property_query(ECX_KEY *ecxkey, const char *propq)
}
{- produce_param_decoder('ecx_set_params',
- (['PKEY_PARAM_ENCODED_PUBLIC_KEY', 'pub', 'octet_string'],
- ['PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ (['OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY', 'pub', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
)); -}
static int ecx_set_params(void *key, const OSSL_PARAM params[])
@@ -588,9 +588,9 @@ static void *ed448_gen_init(void *provctx, int selection,
}
{- produce_param_decoder('ecx_gen_set_params',
- (['PKEY_PARAM_GROUP_NAME', 'group', 'utf8_string'],
- ['KDF_PARAM_PROPERTIES', 'kdfpropq', 'utf8_string'],
- ['PKEY_PARAM_DHKEM_IKM', 'ikm', 'octet_string'],
+ (['OSSL_PKEY_PARAM_GROUP_NAME', 'group', 'utf8_string'],
+ ['OSSL_KDF_PARAM_PROPERTIES', 'kdfpropq', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_DHKEM_IKM', 'ikm', 'octet_string'],
)); -}
static int ecx_gen_set_params(void *genctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/keymgmt/lms_kmgmt.c.in b/providers/implementations/keymgmt/lms_kmgmt.c.in
index 7ba2c9d229..8b6a941444 100644
--- a/providers/implementations/keymgmt/lms_kmgmt.c.in
+++ b/providers/implementations/keymgmt/lms_kmgmt.c.in
@@ -68,7 +68,7 @@ static int lms_match(const void *keydata1, const void *keydata2, int selection)
}
{- produce_param_decoder('lms_import',
- (['PKEY_PARAM_PUB_KEY', 'pub', 'octet_string'],
+ (['OSSL_PKEY_PARAM_PUB_KEY', 'pub', 'octet_string'],
)); -}
static int lms_import(void *keydata, int selection, const OSSL_PARAM params[])
diff --git a/providers/implementations/keymgmt/mac_legacy_kmgmt.c.in b/providers/implementations/keymgmt/mac_legacy_kmgmt.c.in
index 630cd9771b..2eefe6bc9a 100644
--- a/providers/implementations/keymgmt/mac_legacy_kmgmt.c.in
+++ b/providers/implementations/keymgmt/mac_legacy_kmgmt.c.in
@@ -235,8 +235,8 @@ static int mac_key_fromdata(MAC_KEY *key, const struct mac_common_params_st *p)
#define mac_import_st mac_common_params_st
{- produce_param_decoder('mac_import',
- (['PKEY_PARAM_PRIV_KEY', 'key', 'octet_string'],
- ['PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ (['OSSL_PKEY_PARAM_PRIV_KEY', 'key', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
)); -}
static int mac_import(void *keydata, int selection, const OSSL_PARAM params[])
@@ -263,10 +263,10 @@ static const OSSL_PARAM *mac_imexport_types(int selection)
#define cmac_import_st mac_common_params_st
{- produce_param_decoder('cmac_import',
- (['PKEY_PARAM_PRIV_KEY', 'key', 'octet_string'],
- ['PKEY_PARAM_CIPHER', 'cipher', 'utf8_string'],
- ['PKEY_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ (['OSSL_PKEY_PARAM_PRIV_KEY', 'key', 'octet_string'],
+ ['OSSL_PKEY_PARAM_CIPHER', 'cipher', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
)); -}
static int cmac_import(void *keydata, int selection, const OSSL_PARAM params[])
@@ -356,7 +356,7 @@ err:
#define mac_get_params_st mac_common_params_st
{- produce_param_decoder('mac_get_params',
- (['PKEY_PARAM_PRIV_KEY', 'key', 'octet_string'],
+ (['OSSL_PKEY_PARAM_PRIV_KEY', 'key', 'octet_string'],
)); -}
static int mac_get_params(void *keydata, OSSL_PARAM params[])
@@ -378,9 +378,9 @@ static const OSSL_PARAM *mac_gettable_params(void *provctx)
#define cmac_get_params_st mac_common_params_st
{- produce_param_decoder('cmac_get_params',
- (['PKEY_PARAM_PRIV_KEY', 'key', 'octet_string'],
- ['PKEY_PARAM_CIPHER', 'cipher', 'utf8_string'],
- ['PKEY_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ (['OSSL_PKEY_PARAM_PRIV_KEY', 'key', 'octet_string'],
+ ['OSSL_PKEY_PARAM_CIPHER', 'cipher', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
)); -}
static int cmac_get_params(void *keydata, OSSL_PARAM params[])
@@ -403,7 +403,7 @@ static const OSSL_PARAM *cmac_gettable_params(void *provctx)
#define mac_set_params_st mac_common_params_st
{- produce_param_decoder('mac_set_params',
- (['PKEY_PARAM_PRIV_KEY', 'key', 'octet_string'],
+ (['OSSL_PKEY_PARAM_PRIV_KEY', 'key', 'octet_string'],
)); -}
static int mac_set_params(void *keydata, const OSSL_PARAM params[])
@@ -485,7 +485,7 @@ static int mac_gen_set_params_common(struct mac_gen_ctx *gctx,
#define mac_gen_set_params_st mac_common_params_st
{- produce_param_decoder('mac_gen_set_params',
- (['PKEY_PARAM_PRIV_KEY', 'key', 'octet_string'],
+ (['OSSL_PKEY_PARAM_PRIV_KEY', 'key', 'octet_string'],
)); -}
static int mac_gen_set_params(void *genctx, const OSSL_PARAM params[])
@@ -502,10 +502,10 @@ static int mac_gen_set_params(void *genctx, const OSSL_PARAM params[])
#define cmac_gen_set_params_st mac_common_params_st
{- produce_param_decoder('cmac_gen_set_params',
- (['PKEY_PARAM_PRIV_KEY', 'key', 'octet_string'],
- ['PKEY_PARAM_CIPHER', 'cipher', 'utf8_string'],
- ['PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['PKEY_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ (['OSSL_PKEY_PARAM_PRIV_KEY', 'key', 'octet_string'],
+ ['OSSL_PKEY_PARAM_CIPHER', 'cipher', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
)); -}
static int cmac_gen_set_params(void *genctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/keymgmt/ml_dsa_kmgmt.c.in b/providers/implementations/keymgmt/ml_dsa_kmgmt.c.in
index fb1005918d..9a550133cb 100644
--- a/providers/implementations/keymgmt/ml_dsa_kmgmt.c.in
+++ b/providers/implementations/keymgmt/ml_dsa_kmgmt.c.in
@@ -183,9 +183,9 @@ static int ml_dsa_validate(const void *key_data, int selection, int check_type)
}
{- produce_param_decoder('ml_dsa_key_type_params',
- (['PKEY_PARAM_ML_DSA_SEED', 'seed', 'octet_string'],
- ['PKEY_PARAM_PUB_KEY', 'pubkey', 'octet_string'],
- ['PKEY_PARAM_PRIV_KEY', 'privkey', 'octet_string'],
+ (['OSSL_PKEY_PARAM_ML_DSA_SEED', 'seed', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PUB_KEY', 'pubkey', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PRIV_KEY', 'privkey', 'octet_string'],
)); -}
/**
@@ -311,14 +311,14 @@ static const OSSL_PARAM *ml_dsa_imexport_types(int selection)
}
{- produce_param_decoder('ml_dsa_get_params',
- (['PKEY_PARAM_BITS', 'bits', 'int'],
- ['PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
- ['PKEY_PARAM_MAX_SIZE', 'maxsize', 'int'],
- ['PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
- ['PKEY_PARAM_MANDATORY_DIGEST', 'dgstp', 'utf8_string'],
- ['PKEY_PARAM_ML_DSA_SEED', 'seed', 'octet_string'],
- ['PKEY_PARAM_PUB_KEY', 'pubkey', 'octet_string'],
- ['PKEY_PARAM_PRIV_KEY', 'privkey', 'octet_string'],
+ (['OSSL_PKEY_PARAM_BITS', 'bits', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
+ ['OSSL_PKEY_PARAM_MAX_SIZE', 'maxsize', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
+ ['OSSL_PKEY_PARAM_MANDATORY_DIGEST', 'dgstp', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_ML_DSA_SEED', 'seed', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PUB_KEY', 'pubkey', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PRIV_KEY', 'privkey', 'octet_string'],
)); -}
static const OSSL_PARAM *ml_dsa_gettable_params(void *provctx)
@@ -520,8 +520,8 @@ static void *ml_dsa_gen(void *genctx, int evp_type)
}
{- produce_param_decoder('ml_dsa_gen_set_params',
- (['PKEY_PARAM_ML_DSA_SEED', 'seed', 'octet_string'],
- ['PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ (['OSSL_PKEY_PARAM_ML_DSA_SEED', 'seed', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
)); -}
static int ml_dsa_gen_set_params(void *genctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/keymgmt/ml_kem_kmgmt.c.in b/providers/implementations/keymgmt/ml_kem_kmgmt.c.in
index 8b995015ba..e92241a845 100644
--- a/providers/implementations/keymgmt/ml_kem_kmgmt.c.in
+++ b/providers/implementations/keymgmt/ml_kem_kmgmt.c.in
@@ -333,9 +333,9 @@ err:
}
{- produce_param_decoder('ml_kem_key_type_params',
- (['PKEY_PARAM_ML_KEM_SEED', 'seed', 'octet_string'],
- ['PKEY_PARAM_PRIV_KEY', 'privkey', 'octet_string'],
- ['PKEY_PARAM_PUB_KEY', 'pubkey', 'octet_string'],
+ (['OSSL_PKEY_PARAM_ML_KEM_SEED', 'seed', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PRIV_KEY', 'privkey', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PUB_KEY', 'pubkey', 'octet_string'],
)); -}
static const OSSL_PARAM *ml_kem_imexport_types(int selection)
@@ -491,16 +491,16 @@ static int ml_kem_import(void *vkey, int selection, const OSSL_PARAM params[])
}
{- produce_param_decoder('ml_kem_get_params',
- (['PKEY_PARAM_BITS', 'bits', 'int'],
- ['PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
- ['PKEY_PARAM_MAX_SIZE', 'maxsize', 'int'],
- ['PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
- ['PKEY_PARAM_ML_KEM_SEED', 'seed', 'octet_string'],
- ['PKEY_PARAM_PRIV_KEY', 'privkey', 'octet_string'],
- ['PKEY_PARAM_PUB_KEY', 'pubkey', 'octet_string'],
- ['PKEY_PARAM_ENCODED_PUBLIC_KEY', 'encpubkey', 'octet_string'],
- ['PKEY_PARAM_CMS_RI_TYPE', 'ri_type', 'int'],
- ['PKEY_PARAM_CMS_KEMRI_KDF_ALGORITHM', 'kemri_kdf_alg', 'octet_string'],
+ (['OSSL_PKEY_PARAM_BITS', 'bits', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
+ ['OSSL_PKEY_PARAM_MAX_SIZE', 'maxsize', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
+ ['OSSL_PKEY_PARAM_ML_KEM_SEED', 'seed', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PRIV_KEY', 'privkey', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PUB_KEY', 'pubkey', 'octet_string'],
+ ['OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY', 'encpubkey', 'octet_string'],
+ ['OSSL_PKEY_PARAM_CMS_RI_TYPE', 'ri_type', 'int'],
+ ['OSSL_PKEY_PARAM_CMS_KEMRI_KDF_ALGORITHM', 'kemri_kdf_alg', 'octet_string'],
)); -}
static const OSSL_PARAM *ml_kem_gettable_params(void *provctx)
@@ -658,7 +658,7 @@ static int ml_kem_get_params(void *vkey, OSSL_PARAM params[])
}
{- produce_param_decoder('ml_kem_set_params',
- (['PKEY_PARAM_ENCODED_PUBLIC_KEY', 'pub', 'octet_string'],
+ (['OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY', 'pub', 'octet_string'],
)); -}
static const OSSL_PARAM *ml_kem_settable_params(void *provctx)
@@ -699,8 +699,8 @@ static int ml_kem_set_params(void *vkey, const OSSL_PARAM params[])
}
{- produce_param_decoder('ml_kem_gen_set_params',
- (['PKEY_PARAM_ML_DSA_SEED', 'seed', 'octet_string'],
- ['PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ (['OSSL_PKEY_PARAM_ML_DSA_SEED', 'seed', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
)); -}
static int ml_kem_gen_set_params(void *vgctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/keymgmt/mlx_kmgmt.c.in b/providers/implementations/keymgmt/mlx_kmgmt.c.in
index 7738b2d454..b52bd343df 100644
--- a/providers/implementations/keymgmt/mlx_kmgmt.c.in
+++ b/providers/implementations/keymgmt/mlx_kmgmt.c.in
@@ -148,8 +148,8 @@ static int mlx_kem_match(const void *vkey1, const void *vkey2, int selection)
}
{- produce_param_decoder('ml_kem_import_export',
- (['PKEY_PARAM_PRIV_KEY', 'privkey', 'octet_string'],
- ['PKEY_PARAM_PUB_KEY', 'pubkey', 'octet_string'],
+ (['OSSL_PKEY_PARAM_PRIV_KEY', 'privkey', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PUB_KEY', 'pubkey', 'octet_string'],
)); -}
typedef struct export_cb_arg_st {
@@ -476,12 +476,12 @@ static int mlx_kem_import(void *vkey, int selection, const OSSL_PARAM params[])
}
{- produce_param_decoder('mlx_get_params',
- (['PKEY_PARAM_BITS', 'bits', 'int'],
- ['PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
- ['PKEY_PARAM_MAX_SIZE', 'maxsize', 'int'],
- ['PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
- ['PKEY_PARAM_ENCODED_PUBLIC_KEY', 'pub', 'octet_string'],
- ['PKEY_PARAM_PRIV_KEY', 'priv', 'octet_string'],
+ (['OSSL_PKEY_PARAM_BITS', 'bits', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
+ ['OSSL_PKEY_PARAM_MAX_SIZE', 'maxsize', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
+ ['OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY', 'pub', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PRIV_KEY', 'priv', 'octet_string'],
)); -}
static const OSSL_PARAM *mlx_kem_gettable_params(void *provctx)
@@ -585,8 +585,8 @@ static int mlx_kem_get_params(void *vkey, OSSL_PARAM params[])
}
{- produce_param_decoder('mlx_set_params',
- (['PKEY_PARAM_ENCODED_PUBLIC_KEY', 'pub', 'octet_string'],
- ['PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ (['OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY', 'pub', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
)); -}
static const OSSL_PARAM *mlx_kem_settable_params(void *provctx)
@@ -634,7 +634,7 @@ static int mlx_kem_set_params(void *vkey, const OSSL_PARAM params[])
}
{- produce_param_decoder('mlx_gen_set_params',
- (['PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ (['OSSL_PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
)); -}
static int mlx_kem_gen_set_params(void *vgctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/keymgmt/slh_dsa_kmgmt.c.in b/providers/implementations/keymgmt/slh_dsa_kmgmt.c.in
index e2690731ef..129a11f92e 100644
--- a/providers/implementations/keymgmt/slh_dsa_kmgmt.c.in
+++ b/providers/implementations/keymgmt/slh_dsa_kmgmt.c.in
@@ -112,8 +112,8 @@ static int slh_dsa_validate(const void *key_data, int selection, int check_type)
}
{- produce_param_decoder('slh_dsa_import',
- (['PKEY_PARAM_PUB_KEY', 'pub', 'octet_string'],
- ['PKEY_PARAM_PRIV_KEY', 'priv', 'octet_string'],
+ (['OSSL_PKEY_PARAM_PUB_KEY', 'pub', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PRIV_KEY', 'priv', 'octet_string'],
)); -}
static int slh_dsa_import(void *keydata, int selection, const OSSL_PARAM params[])
@@ -142,13 +142,13 @@ static const OSSL_PARAM *slh_dsa_imexport_types(int selection)
}
{- produce_param_decoder('slh_dsa_get_params',
- (['PKEY_PARAM_BITS', 'bits', 'int'],
- ['PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
- ['PKEY_PARAM_MAX_SIZE', 'maxsize', 'int'],
- ['PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
- ['PKEY_PARAM_MANDATORY_DIGEST', 'mandgst', 'utf8_string'],
- ['PKEY_PARAM_PUB_KEY', 'pub', 'octet_string'],
- ['PKEY_PARAM_PRIV_KEY', 'priv', 'octet_string'],
+ (['OSSL_PKEY_PARAM_BITS', 'bits', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
+ ['OSSL_PKEY_PARAM_MAX_SIZE', 'maxsize', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
+ ['OSSL_PKEY_PARAM_MANDATORY_DIGEST', 'mandgst', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_PUB_KEY', 'pub', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PRIV_KEY', 'priv', 'octet_string'],
)); -}
static const OSSL_PARAM *slh_dsa_gettable_params(void *provctx)
@@ -387,8 +387,8 @@ static void *slh_dsa_gen(void *genctx, const char *alg)
}
{- produce_param_decoder('slh_dsa_gen_set_params',
- (['PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['PKEY_PARAM_SLH_DSA_SEED', 'seed', 'octet_string'],
+ (['OSSL_PKEY_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_SLH_DSA_SEED', 'seed', 'octet_string'],
)); -}
static int slh_dsa_gen_set_params(void *genctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/keymgmt/template_kmgmt.c.in b/providers/implementations/keymgmt/template_kmgmt.c.in
index cd4620f412..9095188b1e 100644
--- a/providers/implementations/keymgmt/template_kmgmt.c.in
+++ b/providers/implementations/keymgmt/template_kmgmt.c.in
@@ -182,8 +182,8 @@ err:
}
{- produce_param_decoder('template_key_types',
- (['PKEY_PARAM_PUB_KEY', 'pub_key', 'octet_string'],
- ['PKEY_PARAM_PRIV_KEY', 'priv_key', 'octet_string'],
+ (['OSSL_PKEY_PARAM_PUB_KEY', 'pub_key', 'octet_string'],
+ ['OSSL_PKEY_PARAM_PRIV_KEY', 'priv_key', 'octet_string'],
)); -}
static int ossl_template_key_fromdata(void *key,
@@ -238,11 +238,11 @@ static const OSSL_PARAM *template_imexport_types(int selection)
}
{- produce_param_decoder('template_get_params',
- (['PKEY_PARAM_BITS', 'bits', 'int'],
- ['PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
- ['PKEY_PARAM_MAX_SIZE', 'size', 'int'],
- ['PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
- ['PKEY_PARAM_ENCODED_PUBLIC_KEY', 'encpub', 'octet_string'],
+ (['OSSL_PKEY_PARAM_BITS', 'bits', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_BITS', 'secbits', 'int'],
+ ['OSSL_PKEY_PARAM_MAX_SIZE', 'size', 'int'],
+ ['OSSL_PKEY_PARAM_SECURITY_CATEGORY', 'seccat', 'int'],
+ ['OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY', 'encpub', 'octet_string'],
)); -}
static int template_get_params(void *key, OSSL_PARAM params[])
@@ -278,7 +278,7 @@ static const OSSL_PARAM *template_gettable_params(void *provctx)
}
{- produce_param_decoder('template_set_params',
- (['PKEY_PARAM_ENCODED_PUBLIC_KEY', 'pub', 'octet_string'],
+ (['OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY', 'pub', 'octet_string'],
)); -}
static int template_set_params(void *key, const OSSL_PARAM params[])
@@ -304,7 +304,7 @@ static const OSSL_PARAM *template_settable_params(void *provctx)
}
{- produce_param_decoder('template_gen_set_params',
- (['PKEY_PARAM_GROUP_NAME', 'name', 'utf8_string'],
+ (['OSSL_PKEY_PARAM_GROUP_NAME', 'name', 'utf8_string'],
)); -}
static int template_gen_set_params(void *genctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/macs/cmac_prov.c.in b/providers/implementations/macs/cmac_prov.c.in
index f8c2db4d48..0d3b3d5d6d 100644
--- a/providers/implementations/macs/cmac_prov.c.in
+++ b/providers/implementations/macs/cmac_prov.c.in
@@ -204,9 +204,9 @@ static int cmac_final(void *vmacctx, unsigned char *out, size_t *outl,
}
{- produce_param_decoder('cmac_get_ctx_params',
- (['MAC_PARAM_SIZE', 'size', 'size_t'],
- ['MAC_PARAM_BLOCK_SIZE', 'bsize', 'size_t'],
- ['ALG_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_MAC_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_MAC_PARAM_BLOCK_SIZE', 'bsize', 'size_t'],
+ ['OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static const OSSL_PARAM *cmac_gettable_ctx_params(ossl_unused void *ctx,
@@ -236,11 +236,11 @@ static int cmac_get_ctx_params(void *vmacctx, OSSL_PARAM params[])
}
{- produce_param_decoder('cmac_set_ctx_params',
- (['MAC_PARAM_CIPHER', 'cipher', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['MAC_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['MAC_PARAM_KEY', 'key', 'octet_string'],
- ['CIPHER_PARAM_FIPS_ENCRYPT_CHECK', 'ind_ec', 'int', 'fips'],
+ (['OSSL_MAC_PARAM_CIPHER', 'cipher', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_MAC_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_MAC_PARAM_KEY', 'key', 'octet_string'],
+ ['OSSL_CIPHER_PARAM_FIPS_ENCRYPT_CHECK', 'ind_ec', 'int', 'fips'],
)); -}
static const OSSL_PARAM *cmac_settable_ctx_params(ossl_unused void *ctx,
diff --git a/providers/implementations/macs/gmac_prov.c.in b/providers/implementations/macs/gmac_prov.c.in
index b3d6578c33..0b60ac7739 100644
--- a/providers/implementations/macs/gmac_prov.c.in
+++ b/providers/implementations/macs/gmac_prov.c.in
@@ -171,7 +171,7 @@ static int gmac_final(void *vmacctx, unsigned char *out, size_t *outl,
}
{- produce_param_decoder('gmac_get_params',
- (['MAC_PARAM_SIZE', 'size', 'size_t'],
+ (['OSSL_MAC_PARAM_SIZE', 'size', 'size_t'],
)); -}
static const OSSL_PARAM *gmac_gettable_params(void *provctx)
@@ -193,11 +193,11 @@ static int gmac_get_params(OSSL_PARAM params[])
}
{- produce_param_decoder('gmac_set_ctx_params',
- (['MAC_PARAM_CIPHER', 'cipher', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['MAC_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['MAC_PARAM_KEY', 'key', 'octet_string'],
- ['MAC_PARAM_IV', 'iv', 'octet_string'],
+ (['OSSL_MAC_PARAM_CIPHER', 'cipher', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_MAC_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_MAC_PARAM_KEY', 'key', 'octet_string'],
+ ['OSSL_MAC_PARAM_IV', 'iv', 'octet_string'],
)); -}
static const OSSL_PARAM *gmac_settable_ctx_params(ossl_unused void *ctx,
diff --git a/providers/implementations/macs/hmac_prov.c.in b/providers/implementations/macs/hmac_prov.c.in
index 4d9bb3ec78..e6ca348403 100644
--- a/providers/implementations/macs/hmac_prov.c.in
+++ b/providers/implementations/macs/hmac_prov.c.in
@@ -272,9 +272,9 @@ static int hmac_final(void *vmacctx, unsigned char *out, size_t *outl,
}
{- produce_param_decoder('hmac_get_ctx_params',
- (['MAC_PARAM_SIZE', 'size', 'size_t'],
- ['MAC_PARAM_BLOCK_SIZE', 'bsize', 'size_t'],
- ['ALG_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_MAC_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_MAC_PARAM_BLOCK_SIZE', 'bsize', 'size_t'],
+ ['OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static const OSSL_PARAM *hmac_gettable_ctx_params(ossl_unused void *ctx,
@@ -311,12 +311,12 @@ static int hmac_get_ctx_params(void *vmacctx, OSSL_PARAM params[])
}
{- produce_param_decoder('hmac_set_ctx_params',
- (['MAC_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['MAC_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['MAC_PARAM_KEY', 'key', 'octet_string'],
- ['MAC_PARAM_TLS_DATA_SIZE', 'tlssize', 'size_t'],
- ['MAC_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ (['OSSL_MAC_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_MAC_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_MAC_PARAM_KEY', 'key', 'octet_string'],
+ ['OSSL_MAC_PARAM_TLS_DATA_SIZE', 'tlssize', 'size_t'],
+ ['OSSL_MAC_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
)); -}
static const OSSL_PARAM *hmac_settable_ctx_params(ossl_unused void *ctx,
diff --git a/providers/implementations/macs/kmac_prov.c.in b/providers/implementations/macs/kmac_prov.c.in
index 6046d2ddcc..630851cc8e 100644
--- a/providers/implementations/macs/kmac_prov.c.in
+++ b/providers/implementations/macs/kmac_prov.c.in
@@ -192,9 +192,9 @@ static struct kmac_data_st *kmac_new(void *provctx)
#define kmac_new_list
{- produce_param_decoder('kmac_new',
- (['MAC_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['MAC_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ (['OSSL_MAC_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_MAC_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
)); -}
static void *kmac_fetch_new(void *provctx, const OSSL_PARAM *params)
@@ -404,9 +404,9 @@ static int kmac_final(void *vmacctx, unsigned char *out, size_t *outl,
}
{- produce_param_decoder('kmac_get_ctx_params',
- (['MAC_PARAM_SIZE', 'size', 'size_t'],
- ['MAC_PARAM_BLOCK_SIZE', 'bsize', 'size_t'],
- ['ALG_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_MAC_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_MAC_PARAM_BLOCK_SIZE', 'bsize', 'size_t'],
+ ['OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static const OSSL_PARAM *kmac_gettable_ctx_params(ossl_unused void *ctx,
@@ -440,12 +440,12 @@ static int kmac_get_ctx_params(void *vmacctx, OSSL_PARAM params[])
}
{- produce_param_decoder('kmac_set_ctx_params',
- (['MAC_PARAM_XOF', 'xof', 'int'],
- ['MAC_PARAM_SIZE', 'size', 'size_t'],
- ['MAC_PARAM_KEY', 'key', 'octet_string'],
- ['MAC_PARAM_CUSTOM', 'custom', 'octet_string'],
- ['MAC_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
- ['MAC_PARAM_FIPS_NO_SHORT_MAC', 'ind_sht', 'int', 'fips'],
+ (['OSSL_MAC_PARAM_XOF', 'xof', 'int'],
+ ['OSSL_MAC_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_MAC_PARAM_KEY', 'key', 'octet_string'],
+ ['OSSL_MAC_PARAM_CUSTOM', 'custom', 'octet_string'],
+ ['OSSL_MAC_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ ['OSSL_MAC_PARAM_FIPS_NO_SHORT_MAC', 'ind_sht', 'int', 'fips'],
)); -}
static const OSSL_PARAM *kmac_settable_ctx_params(ossl_unused void *ctx,
diff --git a/providers/implementations/macs/poly1305_prov.c.in b/providers/implementations/macs/poly1305_prov.c.in
index 3dc95f68e2..fe833c5966 100644
--- a/providers/implementations/macs/poly1305_prov.c.in
+++ b/providers/implementations/macs/poly1305_prov.c.in
@@ -138,7 +138,7 @@ static int poly1305_final(void *vmacctx, unsigned char *out, size_t *outl,
}
{- produce_param_decoder('poly1305_get_params',
- (['MAC_PARAM_SIZE', 'size', 'size_t'],
+ (['OSSL_MAC_PARAM_SIZE', 'size', 'size_t'],
)); -}
static const OSSL_PARAM *poly1305_gettable_params(void *provctx)
@@ -160,7 +160,7 @@ static int poly1305_get_params(OSSL_PARAM params[])
}
{- produce_param_decoder('poly1305_set_ctx_params',
- (['MAC_PARAM_KEY', 'key', 'octet_string'],
+ (['OSSL_MAC_PARAM_KEY', 'key', 'octet_string'],
)); -}
static const OSSL_PARAM *poly1305_settable_ctx_params(ossl_unused void *ctx,
diff --git a/providers/implementations/macs/siphash_prov.c.in b/providers/implementations/macs/siphash_prov.c.in
index ab574d1f1c..5d8433e16d 100644
--- a/providers/implementations/macs/siphash_prov.c.in
+++ b/providers/implementations/macs/siphash_prov.c.in
@@ -153,9 +153,9 @@ static int siphash_final(void *vmacctx, unsigned char *out, size_t *outl,
}
{- produce_param_decoder('siphash_get_ctx_params',
- (['MAC_PARAM_SIZE', 'size', 'size_t'],
- ['MAC_PARAM_C_ROUNDS', 'c', 'uint'],
- ['MAC_PARAM_D_ROUNDS', 'd', 'uint'],
+ (['OSSL_MAC_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_MAC_PARAM_C_ROUNDS', 'c', 'uint'],
+ ['OSSL_MAC_PARAM_D_ROUNDS', 'd', 'uint'],
)); -}
static const OSSL_PARAM *siphash_gettable_ctx_params(ossl_unused void *ctx,
@@ -182,10 +182,10 @@ static int siphash_get_ctx_params(void *vmacctx, OSSL_PARAM params[])
}
{- produce_param_decoder('siphash_set_params',
- (['MAC_PARAM_SIZE', 'size', 'size_t'],
- ['MAC_PARAM_KEY', 'key', 'octet_string'],
- ['MAC_PARAM_C_ROUNDS', 'c', 'uint'],
- ['MAC_PARAM_D_ROUNDS', 'd', 'uint'],
+ (['OSSL_MAC_PARAM_SIZE', 'size', 'size_t'],
+ ['OSSL_MAC_PARAM_KEY', 'key', 'octet_string'],
+ ['OSSL_MAC_PARAM_C_ROUNDS', 'c', 'uint'],
+ ['OSSL_MAC_PARAM_D_ROUNDS', 'd', 'uint'],
)); -}
static const OSSL_PARAM *siphash_settable_ctx_params(ossl_unused void *ctx,
diff --git a/providers/implementations/rands/drbg_ctr.c.in b/providers/implementations/rands/drbg_ctr.c.in
index 9d129ef9db..347ecf1ae6 100644
--- a/providers/implementations/rands/drbg_ctr.c.in
+++ b/providers/implementations/rands/drbg_ctr.c.in
@@ -674,22 +674,22 @@ static void drbg_ctr_free(void *vdrbg)
#define drbg_ctr_get_ctx_params_st drbg_get_ctx_params_st
{- produce_param_decoder('drbg_ctr_get_ctx_params',
- (['DRBG_PARAM_CIPHER', 'cipher', 'utf8_string'],
- ['DRBG_PARAM_USE_DF', 'df', 'int'],
- ['RAND_PARAM_STATE', 'state', 'int'],
- ['RAND_PARAM_STRENGTH', 'str', 'uint'],
- ['RAND_PARAM_MAX_REQUEST', 'maxreq', 'size_t'],
- ['DRBG_PARAM_MIN_ENTROPYLEN', 'minentlen', 'size_t'],
- ['DRBG_PARAM_MAX_ENTROPYLEN', 'maxentlen', 'size_t'],
- ['DRBG_PARAM_MIN_NONCELEN', 'minnonlen', 'size_t'],
- ['DRBG_PARAM_MAX_NONCELEN', 'maxnonlen', 'size_t'],
- ['DRBG_PARAM_MAX_PERSLEN', 'maxperlen', 'size_t'],
- ['DRBG_PARAM_MAX_ADINLEN', 'maxadlen', 'size_t'],
- ['DRBG_PARAM_RESEED_COUNTER', 'reseed_cnt', 'uint'],
- ['DRBG_PARAM_RESEED_TIME', 'reseed_time', 'time_t'],
- ['DRBG_PARAM_RESEED_REQUESTS', 'reseed_req', 'uint'],
- ['DRBG_PARAM_RESEED_TIME_INTERVAL', 'reseed_int', 'uint64'],
- ['KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_DRBG_PARAM_CIPHER', 'cipher', 'utf8_string'],
+ ['OSSL_DRBG_PARAM_USE_DF', 'df', 'int'],
+ ['OSSL_RAND_PARAM_STATE', 'state', 'int'],
+ ['OSSL_RAND_PARAM_STRENGTH', 'str', 'uint'],
+ ['OSSL_RAND_PARAM_MAX_REQUEST', 'maxreq', 'size_t'],
+ ['OSSL_DRBG_PARAM_MIN_ENTROPYLEN', 'minentlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MAX_ENTROPYLEN', 'maxentlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MIN_NONCELEN', 'minnonlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MAX_NONCELEN', 'maxnonlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MAX_PERSLEN', 'maxperlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MAX_ADINLEN', 'maxadlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_RESEED_COUNTER', 'reseed_cnt', 'uint'],
+ ['OSSL_DRBG_PARAM_RESEED_TIME', 'reseed_time', 'time_t'],
+ ['OSSL_DRBG_PARAM_RESEED_REQUESTS', 'reseed_req', 'uint'],
+ ['OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL', 'reseed_int', 'uint64'],
+ ['OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int drbg_ctr_get_ctx_params(void *vdrbg, OSSL_PARAM params[])
@@ -828,12 +828,12 @@ static int drbg_ctr_set_ctx_params_locked(PROV_DRBG *ctx,
#define drbg_ctr_set_ctx_params_st drbg_set_ctx_params_st
{- produce_param_decoder('drbg_ctr_set_ctx_params',
- (['DRBG_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['DRBG_PARAM_CIPHER', 'cipher', 'utf8_string'],
- ['DRBG_PARAM_USE_DF', 'df', 'int'],
- ['PROV_PARAM_CORE_PROV_NAME', 'prov', 'utf8_string'],
- ['DRBG_PARAM_RESEED_REQUESTS', 'reseed_req', 'uint'],
- ['DRBG_PARAM_RESEED_TIME_INTERVAL', 'reseed_time', 'uint64'],
+ (['OSSL_DRBG_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_DRBG_PARAM_CIPHER', 'cipher', 'utf8_string'],
+ ['OSSL_DRBG_PARAM_USE_DF', 'df', 'int'],
+ ['OSSL_PROV_PARAM_CORE_PROV_NAME', 'prov', 'utf8_string'],
+ ['OSSL_DRBG_PARAM_RESEED_REQUESTS', 'reseed_req', 'uint'],
+ ['OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL', 'reseed_time', 'uint64'],
)); -}
static int drbg_ctr_set_ctx_params(void *vctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/rands/drbg_hash.c.in b/providers/implementations/rands/drbg_hash.c.in
index 7fdfe7c7d1..cf51800721 100644
--- a/providers/implementations/rands/drbg_hash.c.in
+++ b/providers/implementations/rands/drbg_hash.c.in
@@ -477,21 +477,21 @@ static void drbg_hash_free(void *vdrbg)
#define drbg_hash_get_ctx_params_st drbg_get_ctx_params_st
{- produce_param_decoder('drbg_hash_get_ctx_params',
- (['DRBG_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['RAND_PARAM_STATE', 'state', 'int'],
- ['RAND_PARAM_STRENGTH', 'str', 'uint'],
- ['RAND_PARAM_MAX_REQUEST', 'maxreq', 'size_t'],
- ['DRBG_PARAM_MIN_ENTROPYLEN', 'minentlen', 'size_t'],
- ['DRBG_PARAM_MAX_ENTROPYLEN', 'maxentlen', 'size_t'],
- ['DRBG_PARAM_MIN_NONCELEN', 'minnonlen', 'size_t'],
- ['DRBG_PARAM_MAX_NONCELEN', 'maxnonlen', 'size_t'],
- ['DRBG_PARAM_MAX_PERSLEN', 'maxperlen', 'size_t'],
- ['DRBG_PARAM_MAX_ADINLEN', 'maxadlen', 'size_t'],
- ['DRBG_PARAM_RESEED_COUNTER', 'reseed_cnt', 'uint'],
- ['DRBG_PARAM_RESEED_TIME', 'reseed_time', 'time_t'],
- ['DRBG_PARAM_RESEED_REQUESTS', 'reseed_req', 'uint'],
- ['DRBG_PARAM_RESEED_TIME_INTERVAL', 'reseed_int', 'uint64'],
- ['KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_DRBG_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_RAND_PARAM_STATE', 'state', 'int'],
+ ['OSSL_RAND_PARAM_STRENGTH', 'str', 'uint'],
+ ['OSSL_RAND_PARAM_MAX_REQUEST', 'maxreq', 'size_t'],
+ ['OSSL_DRBG_PARAM_MIN_ENTROPYLEN', 'minentlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MAX_ENTROPYLEN', 'maxentlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MIN_NONCELEN', 'minnonlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MAX_NONCELEN', 'maxnonlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MAX_PERSLEN', 'maxperlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MAX_ADINLEN', 'maxadlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_RESEED_COUNTER', 'reseed_cnt', 'uint'],
+ ['OSSL_DRBG_PARAM_RESEED_TIME', 'reseed_time', 'time_t'],
+ ['OSSL_DRBG_PARAM_RESEED_REQUESTS', 'reseed_req', 'uint'],
+ ['OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL', 'reseed_int', 'uint64'],
+ ['OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int drbg_hash_get_ctx_params(void *vdrbg, OSSL_PARAM params[])
@@ -628,13 +628,13 @@ static int drbg_hash_set_ctx_params_locked
#define drbg_hash_set_ctx_params_st drbg_set_ctx_params_st
{- produce_param_decoder('drbg_hash_set_ctx_params',
- (['DRBG_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['DRBG_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['PROV_PARAM_CORE_PROV_NAME', 'prov', 'utf8_string'],
- ['DRBG_PARAM_RESEED_REQUESTS', 'reseed_req', 'uint'],
- ['DRBG_PARAM_RESEED_TIME_INTERVAL', 'reseed_time', 'uint64'],
- ['KDF_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
+ (['OSSL_DRBG_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_DRBG_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_PROV_PARAM_CORE_PROV_NAME', 'prov', 'utf8_string'],
+ ['OSSL_DRBG_PARAM_RESEED_REQUESTS', 'reseed_req', 'uint'],
+ ['OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL', 'reseed_time', 'uint64'],
+ ['OSSL_KDF_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
)); -}
static int drbg_hash_set_ctx_params(void *vctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/rands/drbg_hmac.c.in b/providers/implementations/rands/drbg_hmac.c.in
index 4a52b5ed08..a0ab399559 100644
--- a/providers/implementations/rands/drbg_hmac.c.in
+++ b/providers/implementations/rands/drbg_hmac.c.in
@@ -369,22 +369,22 @@ static void drbg_hmac_free(void *vdrbg)
#define drbg_hmac_get_ctx_params_st drbg_get_ctx_params_st
{- produce_param_decoder('drbg_hmac_get_ctx_params',
- (['DRBG_PARAM_MAC', 'mac', 'utf8_string'],
- ['DRBG_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['RAND_PARAM_STATE', 'state', 'int'],
- ['RAND_PARAM_STRENGTH', 'str', 'uint'],
- ['RAND_PARAM_MAX_REQUEST', 'maxreq', 'size_t'],
- ['DRBG_PARAM_MIN_ENTROPYLEN', 'minentlen', 'size_t'],
- ['DRBG_PARAM_MAX_ENTROPYLEN', 'maxentlen', 'size_t'],
- ['DRBG_PARAM_MIN_NONCELEN', 'minnonlen', 'size_t'],
- ['DRBG_PARAM_MAX_NONCELEN', 'maxnonlen', 'size_t'],
- ['DRBG_PARAM_MAX_PERSLEN', 'maxperlen', 'size_t'],
- ['DRBG_PARAM_MAX_ADINLEN', 'maxadlen', 'size_t'],
- ['DRBG_PARAM_RESEED_COUNTER', 'reseed_cnt', 'uint'],
- ['DRBG_PARAM_RESEED_TIME', 'reseed_time', 'time_t'],
- ['DRBG_PARAM_RESEED_REQUESTS', 'reseed_req', 'uint'],
- ['DRBG_PARAM_RESEED_TIME_INTERVAL', 'reseed_int', 'uint64'],
- ['KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_DRBG_PARAM_MAC', 'mac', 'utf8_string'],
+ ['OSSL_DRBG_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_RAND_PARAM_STATE', 'state', 'int'],
+ ['OSSL_RAND_PARAM_STRENGTH', 'str', 'uint'],
+ ['OSSL_RAND_PARAM_MAX_REQUEST', 'maxreq', 'size_t'],
+ ['OSSL_DRBG_PARAM_MIN_ENTROPYLEN', 'minentlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MAX_ENTROPYLEN', 'maxentlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MIN_NONCELEN', 'minnonlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MAX_NONCELEN', 'maxnonlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MAX_PERSLEN', 'maxperlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_MAX_ADINLEN', 'maxadlen', 'size_t'],
+ ['OSSL_DRBG_PARAM_RESEED_COUNTER', 'reseed_cnt', 'uint'],
+ ['OSSL_DRBG_PARAM_RESEED_TIME', 'reseed_time', 'time_t'],
+ ['OSSL_DRBG_PARAM_RESEED_REQUESTS', 'reseed_req', 'uint'],
+ ['OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL', 'reseed_int', 'uint64'],
+ ['OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int drbg_hmac_get_ctx_params(void *vdrbg, OSSL_PARAM params[])
@@ -550,14 +550,14 @@ static int drbg_hmac_set_ctx_params_locked
#define drbg_hmac_set_ctx_params_st drbg_set_ctx_params_st
{- produce_param_decoder('drbg_hmac_set_ctx_params',
- (['DRBG_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
- ['DRBG_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['DRBG_PARAM_MAC', 'mac', 'utf8_string'],
- ['PROV_PARAM_CORE_PROV_NAME', 'prov', 'utf8_string'],
- ['DRBG_PARAM_RESEED_REQUESTS', 'reseed_req', 'uint'],
- ['DRBG_PARAM_RESEED_TIME_INTERVAL', 'reseed_time', 'uint64'],
- ['KDF_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
+ (['OSSL_DRBG_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_ALG_PARAM_ENGINE', 'engine', 'utf8_string', 'hidden'],
+ ['OSSL_DRBG_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_DRBG_PARAM_MAC', 'mac', 'utf8_string'],
+ ['OSSL_PROV_PARAM_CORE_PROV_NAME', 'prov', 'utf8_string'],
+ ['OSSL_DRBG_PARAM_RESEED_REQUESTS', 'reseed_req', 'uint'],
+ ['OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL', 'reseed_time', 'uint64'],
+ ['OSSL_KDF_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
)); -}
static int drbg_hmac_set_ctx_params(void *vctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/rands/fips_crng_test.c.in b/providers/implementations/rands/fips_crng_test.c.in
index ab0812288c..4be6aaa362 100644
--- a/providers/implementations/rands/fips_crng_test.c.in
+++ b/providers/implementations/rands/fips_crng_test.c.in
@@ -366,10 +366,10 @@ static void crng_test_unlock(ossl_unused void *vcrngt)
}
{- produce_param_decoder('crng_test_get_ctx_params',
- (['RAND_PARAM_STATE', 'state', 'int'],
- ['RAND_PARAM_STRENGTH', 'str', 'uint'],
- ['RAND_PARAM_MAX_REQUEST', 'maxreq', 'size_t'],
- ['RAND_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_RAND_PARAM_STATE', 'state', 'int'],
+ ['OSSL_RAND_PARAM_STRENGTH', 'str', 'uint'],
+ ['OSSL_RAND_PARAM_MAX_REQUEST', 'maxreq', 'size_t'],
+ ['OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int crng_test_get_ctx_params(void *vcrngt, OSSL_PARAM params[])
diff --git a/providers/implementations/rands/seed_src.c.in b/providers/implementations/rands/seed_src.c.in
index b6a1a6e381..36c8d70a98 100644
--- a/providers/implementations/rands/seed_src.c.in
+++ b/providers/implementations/rands/seed_src.c.in
@@ -146,9 +146,9 @@ static int seed_src_reseed(void *vseed,
}
{- produce_param_decoder('seed_src_get_ctx_params',
- (['RAND_PARAM_STATE', 'state', 'int'],
- ['RAND_PARAM_STRENGTH', 'str', 'uint'],
- ['RAND_PARAM_MAX_REQUEST', 'maxreq', 'size_t'],
+ (['OSSL_RAND_PARAM_STATE', 'state', 'int'],
+ ['OSSL_RAND_PARAM_STRENGTH', 'str', 'uint'],
+ ['OSSL_RAND_PARAM_MAX_REQUEST', 'maxreq', 'size_t'],
)); -}
static int seed_src_get_ctx_params(void *vseed, OSSL_PARAM params[])
diff --git a/providers/implementations/rands/seed_src_jitter.c.in b/providers/implementations/rands/seed_src_jitter.c.in
index 1139c7395a..4d73f07574 100644
--- a/providers/implementations/rands/seed_src_jitter.c.in
+++ b/providers/implementations/rands/seed_src_jitter.c.in
@@ -232,9 +232,9 @@ static int jitter_reseed(void *vseed,
}
{- produce_param_decoder('jitter_get_ctx_params',
- (['RAND_PARAM_STATE', 'state', 'int'],
- ['RAND_PARAM_STRENGTH', 'str', 'uint'],
- ['RAND_PARAM_MAX_REQUEST', 'maxreq', 'size_t'],
+ (['OSSL_RAND_PARAM_STATE', 'state', 'int'],
+ ['OSSL_RAND_PARAM_STRENGTH', 'str', 'uint'],
+ ['OSSL_RAND_PARAM_MAX_REQUEST', 'maxreq', 'size_t'],
)); -}
static int jitter_get_ctx_params(void *vseed, OSSL_PARAM params[])
diff --git a/providers/implementations/rands/test_rng.c.in b/providers/implementations/rands/test_rng.c.in
index 70a8691686..f6389d3662 100644
--- a/providers/implementations/rands/test_rng.c.in
+++ b/providers/implementations/rands/test_rng.c.in
@@ -186,11 +186,11 @@ static size_t test_rng_nonce(void *vtest, unsigned char *out,
}
{- 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', 'fips'],
+ (['OSSL_RAND_PARAM_STATE', 'state', 'int'],
+ ['OSSL_RAND_PARAM_STRENGTH', 'str', 'uint'],
+ ['OSSL_RAND_PARAM_MAX_REQUEST', 'maxreq', 'size_t'],
+ ['OSSL_RAND_PARAM_GENERATE', 'gen', 'uint'],
+ ['OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int test_rng_get_ctx_params(void *vtest, OSSL_PARAM params[])
@@ -228,11 +228,11 @@ static const OSSL_PARAM *test_rng_gettable_ctx_params(ossl_unused void *vtest,
}
{- 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'],
+ (['OSSL_RAND_PARAM_TEST_ENTROPY', 'ent', 'octet_string'],
+ ['OSSL_RAND_PARAM_TEST_NONCE', 'nonce', 'octet_string'],
+ ['OSSL_RAND_PARAM_STRENGTH', 'str', 'uint'],
+ ['OSSL_RAND_PARAM_MAX_REQUEST', 'maxreq', 'size_t'],
+ ['OSSL_RAND_PARAM_GENERATE', 'gen', 'uint'],
)); -}
static int test_rng_set_ctx_params(void *vtest, const OSSL_PARAM params[])
diff --git a/providers/implementations/signature/dsa_sig.c.in b/providers/implementations/signature/dsa_sig.c.in
index 5b64a0cd16..b208992ee1 100644
--- a/providers/implementations/signature/dsa_sig.c.in
+++ b/providers/implementations/signature/dsa_sig.c.in
@@ -673,10 +673,10 @@ static void *dsa_dupctx(void *vpdsactx)
}
{- produce_param_decoder('dsa_get_ctx_params',
- (['SIGNATURE_PARAM_ALGORITHM_ID', 'algid', 'octet_string'],
- ['SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['SIGNATURE_PARAM_NONCE_TYPE', 'nonce', 'uint'],
- ['SIGNATURE_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_SIGNATURE_PARAM_ALGORITHM_ID', 'algid', 'octet_string'],
+ ['OSSL_SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_NONCE_TYPE', 'nonce', 'uint'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int dsa_get_ctx_params(void *vpdsactx, OSSL_PARAM *params)
@@ -750,12 +750,12 @@ static int dsa_common_set_ctx_params(PROV_DSA_CTX *pdsactx,
#define dsa_set_ctx_params_st dsa_all_set_ctx_params_st
{- produce_param_decoder('dsa_set_ctx_params',
- (['SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['SIGNATURE_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['SIGNATURE_PARAM_NONCE_TYPE', 'nonce', 'uint'],
- ['SIGNATURE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
- ['SIGNATURE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
- ['SIGNATURE_PARAM_FIPS_SIGN_CHECK', 'ind_sign', 'int', 'fips'],
+ (['OSSL_SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_NONCE_TYPE', 'nonce', 'uint'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_SIGN_CHECK', 'ind_sign', 'int', 'fips'],
)); -}
static int dsa_set_ctx_params(void *vpdsactx, const OSSL_PARAM params[])
@@ -939,11 +939,11 @@ static const char **dsa_sigalg_query_key_types(void)
#define dsa_sigalg_set_ctx_params_st dsa_all_set_ctx_params_st
{- produce_param_decoder('dsa_sigalg_set_ctx_params',
- (['SIGNATURE_PARAM_SIGNATURE', 'sig', 'octet_string'],
- ['SIGNATURE_PARAM_NONCE_TYPE', 'nonce', 'uint'],
- ['SIGNATURE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
- ['SIGNATURE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
- ['SIGNATURE_PARAM_FIPS_SIGN_CHECK', 'ind_sign', 'int', 'fips'],
+ (['OSSL_SIGNATURE_PARAM_SIGNATURE', 'sig', 'octet_string'],
+ ['OSSL_SIGNATURE_PARAM_NONCE_TYPE', 'nonce', 'uint'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_SIGN_CHECK', 'ind_sign', 'int', 'fips'],
)); -}
static const OSSL_PARAM *dsa_sigalg_settable_ctx_params(void *vpdsactx,
diff --git a/providers/implementations/signature/ecdsa_sig.c.in b/providers/implementations/signature/ecdsa_sig.c.in
index 741f5ffc47..d2e954b1af 100644
--- a/providers/implementations/signature/ecdsa_sig.c.in
+++ b/providers/implementations/signature/ecdsa_sig.c.in
@@ -676,12 +676,12 @@ static void *ecdsa_dupctx(void *vctx)
}
{- produce_param_decoder('ecdsa_get_ctx_params',
- (['SIGNATURE_PARAM_ALGORITHM_ID', 'algid', 'octet_string'],
- ['SIGNATURE_PARAM_DIGEST_SIZE', 'size', 'size_t'],
- ['SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['SIGNATURE_PARAM_NONCE_TYPE', 'nonce', 'uint'],
- ['SIGNATURE_PARAM_FIPS_VERIFY_MESSAGE', 'verify', 'uint', 'fips'],
- ['SIGNATURE_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_SIGNATURE_PARAM_ALGORITHM_ID', 'algid', 'octet_string'],
+ ['OSSL_SIGNATURE_PARAM_DIGEST_SIZE', 'size', 'size_t'],
+ ['OSSL_SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_NONCE_TYPE', 'nonce', 'uint'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_VERIFY_MESSAGE', 'verify', 'uint', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int ecdsa_get_ctx_params(void *vctx, OSSL_PARAM *params)
@@ -769,14 +769,14 @@ static int ecdsa_common_set_ctx_params(PROV_ECDSA_CTX *ctx,
#define ecdsa_set_ctx_params_st ecdsa_all_set_ctx_params_st
{- produce_param_decoder('ecdsa_set_ctx_params',
- (['SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['SIGNATURE_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['SIGNATURE_PARAM_DIGEST_SIZE', 'size', 'size_t'],
- ['SIGNATURE_PARAM_KAT', 'kat', 'uint',
+ (['OSSL_SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_DIGEST_SIZE', 'size', 'size_t'],
+ ['OSSL_SIGNATURE_PARAM_KAT', 'kat', 'uint',
"#if !defined(OPENSSL_NO_ACVP_TESTS)"],
- ['SIGNATURE_PARAM_NONCE_TYPE', 'nonce', 'uint'],
- ['SIGNATURE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
- ['SIGNATURE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_NONCE_TYPE', 'nonce', 'uint'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
)); -}
static int ecdsa_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -960,12 +960,12 @@ static const char **ecdsa_sigalg_query_key_types(void)
#define ecdsa_sigalg_set_ctx_params_st ecdsa_all_set_ctx_params_st
{- produce_param_decoder('ecdsa_sigalg_set_ctx_params',
- (['SIGNATURE_PARAM_SIGNATURE', 'sig', 'octet_string'],
- ['SIGNATURE_PARAM_KAT', 'kat', 'uint',
+ (['OSSL_SIGNATURE_PARAM_SIGNATURE', 'sig', 'octet_string'],
+ ['OSSL_SIGNATURE_PARAM_KAT', 'kat', 'uint',
"#if !defined(OPENSSL_NO_ACVP_TESTS)"],
- ['SIGNATURE_PARAM_NONCE_TYPE', 'nonce', 'uint'],
- ['SIGNATURE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
- ['SIGNATURE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_NONCE_TYPE', 'nonce', 'uint'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
)); -}
static const OSSL_PARAM *ecdsa_sigalg_settable_ctx_params(void *vctx,
diff --git a/providers/implementations/signature/eddsa_sig.c.in b/providers/implementations/signature/eddsa_sig.c.in
index 5e37351a41..1ef925253d 100644
--- a/providers/implementations/signature/eddsa_sig.c.in
+++ b/providers/implementations/signature/eddsa_sig.c.in
@@ -793,7 +793,7 @@ static const char **ed448_sigalg_query_key_types(void)
}
{- produce_param_decoder('eddsa_get_ctx_params',
- (['SIGNATURE_PARAM_ALGORITHM_ID', 'id', 'octet_string'],
+ (['OSSL_SIGNATURE_PARAM_ALGORITHM_ID', 'id', 'octet_string'],
)); -}
static int eddsa_get_ctx_params(void *vpeddsactx, OSSL_PARAM *params)
@@ -820,8 +820,8 @@ static const OSSL_PARAM *eddsa_gettable_ctx_params(ossl_unused void *vpeddsactx,
}
{- produce_param_decoder('eddsa_set_ctx_params',
- (['SIGNATURE_PARAM_INSTANCE', 'inst', 'utf8_string'],
- ['SIGNATURE_PARAM_CONTEXT_STRING', 'ctx', 'octet_string'],
+ (['OSSL_SIGNATURE_PARAM_INSTANCE', 'inst', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_CONTEXT_STRING', 'ctx', 'octet_string'],
)); -}
static int eddsa_set_ctx_params_internal
@@ -904,7 +904,7 @@ static int eddsa_set_ctx_params(void *vpeddsactx, const OSSL_PARAM params[])
#define eddsa_set_variant_ctx_params_st eddsa_set_ctx_params_st
{- produce_param_decoder('eddsa_set_variant_ctx_params',
- (['SIGNATURE_PARAM_CONTEXT_STRING', 'ctx', 'octet_string'],
+ (['OSSL_SIGNATURE_PARAM_CONTEXT_STRING', 'ctx', 'octet_string'],
)); -}
static const OSSL_PARAM *
diff --git a/providers/implementations/signature/ml_dsa_sig.c.in b/providers/implementations/signature/ml_dsa_sig.c.in
index 6717fcfdd4..a12618ac71 100644
--- a/providers/implementations/signature/ml_dsa_sig.c.in
+++ b/providers/implementations/signature/ml_dsa_sig.c.in
@@ -369,20 +369,20 @@ static int ml_dsa_digest_verify(void *vctx,
#define ml_dsa_set_ctx_params_decoder ml_dsa_verifymsg_set_ctx_params_decoder
{- produce_param_decoder('ml_dsa_set_ctx_params',
- (['SIGNATURE_PARAM_CONTEXT_STRING', 'ctx', 'octet_string'],
- ['SIGNATURE_PARAM_TEST_ENTROPY', 'ent', 'octet_string'],
- ['SIGNATURE_PARAM_DETERMINISTIC', 'det', 'int'],
- ['SIGNATURE_PARAM_MESSAGE_ENCODING', 'msgenc', 'int'],
- ['SIGNATURE_PARAM_MU', 'mu', 'int'],
+ (['OSSL_SIGNATURE_PARAM_CONTEXT_STRING', 'ctx', 'octet_string'],
+ ['OSSL_SIGNATURE_PARAM_TEST_ENTROPY', 'ent', 'octet_string'],
+ ['OSSL_SIGNATURE_PARAM_DETERMINISTIC', 'det', 'int'],
+ ['OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING', 'msgenc', 'int'],
+ ['OSSL_SIGNATURE_PARAM_MU', 'mu', 'int'],
)); -}
{- produce_param_decoder('ml_dsa_verifymsg_set_ctx_params',
- (['SIGNATURE_PARAM_CONTEXT_STRING', 'ctx', 'octet_string'],
- ['SIGNATURE_PARAM_TEST_ENTROPY', 'ent', 'octet_string'],
- ['SIGNATURE_PARAM_DETERMINISTIC', 'det', 'int'],
- ['SIGNATURE_PARAM_MESSAGE_ENCODING', 'msgenc', 'int'],
- ['SIGNATURE_PARAM_MU', 'mu', 'int'],
- ['SIGNATURE_PARAM_SIGNATURE', 'sig', 'octet_string'],
+ (['OSSL_SIGNATURE_PARAM_CONTEXT_STRING', 'ctx', 'octet_string'],
+ ['OSSL_SIGNATURE_PARAM_TEST_ENTROPY', 'ent', 'octet_string'],
+ ['OSSL_SIGNATURE_PARAM_DETERMINISTIC', 'det', 'int'],
+ ['OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING', 'msgenc', 'int'],
+ ['OSSL_SIGNATURE_PARAM_MU', 'mu', 'int'],
+ ['OSSL_SIGNATURE_PARAM_SIGNATURE', 'sig', 'octet_string'],
)); -}
static int ml_dsa_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -450,7 +450,7 @@ static const OSSL_PARAM *ml_dsa_settable_ctx_params(void *vctx,
}
{- produce_param_decoder('ml_dsa_get_ctx_params',
- (['SIGNATURE_PARAM_ALGORITHM_ID', 'id', 'octet_string'],
+ (['OSSL_SIGNATURE_PARAM_ALGORITHM_ID', 'id', 'octet_string'],
)); -}
static const OSSL_PARAM *ml_dsa_gettable_ctx_params(ossl_unused void *vctx,
diff --git a/providers/implementations/signature/rsa_sig.c.in b/providers/implementations/signature/rsa_sig.c.in
index 2c9d0c85f6..90b6f5d154 100644
--- a/providers/implementations/signature/rsa_sig.c.in
+++ b/providers/implementations/signature/rsa_sig.c.in
@@ -1386,15 +1386,15 @@ static void *rsa_dupctx(void *vprsactx)
}
{- produce_param_decoder('rsa_get_ctx_params',
- (['SIGNATURE_PARAM_ALGORITHM_ID', 'algid', 'octet_string'],
- ['SIGNATURE_PARAM_PAD_MODE', 'pad', 'utf8_string'],
- ['SIGNATURE_PARAM_PAD_MODE', 'pad', 'int'],
- ['SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['SIGNATURE_PARAM_MGF1_DIGEST', 'mgf1', 'utf8_string'],
- ['SIGNATURE_PARAM_PSS_SALTLEN', 'slen', 'utf8_string'],
- ['SIGNATURE_PARAM_PSS_SALTLEN', 'slen', 'int'],
- ['SIGNATURE_PARAM_FIPS_VERIFY_MESSAGE', 'verify', 'uint', 'fips'],
- ['SIGNATURE_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
+ (['OSSL_SIGNATURE_PARAM_ALGORITHM_ID', 'algid', 'octet_string'],
+ ['OSSL_SIGNATURE_PARAM_PAD_MODE', 'pad', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_PAD_MODE', 'pad', 'int'],
+ ['OSSL_SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_MGF1_DIGEST', 'mgf1', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_PSS_SALTLEN', 'slen', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_PSS_SALTLEN', 'slen', 'int'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_VERIFY_MESSAGE', 'verify', 'uint', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_APPROVED_INDICATOR', 'ind', 'int', 'fips'],
)); -}
static int rsa_get_ctx_params(void *vprsactx, OSSL_PARAM *params)
@@ -1520,33 +1520,33 @@ static int rsa_x931_padding_allowed(PROV_RSA_CTX *ctx)
#endif
{- produce_param_decoder('rsa_set_ctx_params',
- (['SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['SIGNATURE_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['SIGNATURE_PARAM_PAD_MODE', 'pad', 'utf8_string'],
- ['SIGNATURE_PARAM_PAD_MODE', 'pad', 'int'],
- ['SIGNATURE_PARAM_MGF1_DIGEST', 'mgf1', 'utf8_string'],
- ['SIGNATURE_PARAM_MGF1_PROPERTIES', 'mgf1pq', 'utf8_string'],
- ['SIGNATURE_PARAM_PSS_SALTLEN', 'slen', 'utf8_string'],
- ['SIGNATURE_PARAM_PSS_SALTLEN', 'slen', 'int'],
- ['SIGNATURE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
- ['SIGNATURE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
- ['SIGNATURE_PARAM_FIPS_RSA_PSS_SALTLEN_CHECK', 'ind_slen', 'int', 'fips'],
- ['SIGNATURE_PARAM_FIPS_SIGN_X931_PAD_CHECK', 'ind_xpad', 'int', 'fips'],
+ (['OSSL_SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_PAD_MODE', 'pad', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_PAD_MODE', 'pad', 'int'],
+ ['OSSL_SIGNATURE_PARAM_MGF1_DIGEST', 'mgf1', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_MGF1_PROPERTIES', 'mgf1pq', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_PSS_SALTLEN', 'slen', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_PSS_SALTLEN', 'slen', 'int'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_RSA_PSS_SALTLEN_CHECK', 'ind_slen', 'int', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_SIGN_X931_PAD_CHECK', 'ind_xpad', 'int', 'fips'],
)); -}
#define rsa_set_ctx_params_no_digest_st rsa_set_ctx_params_st
{- produce_param_decoder('rsa_set_ctx_params_no_digest',
- (['SIGNATURE_PARAM_PAD_MODE', 'pad', 'utf8_string'],
- ['SIGNATURE_PARAM_PAD_MODE', 'pad', 'int'],
- ['SIGNATURE_PARAM_MGF1_DIGEST', 'mgf1', 'utf8_string'],
- ['SIGNATURE_PARAM_MGF1_PROPERTIES', 'mgf1pq', 'utf8_string'],
- ['SIGNATURE_PARAM_PSS_SALTLEN', 'slen', 'utf8_string'],
- ['SIGNATURE_PARAM_PSS_SALTLEN', 'slen', 'int'],
- ['SIGNATURE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
- ['SIGNATURE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
- ['SIGNATURE_PARAM_FIPS_RSA_PSS_SALTLEN_CHECK', 'ind_slen', 'int', 'fips'],
- ['SIGNATURE_PARAM_FIPS_SIGN_X931_PAD_CHECK', 'ind_xpad', 'int', 'fips'],
+ (['OSSL_SIGNATURE_PARAM_PAD_MODE', 'pad', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_PAD_MODE', 'pad', 'int'],
+ ['OSSL_SIGNATURE_PARAM_MGF1_DIGEST', 'mgf1', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_MGF1_PROPERTIES', 'mgf1pq', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_PSS_SALTLEN', 'slen', 'utf8_string'],
+ ['OSSL_SIGNATURE_PARAM_PSS_SALTLEN', 'slen', 'int'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_KEY_CHECK', 'ind_k', 'int', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_DIGEST_CHECK', 'ind_d', 'int', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_RSA_PSS_SALTLEN_CHECK', 'ind_slen', 'int', 'fips'],
+ ['OSSL_SIGNATURE_PARAM_FIPS_SIGN_X931_PAD_CHECK', 'ind_xpad', 'int', 'fips'],
)); -}
static int rsa_set_ctx_params(void *vprsactx, const OSSL_PARAM params[])
@@ -1950,7 +1950,7 @@ static const char **rsa_sigalg_query_key_types(void)
}
{- produce_param_decoder('rsa_sigalg_set_ctx_params',
- (['SIGNATURE_PARAM_SIGNATURE', 'sig', 'octet_string'],
+ (['OSSL_SIGNATURE_PARAM_SIGNATURE', 'sig', 'octet_string'],
)); -}
static const OSSL_PARAM *rsa_sigalg_settable_ctx_params(void *vprsactx,
diff --git a/providers/implementations/signature/slh_dsa_sig.c.in b/providers/implementations/signature/slh_dsa_sig.c.in
index abe099f898..909691637c 100644
--- a/providers/implementations/signature/slh_dsa_sig.c.in
+++ b/providers/implementations/signature/slh_dsa_sig.c.in
@@ -261,10 +261,10 @@ static int slh_dsa_digest_verify(void *vctx, const uint8_t *sig, size_t siglen,
}
{- produce_param_decoder('slh_dsa_set_ctx_params',
- (['SIGNATURE_PARAM_CONTEXT_STRING', 'context', 'octet_string'],
- ['SIGNATURE_PARAM_TEST_ENTROPY', 'entropy', 'octet_string'],
- ['SIGNATURE_PARAM_DETERMINISTIC', 'det', 'int'],
- ['SIGNATURE_PARAM_MESSAGE_ENCODING', 'msgenc', 'int'],
+ (['OSSL_SIGNATURE_PARAM_CONTEXT_STRING', 'context', 'octet_string'],
+ ['OSSL_SIGNATURE_PARAM_TEST_ENTROPY', 'entropy', 'octet_string'],
+ ['OSSL_SIGNATURE_PARAM_DETERMINISTIC', 'det', 'int'],
+ ['OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING', 'msgenc', 'int'],
)); -}
static int slh_dsa_set_ctx_params(void *vctx, const OSSL_PARAM params[])
@@ -312,7 +312,7 @@ static const OSSL_PARAM *slh_dsa_settable_ctx_params(void *vctx,
}
{- produce_param_decoder('slh_dsa_get_ctx_params',
- (['SIGNATURE_PARAM_ALGORITHM_ID', 'algid', 'octet_string'],
+ (['OSSL_SIGNATURE_PARAM_ALGORITHM_ID', 'algid', 'octet_string'],
)); -}
static const OSSL_PARAM *slh_dsa_gettable_ctx_params(ossl_unused void *vctx,
diff --git a/providers/implementations/signature/sm2_sig.c.in b/providers/implementations/signature/sm2_sig.c.in
index ec73fbfe42..0ce7f752e7 100644
--- a/providers/implementations/signature/sm2_sig.c.in
+++ b/providers/implementations/signature/sm2_sig.c.in
@@ -400,9 +400,9 @@ static void *sm2sig_dupctx(void *vpsm2ctx)
}
{- produce_param_decoder('sm2sig_get_ctx_params',
- (['SIGNATURE_PARAM_ALGORITHM_ID', 'algid', 'octet_string'],
- ['SIGNATURE_PARAM_DIGEST_SIZE', 'size', 'size_t'],
- ['SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
+ (['OSSL_SIGNATURE_PARAM_ALGORITHM_ID', 'algid', 'octet_string'],
+ ['OSSL_SIGNATURE_PARAM_DIGEST_SIZE', 'size', 'size_t'],
+ ['OSSL_SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
)); -}
static int sm2sig_get_ctx_params(void *vpsm2ctx, OSSL_PARAM *params)
@@ -438,9 +438,9 @@ static const OSSL_PARAM *sm2sig_gettable_ctx_params(ossl_unused void *vpsm2ctx,
}
{- produce_param_decoder('sm2sig_set_ctx_params',
- (['SIGNATURE_PARAM_DIGEST_SIZE', 'size', 'size_t'],
- ['SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
- ['PKEY_PARAM_DIST_ID', 'distid', 'octet_string'],
+ (['OSSL_SIGNATURE_PARAM_DIGEST_SIZE', 'size', 'size_t'],
+ ['OSSL_SIGNATURE_PARAM_DIGEST', 'digest', 'utf8_string'],
+ ['OSSL_PKEY_PARAM_DIST_ID', 'distid', 'octet_string'],
)); -}
static int sm2sig_set_ctx_params(void *vpsm2ctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/skeymgmt/generic.c.in b/providers/implementations/skeymgmt/generic.c.in
index cbb1d42c32..d32624b930 100644
--- a/providers/implementations/skeymgmt/generic.c.in
+++ b/providers/implementations/skeymgmt/generic.c.in
@@ -34,7 +34,7 @@ void generic_free(void *keydata)
}
{- produce_param_decoder('generic_skey_import',
- (['SKEY_PARAM_RAW_BYTES', 'raw_bytes', 'octet_string'],
+ (['OSSL_SKEY_PARAM_RAW_BYTES', 'raw_bytes', 'octet_string'],
)); -}
void *generic_import(void *provctx, int selection, const OSSL_PARAM params[])
diff --git a/providers/implementations/storemgmt/file_store.c.in b/providers/implementations/storemgmt/file_store.c.in
index c2483faca3..c1007af34c 100644
--- a/providers/implementations/storemgmt/file_store.c.in
+++ b/providers/implementations/storemgmt/file_store.c.in
@@ -294,10 +294,10 @@ void *file_attach(void *provctx, OSSL_CORE_BIO *cin)
*/
{- produce_param_decoder('file_set_ctx_params',
- (['STORE_PARAM_PROPERTIES', 'propq', 'utf8_string'],
- ['STORE_PARAM_EXPECT', 'expect', 'int'],
- ['STORE_PARAM_SUBJECT', 'sub', 'octet_string'],
- ['STORE_PARAM_INPUT_TYPE', 'type', 'utf8_string'],
+ (['OSSL_STORE_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ ['OSSL_STORE_PARAM_EXPECT', 'expect', 'int'],
+ ['OSSL_STORE_PARAM_SUBJECT', 'sub', 'octet_string'],
+ ['OSSL_STORE_PARAM_INPUT_TYPE', 'type', 'utf8_string'],
)); -}
static const OSSL_PARAM *file_settable_ctx_params(void *provctx)
diff --git a/providers/implementations/storemgmt/file_store_any2obj.c.in b/providers/implementations/storemgmt/file_store_any2obj.c.in
index eef6f6f03c..c21c3ad372 100644
--- a/providers/implementations/storemgmt/file_store_any2obj.c.in
+++ b/providers/implementations/storemgmt/file_store_any2obj.c.in
@@ -71,7 +71,7 @@ static void any2obj_freectx(void *ctx)
}
{- produce_param_decoder('any2obj_set_ctx_params',
- (['OBJECT_PARAM_DATA_STRUCTURE', 'datastruct', 'utf8_string'],
+ (['OSSL_OBJECT_PARAM_DATA_STRUCTURE', 'datastruct', 'utf8_string'],
)); -}
static int any2obj_set_ctx_params(void *vctx, const OSSL_PARAM params[])
diff --git a/providers/implementations/storemgmt/winstore_store.c.in b/providers/implementations/storemgmt/winstore_store.c.in
index 610d44eaa7..5539e1e846 100644
--- a/providers/implementations/storemgmt/winstore_store.c.in
+++ b/providers/implementations/storemgmt/winstore_store.c.in
@@ -109,8 +109,8 @@ static void *winstore_attach(void *provctx, OSSL_CORE_BIO *cin)
}
{- produce_param_decoder('winstore_set_ctx_params',
- (['STORE_PARAM_SUBJECT', 'sub', 'octet_string'],
- ['STORE_PARAM_PROPERTIES', 'propq', 'utf8_string'],
+ (['OSSL_STORE_PARAM_SUBJECT', 'sub', 'octet_string'],
+ ['OSSL_STORE_PARAM_PROPERTIES', 'propq', 'utf8_string'],
)); -}
static const OSSL_PARAM *winstore_settable_ctx_params(void *loaderctx, const OSSL_PARAM params[])
diff --git a/util/perl/OpenSSL/paramnames.pm b/util/perl/OpenSSL/paramnames.pm
index cf5be346eb..f51833dfc1 100644
--- a/util/perl/OpenSSL/paramnames.pm
+++ b/util/perl/OpenSSL/paramnames.pm
@@ -22,48 +22,48 @@ my $invalid_param = "invalid param";
my %params = (
# Well known parameter names that core passes to providers
- 'PROV_PARAM_CORE_VERSION' => "openssl-version",# utf8_ptr
- 'PROV_PARAM_CORE_PROV_NAME' => "provider-name", # utf8_ptr
- 'PROV_PARAM_CORE_MODULE_FILENAME' => "module-filename",# utf8_ptr
+ 'OSSL_PROV_PARAM_CORE_VERSION' => "openssl-version",# utf8_ptr
+ 'OSSL_PROV_PARAM_CORE_PROV_NAME' => "provider-name", # utf8_ptr
+ 'OSSL_PROV_PARAM_CORE_MODULE_FILENAME' => "module-filename",# utf8_ptr
# Well known parameter names that Providers can define
- 'PROV_PARAM_NAME' => "name", # utf8_ptr
- 'PROV_PARAM_VERSION' => "version", # utf8_ptr
- 'PROV_PARAM_BUILDINFO' => "buildinfo", # utf8_ptr
- 'PROV_PARAM_STATUS' => "status", # uint
- 'PROV_PARAM_SECURITY_CHECKS' => "security-checks", # uint
- 'PROV_PARAM_HMAC_KEY_CHECK' => "hmac-key-check", # uint
- 'PROV_PARAM_KMAC_KEY_CHECK' => "kmac-key-check", # uint
- 'PROV_PARAM_TLS1_PRF_EMS_CHECK' => "tls1-prf-ems-check", # uint
- 'PROV_PARAM_NO_SHORT_MAC' => "no-short-mac", # uint
- 'PROV_PARAM_DRBG_TRUNC_DIGEST' => "drbg-no-trunc-md", # uint
- 'PROV_PARAM_HKDF_DIGEST_CHECK' => "hkdf-digest-check", # uint
- 'PROV_PARAM_TLS13_KDF_DIGEST_CHECK' => "tls13-kdf-digest-check", # uint
- 'PROV_PARAM_TLS1_PRF_DIGEST_CHECK' => "tls1-prf-digest-check", # uint
- 'PROV_PARAM_SSHKDF_DIGEST_CHECK' => "sshkdf-digest-check", # uint
- 'PROV_PARAM_SSKDF_DIGEST_CHECK' => "sskdf-digest-check", # uint
- 'PROV_PARAM_X963KDF_DIGEST_CHECK' => "x963kdf-digest-check", # uint
- 'PROV_PARAM_DSA_SIGN_DISABLED' => "dsa-sign-disabled", # uint
- 'PROV_PARAM_TDES_ENCRYPT_DISABLED' => "tdes-encrypt-disabled", # uint
- 'PROV_PARAM_RSA_PSS_SALTLEN_CHECK' => "rsa-pss-saltlen-check", # uint
- 'PROV_PARAM_RSA_SIGN_X931_PAD_DISABLED' => "rsa-sign-x931-pad-disabled", # uint
- 'PROV_PARAM_RSA_PKCS15_PAD_DISABLED' => "rsa-pkcs15-pad-disabled", # uint
- 'PROV_PARAM_HKDF_KEY_CHECK' => "hkdf-key-check", # uint
- 'PROV_PARAM_KBKDF_KEY_CHECK' => "kbkdf-key-check", # uint
- 'PROV_PARAM_TLS13_KDF_KEY_CHECK' => "tls13-kdf-key-check", # uint
- 'PROV_PARAM_TLS1_PRF_KEY_CHECK' => "tls1-prf-key-check", # uint
- 'PROV_PARAM_SSHKDF_KEY_CHECK' => "sshkdf-key-check", # uint
- 'PROV_PARAM_SSKDF_KEY_CHECK' => "sskdf-key-check", # uint
- 'PROV_PARAM_X963KDF_KEY_CHECK' => "x963kdf-key-check", # uint
- 'PROV_PARAM_X942KDF_KEY_CHECK' => "x942kdf-key-check", # uint
- 'PROV_PARAM_PBKDF2_LOWER_BOUND_CHECK' => "pbkdf2-lower-bound-check", # uint
- 'PROV_PARAM_ECDH_COFACTOR_CHECK' => "ecdh-cofactor-check", # uint
- 'PROV_PARAM_SIGNATURE_DIGEST_CHECK' => "signature-digest-check", # uint
+ 'OSSL_PROV_PARAM_NAME' => "name", # utf8_ptr
+ 'OSSL_PROV_PARAM_VERSION' => "version", # utf8_ptr
+ 'OSSL_PROV_PARAM_BUILDINFO' => "buildinfo", # utf8_ptr
+ 'OSSL_PROV_PARAM_STATUS' => "status", # uint
+ 'OSSL_PROV_PARAM_SECURITY_CHECKS' => "security-checks", # uint
+ 'OSSL_PROV_PARAM_HMAC_KEY_CHECK' => "hmac-key-check", # uint
+ 'OSSL_PROV_PARAM_KMAC_KEY_CHECK' => "kmac-key-check", # uint
+ 'OSSL_PROV_PARAM_TLS1_PRF_EMS_CHECK' => "tls1-prf-ems-check", # uint
+ 'OSSL_PROV_PARAM_NO_SHORT_MAC' => "no-short-mac", # uint
+ 'OSSL_PROV_PARAM_DRBG_TRUNC_DIGEST' => "drbg-no-trunc-md", # uint
+ 'OSSL_PROV_PARAM_HKDF_DIGEST_CHECK' => "hkdf-digest-check", # uint
+ 'OSSL_PROV_PARAM_TLS13_KDF_DIGEST_CHECK' => "tls13-kdf-digest-check", # uint
+ 'OSSL_PROV_PARAM_TLS1_PRF_DIGEST_CHECK' => "tls1-prf-digest-check", # uint
+ 'OSSL_PROV_PARAM_SSHKDF_DIGEST_CHECK' => "sshkdf-digest-check", # uint
+ 'OSSL_PROV_PARAM_SSKDF_DIGEST_CHECK' => "sskdf-digest-check", # uint
+ 'OSSL_PROV_PARAM_X963KDF_DIGEST_CHECK' => "x963kdf-digest-check", # uint
+ 'OSSL_PROV_PARAM_DSA_SIGN_DISABLED' => "dsa-sign-disabled", # uint
+ 'OSSL_PROV_PARAM_TDES_ENCRYPT_DISABLED' => "tdes-encrypt-disabled", # uint
+ 'OSSL_PROV_PARAM_RSA_PSS_SALTLEN_CHECK' => "rsa-pss-saltlen-check", # uint
+ 'OSSL_PROV_PARAM_RSA_SIGN_X931_PAD_DISABLED' => "rsa-sign-x931-pad-disabled", # uint
+ 'OSSL_PROV_PARAM_RSA_PKCS15_PAD_DISABLED' => "rsa-pkcs15-pad-disabled", # uint
+ 'OSSL_PROV_PARAM_HKDF_KEY_CHECK' => "hkdf-key-check", # uint
+ 'OSSL_PROV_PARAM_KBKDF_KEY_CHECK' => "kbkdf-key-check", # uint
+ 'OSSL_PROV_PARAM_TLS13_KDF_KEY_CHECK' => "tls13-kdf-key-check", # uint
+ 'OSSL_PROV_PARAM_TLS1_PRF_KEY_CHECK' => "tls1-prf-key-check", # uint
+ 'OSSL_PROV_PARAM_SSHKDF_KEY_CHECK' => "sshkdf-key-check", # uint
+ 'OSSL_PROV_PARAM_SSKDF_KEY_CHECK' => "sskdf-key-check", # uint
+ 'OSSL_PROV_PARAM_X963KDF_KEY_CHECK' => "x963kdf-key-check", # uint
+ 'OSSL_PROV_PARAM_X942KDF_KEY_CHECK' => "x942kdf-key-check", # uint
+ 'OSSL_PROV_PARAM_PBKDF2_LOWER_BOUND_CHECK' => "pbkdf2-lower-bound-check", # uint
+ 'OSSL_PROV_PARAM_ECDH_COFACTOR_CHECK' => "ecdh-cofactor-check", # uint
+ 'OSSL_PROV_PARAM_SIGNATURE_DIGEST_CHECK' => "signature-digest-check", # uint
# Self test callback parameters
- 'PROV_PARAM_SELF_TEST_PHASE' => "st-phase",# utf8_string
- 'PROV_PARAM_SELF_TEST_TYPE' => "st-type", # utf8_string
- 'PROV_PARAM_SELF_TEST_DESC' => "st-desc", # utf8_string
+ 'OSSL_PROV_PARAM_SELF_TEST_PHASE' => "st-phase",# utf8_string
+ 'OSSL_PROV_PARAM_SELF_TEST_TYPE' => "st-type", # utf8_string
+ 'OSSL_PROV_PARAM_SELF_TEST_DESC' => "st-desc", # utf8_string
# Provider-native object abstractions
#
@@ -75,13 +75,13 @@ my %params = (
# This set of parameter names is explained in detail in provider-object(7)
# (doc/man7/provider-object.pod)
- 'OBJECT_PARAM_TYPE' => "type", # INTEGER
- 'OBJECT_PARAM_DATA_TYPE' => "data-type",# UTF8_STRING
- 'OBJECT_PARAM_DATA_STRUCTURE' => "data-structure",# UTF8_STRING
- 'OBJECT_PARAM_REFERENCE' => "reference",# OCTET_STRING
- 'OBJECT_PARAM_DATA' => "data",# OCTET_STRING or UTF8_STRING
- 'OBJECT_PARAM_DESC' => "desc", # UTF8_STRING
- 'OBJECT_PARAM_INPUT_TYPE' => "input-type", # UTF8_STRING
+ 'OSSL_OBJECT_PARAM_TYPE' => "type", # INTEGER
+ 'OSSL_OBJECT_PARAM_DATA_TYPE' => "data-type",# UTF8_STRING
+ 'OSSL_OBJECT_PARAM_DATA_STRUCTURE' => "data-structure",# UTF8_STRING
+ 'OSSL_OBJECT_PARAM_REFERENCE' => "reference",# OCTET_STRING
+ 'OSSL_OBJECT_PARAM_DATA' => "data",# OCTET_STRING or UTF8_STRING
+ 'OSSL_OBJECT_PARAM_DESC' => "desc", # UTF8_STRING
+ 'OSSL_OBJECT_PARAM_INPUT_TYPE' => "input-type", # UTF8_STRING
# Algorithm parameters
# If "engine",or "properties",are specified, they should always be paired
@@ -89,13 +89,13 @@ my %params = (
# Note these are common names that are shared by many types (such as kdf, mac,
# and pkey) e.g: see MAC_PARAM_DIGEST below.
- 'ALG_PARAM_DIGEST' => "digest", # utf8_string
- 'ALG_PARAM_CIPHER' => "cipher", # utf8_string
- 'ALG_PARAM_ENGINE' => "engine", # utf8_string
- 'ALG_PARAM_MAC' => "mac", # utf8_string
- 'ALG_PARAM_PROPERTIES' => "properties", # utf8_string
- 'ALG_PARAM_FIPS_APPROVED_INDICATOR' => 'fips-indicator', # int, -1, 0 or 1
- 'ALG_PARAM_SECURITY_CATEGORY' => "security-category", # int, 0 .. 5
+ 'OSSL_ALG_PARAM_DIGEST' => "digest", # utf8_string
+ 'OSSL_ALG_PARAM_CIPHER' => "cipher", # utf8_string
+ 'OSSL_ALG_PARAM_ENGINE' => "engine", # utf8_string
+ 'OSSL_ALG_PARAM_MAC' => "mac", # utf8_string
+ 'OSSL_ALG_PARAM_PROPERTIES' => "properties", # utf8_string
+ 'OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR' => 'fips-indicator', # int, -1, 0 or 1
+ 'OSSL_ALG_PARAM_SECURITY_CATEGORY' => "security-category", # int, 0 .. 5
# For any operation that deals with AlgorithmIdentifier, they should
# implement both of these.
@@ -104,263 +104,263 @@ my %params = (
# ALG_PARAM_ALGORITHM_ID_PARAMS is intended to be both settable
# and gettable, to allow the calling application to pass or get
# AlgID parameters to and from the provided implementation.
- 'ALG_PARAM_ALGORITHM_ID' => "algorithm-id", # octet_string (DER)
- 'ALG_PARAM_ALGORITHM_ID_PARAMS' => "algorithm-id-params", # octet_string
+ 'OSSL_ALG_PARAM_ALGORITHM_ID' => "algorithm-id", # octet_string (DER)
+ 'OSSL_ALG_PARAM_ALGORITHM_ID_PARAMS' => "algorithm-id-params", # octet_string
# cipher parameters
- 'CIPHER_PARAM_PADDING' => "padding", # uint
- 'CIPHER_PARAM_USE_BITS' => "use-bits", # uint
- 'CIPHER_PARAM_TLS_VERSION' => "tls-version", # uint
- 'CIPHER_PARAM_TLS_MAC' => "tls-mac", # octet_ptr
- 'CIPHER_PARAM_TLS_MAC_SIZE' => "tls-mac-size",# size_t
- 'CIPHER_PARAM_MODE' => "mode", # uint
- 'CIPHER_PARAM_BLOCK_SIZE' => "blocksize", # size_t
- 'CIPHER_PARAM_AEAD' => "aead", # int, 0 or 1
- 'CIPHER_PARAM_CUSTOM_IV' => "custom-iv", # int, 0 or 1
- 'CIPHER_PARAM_CTS' => "cts", # int, 0 or 1
- 'CIPHER_PARAM_TLS1_MULTIBLOCK' => "tls-multi", # int, 0 or 1
- 'CIPHER_PARAM_HAS_RAND_KEY' => "has-randkey", # int, 0 or 1
- 'CIPHER_PARAM_KEYLEN' => "keylen", # size_t
- 'CIPHER_PARAM_IVLEN' => "ivlen", # size_t
- 'CIPHER_PARAM_IV' => "iv", # octet_string OR octet_ptr
- 'CIPHER_PARAM_UPDATED_IV' => "updated-iv", # octet_string OR octet_ptr
- 'CIPHER_PARAM_NUM' => "num", # uint
- 'CIPHER_PARAM_ROUNDS' => "rounds", # uint
- 'CIPHER_PARAM_AEAD_TAG' => "tag", # octet_string
- 'CIPHER_PARAM_PIPELINE_AEAD_TAG' => "pipeline-tag",# octet_ptr
- 'CIPHER_PARAM_AEAD_TLS1_AAD' => "tlsaad", # octet_string
- 'CIPHER_PARAM_AEAD_TLS1_AAD_PAD' => "tlsaadpad", # size_t
- 'CIPHER_PARAM_AEAD_TLS1_IV_FIXED' => "tlsivfixed", # octet_string
- 'CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN' => "tlsivgen", # octet_string
- 'CIPHER_PARAM_AEAD_TLS1_SET_IV_INV' => "tlsivinv", # octet_string
- 'CIPHER_PARAM_AEAD_IVLEN' => '*CIPHER_PARAM_IVLEN',
- 'CIPHER_PARAM_AEAD_IV_GENERATED' => "iv-generated", # uint
- 'CIPHER_PARAM_AEAD_TAGLEN' => "taglen", # size_t
- 'CIPHER_PARAM_AEAD_MAC_KEY' => "mackey", # octet_string
- 'CIPHER_PARAM_RANDOM_KEY' => "randkey", # octet_string
- 'CIPHER_PARAM_RC2_KEYBITS' => "keybits", # size_t
- 'CIPHER_PARAM_SPEED' => "speed", # uint
- 'CIPHER_PARAM_CTS_MODE' => "cts_mode", # utf8_string
- 'CIPHER_PARAM_DECRYPT_ONLY' => "decrypt-only", # int, 0 or 1
- 'CIPHER_PARAM_FIPS_ENCRYPT_CHECK' => "encrypt-check", # int
- 'CIPHER_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
- 'CIPHER_PARAM_ALGORITHM_ID' => '*ALG_PARAM_ALGORITHM_ID',
+ 'OSSL_CIPHER_PARAM_PADDING' => "padding", # uint
+ 'OSSL_CIPHER_PARAM_USE_BITS' => "use-bits", # uint
+ 'OSSL_CIPHER_PARAM_TLS_VERSION' => "tls-version", # uint
+ 'OSSL_CIPHER_PARAM_TLS_MAC' => "tls-mac", # octet_ptr
+ 'OSSL_CIPHER_PARAM_TLS_MAC_SIZE' => "tls-mac-size",# size_t
+ 'OSSL_CIPHER_PARAM_MODE' => "mode", # uint
+ 'OSSL_CIPHER_PARAM_BLOCK_SIZE' => "blocksize", # size_t
+ 'OSSL_CIPHER_PARAM_AEAD' => "aead", # int, 0 or 1
+ 'OSSL_CIPHER_PARAM_CUSTOM_IV' => "custom-iv", # int, 0 or 1
+ 'OSSL_CIPHER_PARAM_CTS' => "cts", # int, 0 or 1
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK' => "tls-multi", # int, 0 or 1
+ 'OSSL_CIPHER_PARAM_HAS_RAND_KEY' => "has-randkey", # int, 0 or 1
+ 'OSSL_CIPHER_PARAM_KEYLEN' => "keylen", # size_t
+ 'OSSL_CIPHER_PARAM_IVLEN' => "ivlen", # size_t
+ 'OSSL_CIPHER_PARAM_IV' => "iv", # octet_string OR octet_ptr
+ 'OSSL_CIPHER_PARAM_UPDATED_IV' => "updated-iv", # octet_string OR octet_ptr
+ 'OSSL_CIPHER_PARAM_NUM' => "num", # uint
+ 'OSSL_CIPHER_PARAM_ROUNDS' => "rounds", # uint
+ 'OSSL_CIPHER_PARAM_AEAD_TAG' => "tag", # octet_string
+ 'OSSL_CIPHER_PARAM_PIPELINE_AEAD_TAG' => "pipeline-tag",# octet_ptr
+ 'OSSL_CIPHER_PARAM_AEAD_TLS1_AAD' => "tlsaad", # octet_string
+ 'OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD' => "tlsaadpad", # size_t
+ 'OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED' => "tlsivfixed", # octet_string
+ 'OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN' => "tlsivgen", # octet_string
+ 'OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV' => "tlsivinv", # octet_string
+ 'OSSL_CIPHER_PARAM_AEAD_IVLEN' => '*OSSL_CIPHER_PARAM_IVLEN',
+ 'OSSL_CIPHER_PARAM_AEAD_IV_GENERATED' => "iv-generated", # uint
+ 'OSSL_CIPHER_PARAM_AEAD_TAGLEN' => "taglen", # size_t
+ 'OSSL_CIPHER_PARAM_AEAD_MAC_KEY' => "mackey", # octet_string
+ 'OSSL_CIPHER_PARAM_RANDOM_KEY' => "randkey", # octet_string
+ 'OSSL_CIPHER_PARAM_RC2_KEYBITS' => "keybits", # size_t
+ 'OSSL_CIPHER_PARAM_SPEED' => "speed", # uint
+ 'OSSL_CIPHER_PARAM_CTS_MODE' => "cts_mode", # utf8_string
+ 'OSSL_CIPHER_PARAM_DECRYPT_ONLY' => "decrypt-only", # int, 0 or 1
+ 'OSSL_CIPHER_PARAM_FIPS_ENCRYPT_CHECK' => "encrypt-check", # int
+ 'OSSL_CIPHER_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_CIPHER_PARAM_ALGORITHM_ID' => '*OSSL_ALG_PARAM_ALGORITHM_ID',
# Historically, CIPHER_PARAM_ALGORITHM_ID_PARAMS_OLD was used. For the
# time being, the old libcrypto functions will use both, so old providers
# continue to work.
# New providers are encouraged to use CIPHER_PARAM_ALGORITHM_ID_PARAMS.
- 'CIPHER_PARAM_ALGORITHM_ID_PARAMS' => '*ALG_PARAM_ALGORITHM_ID_PARAMS',
- 'CIPHER_PARAM_ALGORITHM_ID_PARAMS_OLD' => "alg_id_param", # octet_string
- 'CIPHER_PARAM_XTS_STANDARD' => "xts_standard",# utf8_string
- 'CIPHER_PARAM_ENCRYPT_THEN_MAC' => "encrypt-then-mac",# int, 0 or 1
- 'CIPHER_HMAC_PARAM_MAC' => "*CIPHER_PARAM_AEAD_TAG",
-
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT' => "tls1multi_maxsndfrag",# uint
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE' => "tls1multi_maxbufsz", # size_t
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE' => "tls1multi_interleave",# uint
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_AAD' => "tls1multi_aad", # octet_string
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN' => "tls1multi_aadpacklen",# uint
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_ENC' => "tls1multi_enc", # octet_string
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN' => "tls1multi_encin", # octet_string
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN' => "tls1multi_enclen", # size_t
+ 'OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS' => '*OSSL_ALG_PARAM_ALGORITHM_ID_PARAMS',
+ 'OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS_OLD' => "alg_id_param", # octet_string
+ 'OSSL_CIPHER_PARAM_XTS_STANDARD' => "xts_standard",# utf8_string
+ 'OSSL_CIPHER_PARAM_ENCRYPT_THEN_MAC' => "encrypt-then-mac",# int, 0 or 1
+ 'OSSL_CIPHER_HMAC_PARAM_MAC' => "*OSSL_CIPHER_PARAM_AEAD_TAG",
+
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT' => "tls1multi_maxsndfrag",# uint
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE' => "tls1multi_maxbufsz", # size_t
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE' => "tls1multi_interleave",# uint
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD' => "tls1multi_aad", # octet_string
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN' => "tls1multi_aadpacklen",# uint
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC' => "tls1multi_enc", # octet_string
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN' => "tls1multi_encin", # octet_string
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN' => "tls1multi_enclen", # size_t
# digest parameters
- 'DIGEST_PARAM_XOFLEN' => "xoflen", # size_t
- 'DIGEST_PARAM_SSL3_MS' => "ssl3-ms", # octet string
- 'DIGEST_PARAM_PAD_TYPE' => "pad-type", # uint
- 'DIGEST_PARAM_MICALG' => "micalg", # utf8 string
- 'DIGEST_PARAM_BLOCK_SIZE' => "blocksize", # size_t
- 'DIGEST_PARAM_SIZE' => "size", # size_t
- 'DIGEST_PARAM_XOF' => "xof", # int, 0 or 1
- 'DIGEST_PARAM_ALGID_ABSENT' => "algid-absent", # int, 0 or 1
+ 'OSSL_DIGEST_PARAM_XOFLEN' => "xoflen", # size_t
+ 'OSSL_DIGEST_PARAM_SSL3_MS' => "ssl3-ms", # octet string
+ 'OSSL_DIGEST_PARAM_PAD_TYPE' => "pad-type", # uint
+ 'OSSL_DIGEST_PARAM_MICALG' => "micalg", # utf8 string
+ 'OSSL_DIGEST_PARAM_BLOCK_SIZE' => "blocksize", # size_t
+ 'OSSL_DIGEST_PARAM_SIZE' => "size", # size_t
+ 'OSSL_DIGEST_PARAM_XOF' => "xof", # int, 0 or 1
+ 'OSSL_DIGEST_PARAM_ALGID_ABSENT' => "algid-absent", # int, 0 or 1
# MAC parameters
- 'MAC_PARAM_KEY' => "key", # octet string
- 'MAC_PARAM_IV' => "iv", # octet string
- 'MAC_PARAM_CUSTOM' => "custom", # utf8 string
- 'MAC_PARAM_SALT' => "salt", # octet string
- 'MAC_PARAM_XOF' => "xof", # int, 0 or 1
- 'MAC_PARAM_DIGEST_NOINIT' => "digest-noinit", # int, 0 or 1
- 'MAC_PARAM_DIGEST_ONESHOT' => "digest-oneshot",# int, 0 or 1
- 'MAC_PARAM_C_ROUNDS' => "c-rounds", # unsigned int
- 'MAC_PARAM_D_ROUNDS' => "d-rounds", # unsigned int
+ 'OSSL_MAC_PARAM_KEY' => "key", # octet string
+ 'OSSL_MAC_PARAM_IV' => "iv", # octet string
+ 'OSSL_MAC_PARAM_CUSTOM' => "custom", # utf8 string
+ 'OSSL_MAC_PARAM_SALT' => "salt", # octet string
+ 'OSSL_MAC_PARAM_XOF' => "xof", # int, 0 or 1
+ 'OSSL_MAC_PARAM_DIGEST_NOINIT' => "digest-noinit", # int, 0 or 1
+ 'OSSL_MAC_PARAM_DIGEST_ONESHOT' => "digest-oneshot",# int, 0 or 1
+ 'OSSL_MAC_PARAM_C_ROUNDS' => "c-rounds", # unsigned int
+ 'OSSL_MAC_PARAM_D_ROUNDS' => "d-rounds", # unsigned int
# If "engine",or "properties",are specified, they should always be paired
# with "cipher",or "digest".
- 'MAC_PARAM_CIPHER' => '*ALG_PARAM_CIPHER', # utf8 string
- 'MAC_PARAM_DIGEST' => '*ALG_PARAM_DIGEST', # utf8 string
- 'MAC_PARAM_PROPERTIES' => '*ALG_PARAM_PROPERTIES', # utf8 string
- 'MAC_PARAM_SIZE' => "size", # size_t
- 'MAC_PARAM_BLOCK_SIZE' => "block-size", # size_t
- 'MAC_PARAM_TLS_DATA_SIZE' => "tls-data-size", # size_t
- 'MAC_PARAM_FIPS_NO_SHORT_MAC' =>'*PROV_PARAM_NO_SHORT_MAC',
- 'MAC_PARAM_FIPS_KEY_CHECK' => '*PKEY_PARAM_FIPS_KEY_CHECK',
- 'MAC_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
- 'MAC_PARAM_FIPS_NO_SHORT_MAC' => '*PROV_PARAM_NO_SHORT_MAC',
+ 'OSSL_MAC_PARAM_CIPHER' => '*OSSL_ALG_PARAM_CIPHER', # utf8 string
+ 'OSSL_MAC_PARAM_DIGEST' => '*OSSL_ALG_PARAM_DIGEST', # utf8 string
+ 'OSSL_MAC_PARAM_PROPERTIES' => '*OSSL_ALG_PARAM_PROPERTIES', # utf8 string
+ 'OSSL_MAC_PARAM_SIZE' => "size", # size_t
+ 'OSSL_MAC_PARAM_BLOCK_SIZE' => "block-size", # size_t
+ 'OSSL_MAC_PARAM_TLS_DATA_SIZE' => "tls-data-size", # size_t
+ 'OSSL_MAC_PARAM_FIPS_NO_SHORT_MAC' =>'*OSSL_PROV_PARAM_NO_SHORT_MAC',
+ 'OSSL_MAC_PARAM_FIPS_KEY_CHECK' => '*OSSL_PKEY_PARAM_FIPS_KEY_CHECK',
+ 'OSSL_MAC_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_MAC_PARAM_FIPS_NO_SHORT_MAC' => '*OSSL_PROV_PARAM_NO_SHORT_MAC',
# KDF / PRF parameters
- 'KDF_PARAM_SECRET' => "secret", # octet string
- 'KDF_PARAM_KEY' => "key", # octet string
- 'KDF_PARAM_SALT' => "salt", # octet string
- 'KDF_PARAM_PASSWORD' => "pass", # octet string
- 'KDF_PARAM_PREFIX' => "prefix", # octet string
- 'KDF_PARAM_LABEL' => "label", # octet string
- 'KDF_PARAM_DATA' => "data", # octet string
- 'KDF_PARAM_DIGEST' => '*ALG_PARAM_DIGEST', # utf8 string
- 'KDF_PARAM_CIPHER' => '*ALG_PARAM_CIPHER', # utf8 string
- 'KDF_PARAM_MAC' => '*ALG_PARAM_MAC', # utf8 string
- 'KDF_PARAM_MAC_SIZE' => "maclen", # size_t
- 'KDF_PARAM_PROPERTIES' => '*ALG_PARAM_PROPERTIES', # utf8 string
- 'KDF_PARAM_ITER' => "iter", # unsigned int
- 'KDF_PARAM_MODE' => "mode", # utf8 string or int
- 'KDF_PARAM_PKCS5' => "pkcs5", # int
- 'KDF_PARAM_UKM' => "ukm", # octet string
- 'KDF_PARAM_CEK_ALG' => "cekalg", # utf8 string
- 'KDF_PARAM_SCRYPT_N' => "n", # uint64_t
- 'KDF_PARAM_SCRYPT_R' => "r", # uint32_t
- 'KDF_PARAM_SCRYPT_P' => "p", # uint32_t
- 'KDF_PARAM_SCRYPT_MAXMEM' => "maxmem_bytes", # uint64_t
- 'KDF_PARAM_INFO' => "info", # octet string
- 'KDF_PARAM_SEED' => "seed", # octet string
- 'KDF_PARAM_SSHKDF_XCGHASH' => "xcghash", # octet string
- 'KDF_PARAM_SSHKDF_SESSION_ID' => "session_id", # octet string
- 'KDF_PARAM_SSHKDF_TYPE' => "type", # int
- 'KDF_PARAM_SIZE' => "size", # size_t
- 'KDF_PARAM_CONSTANT' => "constant", # octet string
- 'KDF_PARAM_PKCS12_ID' => "id", # int
- 'KDF_PARAM_KBKDF_USE_L' => "use-l", # int
- 'KDF_PARAM_KBKDF_USE_SEPARATOR' => "use-separator", # int
- 'KDF_PARAM_KBKDF_R' => "r", # int
- 'KDF_PARAM_X942_ACVPINFO' => "acvp-info",
- 'KDF_PARAM_X942_PARTYUINFO' => "partyu-info",
- 'KDF_PARAM_X942_PARTYVINFO' => "partyv-info",
- 'KDF_PARAM_X942_SUPP_PUBINFO' => "supp-pubinfo",
- 'KDF_PARAM_X942_SUPP_PRIVINFO' => "supp-privinfo",
- 'KDF_PARAM_X942_USE_KEYBITS' => "use-keybits",
- 'KDF_PARAM_HMACDRBG_ENTROPY' => "entropy",
- 'KDF_PARAM_HMACDRBG_NONCE' => "nonce",
- 'KDF_PARAM_THREADS' => "threads", # uint32_t
- 'KDF_PARAM_EARLY_CLEAN' => "early_clean", # uint32_t
- 'KDF_PARAM_ARGON2_AD' => "ad", # octet string
- 'KDF_PARAM_ARGON2_LANES' => "lanes", # uint32_t
- 'KDF_PARAM_ARGON2_MEMCOST' => "memcost", # uint32_t
- 'KDF_PARAM_ARGON2_VERSION' => "version", # uint32_t
- 'KDF_PARAM_FIPS_EMS_CHECK' => "ems_check", # int
- 'KDF_PARAM_FIPS_DIGEST_CHECK' => '*PKEY_PARAM_FIPS_DIGEST_CHECK',
- 'KDF_PARAM_FIPS_KEY_CHECK' => '*PKEY_PARAM_FIPS_KEY_CHECK',
- 'KDF_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_KDF_PARAM_SECRET' => "secret", # octet string
+ 'OSSL_KDF_PARAM_KEY' => "key", # octet string
+ 'OSSL_KDF_PARAM_SALT' => "salt", # octet string
+ 'OSSL_KDF_PARAM_PASSWORD' => "pass", # octet string
+ 'OSSL_KDF_PARAM_PREFIX' => "prefix", # octet string
+ 'OSSL_KDF_PARAM_LABEL' => "label", # octet string
+ 'OSSL_KDF_PARAM_DATA' => "data", # octet string
+ 'OSSL_KDF_PARAM_DIGEST' => '*OSSL_ALG_PARAM_DIGEST', # utf8 string
+ 'OSSL_KDF_PARAM_CIPHER' => '*OSSL_ALG_PARAM_CIPHER', # utf8 string
+ 'OSSL_KDF_PARAM_MAC' => '*OSSL_ALG_PARAM_MAC', # utf8 string
+ 'OSSL_KDF_PARAM_MAC_SIZE' => "maclen", # size_t
+ 'OSSL_KDF_PARAM_PROPERTIES' => '*OSSL_ALG_PARAM_PROPERTIES', # utf8 string
+ 'OSSL_KDF_PARAM_ITER' => "iter", # unsigned int
+ 'OSSL_KDF_PARAM_MODE' => "mode", # utf8 string or int
+ 'OSSL_KDF_PARAM_PKCS5' => "pkcs5", # int
+ 'OSSL_KDF_PARAM_UKM' => "ukm", # octet string
+ 'OSSL_KDF_PARAM_CEK_ALG' => "cekalg", # utf8 string
+ 'OSSL_KDF_PARAM_SCRYPT_N' => "n", # uint64_t
+ 'OSSL_KDF_PARAM_SCRYPT_R' => "r", # uint32_t
+ 'OSSL_KDF_PARAM_SCRYPT_P' => "p", # uint32_t
+ 'OSSL_KDF_PARAM_SCRYPT_MAXMEM' => "maxmem_bytes", # uint64_t
+ 'OSSL_KDF_PARAM_INFO' => "info", # octet string
+ 'OSSL_KDF_PARAM_SEED' => "seed", # octet string
+ 'OSSL_KDF_PARAM_SSHKDF_XCGHASH' => "xcghash", # octet string
+ 'OSSL_KDF_PARAM_SSHKDF_SESSION_ID' => "session_id", # octet string
+ 'OSSL_KDF_PARAM_SSHKDF_TYPE' => "type", # int
+ 'OSSL_KDF_PARAM_SIZE' => "size", # size_t
+ 'OSSL_KDF_PARAM_CONSTANT' => "constant", # octet string
+ 'OSSL_KDF_PARAM_PKCS12_ID' => "id", # int
+ 'OSSL_KDF_PARAM_KBKDF_USE_L' => "use-l", # int
+ 'OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR' => "use-separator", # int
+ 'OSSL_KDF_PARAM_KBKDF_R' => "r", # int
+ 'OSSL_KDF_PARAM_X942_ACVPINFO' => "acvp-info",
+ 'OSSL_KDF_PARAM_X942_PARTYUINFO' => "partyu-info",
+ 'OSSL_KDF_PARAM_X942_PARTYVINFO' => "partyv-info",
+ 'OSSL_KDF_PARAM_X942_SUPP_PUBINFO' => "supp-pubinfo",
+ 'OSSL_KDF_PARAM_X942_SUPP_PRIVINFO' => "supp-privinfo",
+ 'OSSL_KDF_PARAM_X942_USE_KEYBITS' => "use-keybits",
+ 'OSSL_KDF_PARAM_HMACDRBG_ENTROPY' => "entropy",
+ 'OSSL_KDF_PARAM_HMACDRBG_NONCE' => "nonce",
+ 'OSSL_KDF_PARAM_THREADS' => "threads", # uint32_t
+ 'OSSL_KDF_PARAM_EARLY_CLEAN' => "early_clean", # uint32_t
+ 'OSSL_KDF_PARAM_ARGON2_AD' => "ad", # octet string
+ 'OSSL_KDF_PARAM_ARGON2_LANES' => "lanes", # uint32_t
+ 'OSSL_KDF_PARAM_ARGON2_MEMCOST' => "memcost", # uint32_t
+ 'OSSL_KDF_PARAM_ARGON2_VERSION' => "version", # uint32_t
+ 'OSSL_KDF_PARAM_FIPS_EMS_CHECK' => "ems_check", # int
+ 'OSSL_KDF_PARAM_FIPS_DIGEST_CHECK' => '*OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK',
+ 'OSSL_KDF_PARAM_FIPS_KEY_CHECK' => '*OSSL_PKEY_PARAM_FIPS_KEY_CHECK',
+ 'OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
# Known RAND names
- 'RAND_PARAM_STATE' => "state",
- 'RAND_PARAM_STRENGTH' => "strength",
- 'RAND_PARAM_MAX_REQUEST' => "max_request",
- 'RAND_PARAM_TEST_ENTROPY' => "test_entropy",
- 'RAND_PARAM_TEST_NONCE' => "test_nonce",
- 'RAND_PARAM_GENERATE' => "generate",
- 'RAND_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_RAND_PARAM_STATE' => "state",
+ 'OSSL_RAND_PARAM_STRENGTH' => "strength",
+ 'OSSL_RAND_PARAM_MAX_REQUEST' => "max_request",
+ 'OSSL_RAND_PARAM_TEST_ENTROPY' => "test_entropy",
+ 'OSSL_RAND_PARAM_TEST_NONCE' => "test_nonce",
+ 'OSSL_RAND_PARAM_GENERATE' => "generate",
+ 'OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
# RAND/DRBG names
- 'DRBG_PARAM_RESEED_REQUESTS' => "reseed_requests",
- 'DRBG_PARAM_RESEED_TIME_INTERVAL' => "reseed_time_interval",
- 'DRBG_PARAM_MIN_ENTROPYLEN' => "min_entropylen",
- 'DRBG_PARAM_MAX_ENTROPYLEN' => "max_entropylen",
- 'DRBG_PARAM_MIN_NONCELEN' => "min_noncelen",
- 'DRBG_PARAM_MAX_NONCELEN' => "max_noncelen",
- 'DRBG_PARAM_MAX_PERSLEN' => "max_perslen",
- 'DRBG_PARAM_MAX_ADINLEN' => "max_adinlen",
- 'DRBG_PARAM_RESEED_COUNTER' => "reseed_counter",
- 'DRBG_PARAM_RESEED_TIME' => "reseed_time",
- 'DRBG_PARAM_PROPERTIES' => '*ALG_PARAM_PROPERTIES',
- 'DRBG_PARAM_DIGEST' => '*ALG_PARAM_DIGEST',
- 'DRBG_PARAM_CIPHER' => '*ALG_PARAM_CIPHER',
- 'DRBG_PARAM_MAC' => '*ALG_PARAM_MAC',
- 'DRBG_PARAM_USE_DF' => "use_derivation_function",
- 'DRBG_PARAM_FIPS_DIGEST_CHECK' => '*PKEY_PARAM_FIPS_DIGEST_CHECK',
- 'DRBG_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_DRBG_PARAM_RESEED_REQUESTS' => "reseed_requests",
+ 'OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL' => "reseed_time_interval",
+ 'OSSL_DRBG_PARAM_MIN_ENTROPYLEN' => "min_entropylen",
+ 'OSSL_DRBG_PARAM_MAX_ENTROPYLEN' => "max_entropylen",
+ 'OSSL_DRBG_PARAM_MIN_NONCELEN' => "min_noncelen",
+ 'OSSL_DRBG_PARAM_MAX_NONCELEN' => "max_noncelen",
+ 'OSSL_DRBG_PARAM_MAX_PERSLEN' => "max_perslen",
+ 'OSSL_DRBG_PARAM_MAX_ADINLEN' => "max_adinlen",
+ 'OSSL_DRBG_PARAM_RESEED_COUNTER' => "reseed_counter",
+ 'OSSL_DRBG_PARAM_RESEED_TIME' => "reseed_time",
+ 'OSSL_DRBG_PARAM_PROPERTIES' => '*OSSL_ALG_PARAM_PROPERTIES',
+ 'OSSL_DRBG_PARAM_DIGEST' => '*OSSL_ALG_PARAM_DIGEST',
+ 'OSSL_DRBG_PARAM_CIPHER' => '*OSSL_ALG_PARAM_CIPHER',
+ 'OSSL_DRBG_PARAM_MAC' => '*OSSL_ALG_PARAM_MAC',
+ 'OSSL_DRBG_PARAM_USE_DF' => "use_derivation_function",
+ 'OSSL_DRBG_PARAM_FIPS_DIGEST_CHECK' => '*OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK',
+ 'OSSL_DRBG_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
# DRBG call back parameters
- 'DRBG_PARAM_ENTROPY_REQUIRED' => "entropy_required",
- 'DRBG_PARAM_PREDICTION_RESISTANCE' => "prediction_resistance",
- 'DRBG_PARAM_MIN_LENGTH' => "minium_length",
- 'DRBG_PARAM_MAX_LENGTH' => "maxium_length",
- 'DRBG_PARAM_RANDOM_DATA' => "random_data",
- 'DRBG_PARAM_SIZE' => "size",
+ 'OSSL_DRBG_PARAM_ENTROPY_REQUIRED' => "entropy_required",
+ 'OSSL_DRBG_PARAM_PREDICTION_RESISTANCE' => "prediction_resistance",
+ 'OSSL_DRBG_PARAM_MIN_LENGTH' => "minium_length",
+ 'OSSL_DRBG_PARAM_MAX_LENGTH' => "maxium_length",
+ 'OSSL_DRBG_PARAM_RANDOM_DATA' => "random_data",
+ 'OSSL_DRBG_PARAM_SIZE' => "size",
# PKEY parameters
# Common PKEY parameters
- 'PKEY_PARAM_BITS' => "bits",# integer
- 'PKEY_PARAM_MAX_SIZE' => "max-size",# integer
- 'PKEY_PARAM_SECURITY_BITS' => "security-bits",# integer
- 'PKEY_PARAM_SECURITY_CATEGORY' => '*ALG_PARAM_SECURITY_CATEGORY',
- 'PKEY_PARAM_DIGEST' => '*ALG_PARAM_DIGEST',
- 'PKEY_PARAM_CIPHER' => '*ALG_PARAM_CIPHER', # utf8 string
- 'PKEY_PARAM_ENGINE' => '*ALG_PARAM_ENGINE', # utf8 string
- 'PKEY_PARAM_PROPERTIES' => '*ALG_PARAM_PROPERTIES',
- 'PKEY_PARAM_DEFAULT_DIGEST' => "default-digest",# utf8 string
- 'PKEY_PARAM_MANDATORY_DIGEST' => "mandatory-digest",# utf8 string
- 'PKEY_PARAM_PAD_MODE' => "pad-mode",
- 'PKEY_PARAM_DIGEST_SIZE' => "digest-size",
- 'PKEY_PARAM_MASKGENFUNC' => "mgf",
- 'PKEY_PARAM_MGF1_DIGEST' => "mgf1-digest",
- 'PKEY_PARAM_MGF1_PROPERTIES' => "mgf1-properties",
- 'PKEY_PARAM_ENCODED_PUBLIC_KEY' => "encoded-pub-key",
- 'PKEY_PARAM_GROUP_NAME' => "group",
- 'PKEY_PARAM_DIST_ID' => "distid",
- 'PKEY_PARAM_PUB_KEY' => "pub",
- 'PKEY_PARAM_PRIV_KEY' => "priv",
+ 'OSSL_PKEY_PARAM_BITS' => "bits",# integer
+ 'OSSL_PKEY_PARAM_MAX_SIZE' => "max-size",# integer
+ 'OSSL_PKEY_PARAM_SECURITY_BITS' => "security-bits",# integer
+ 'OSSL_PKEY_PARAM_SECURITY_CATEGORY' => '*OSSL_ALG_PARAM_SECURITY_CATEGORY',
+ 'OSSL_PKEY_PARAM_DIGEST' => '*OSSL_ALG_PARAM_DIGEST',
+ 'OSSL_PKEY_PARAM_CIPHER' => '*OSSL_ALG_PARAM_CIPHER', # utf8 string
+ 'OSSL_PKEY_PARAM_ENGINE' => '*OSSL_ALG_PARAM_ENGINE', # utf8 string
+ 'OSSL_PKEY_PARAM_PROPERTIES' => '*OSSL_ALG_PARAM_PROPERTIES',
+ 'OSSL_PKEY_PARAM_DEFAULT_DIGEST' => "default-digest",# utf8 string
+ 'OSSL_PKEY_PARAM_MANDATORY_DIGEST' => "mandatory-digest",# utf8 string
+ 'OSSL_PKEY_PARAM_PAD_MODE' => "pad-mode",
+ 'OSSL_PKEY_PARAM_DIGEST_SIZE' => "digest-size",
+ 'OSSL_PKEY_PARAM_MASKGENFUNC' => "mgf",
+ 'OSSL_PKEY_PARAM_MGF1_DIGEST' => "mgf1-digest",
+ 'OSSL_PKEY_PARAM_MGF1_PROPERTIES' => "mgf1-properties",
+ 'OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY' => "encoded-pub-key",
+ 'OSSL_PKEY_PARAM_GROUP_NAME' => "group",
+ 'OSSL_PKEY_PARAM_DIST_ID' => "distid",
+ 'OSSL_PKEY_PARAM_PUB_KEY' => "pub",
+ 'OSSL_PKEY_PARAM_PRIV_KEY' => "priv",
# PKEY_PARAM_IMPLICIT_REJECTION isn't actually used, or meaningful. We keep
# it for API stability, but please use ASYM_CIPHER_PARAM_IMPLICIT_REJECTION
# instead.
- 'PKEY_PARAM_IMPLICIT_REJECTION' => "implicit-rejection",
- 'PKEY_PARAM_FIPS_DIGEST_CHECK' => "digest-check",
- 'PKEY_PARAM_FIPS_KEY_CHECK' => "key-check",
- 'PKEY_PARAM_ALGORITHM_ID' => '*ALG_PARAM_ALGORITHM_ID',
- 'PKEY_PARAM_ALGORITHM_ID_PARAMS' => '*ALG_PARAM_ALGORITHM_ID_PARAMS',
- 'PKEY_PARAM_CMS_RI_TYPE' => "ri-type", # integer
- 'PKEY_PARAM_CMS_KEMRI_KDF_ALGORITHM' => "kemri-kdf-alg",
+ 'OSSL_PKEY_PARAM_IMPLICIT_REJECTION' => "implicit-rejection",
+ 'OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK' => "digest-check",
+ 'OSSL_PKEY_PARAM_FIPS_KEY_CHECK' => "key-check",
+ 'OSSL_PKEY_PARAM_ALGORITHM_ID' => '*OSSL_ALG_PARAM_ALGORITHM_ID',
+ 'OSSL_PKEY_PARAM_ALGORITHM_ID_PARAMS' => '*OSSL_ALG_PARAM_ALGORITHM_ID_PARAMS',
+ 'OSSL_PKEY_PARAM_CMS_RI_TYPE' => "ri-type", # integer
+ 'OSSL_PKEY_PARAM_CMS_KEMRI_KDF_ALGORITHM' => "kemri-kdf-alg",
# Diffie-Hellman/DSA Parameters
- 'PKEY_PARAM_FFC_P' => "p",
- 'PKEY_PARAM_FFC_G' => "g",
- 'PKEY_PARAM_FFC_Q' => "q",
- 'PKEY_PARAM_FFC_GINDEX' => "gindex",
- 'PKEY_PARAM_FFC_PCOUNTER' => "pcounter",
- 'PKEY_PARAM_FFC_SEED' => "seed",
- 'PKEY_PARAM_FFC_COFACTOR' => "j",
- 'PKEY_PARAM_FFC_H' => "hindex",
- 'PKEY_PARAM_FFC_VALIDATE_PQ' => "validate-pq",
- 'PKEY_PARAM_FFC_VALIDATE_G' => "validate-g",
- 'PKEY_PARAM_FFC_VALIDATE_LEGACY' => "validate-legacy",
+ 'OSSL_PKEY_PARAM_FFC_P' => "p",
+ 'OSSL_PKEY_PARAM_FFC_G' => "g",
+ 'OSSL_PKEY_PARAM_FFC_Q' => "q",
+ 'OSSL_PKEY_PARAM_FFC_GINDEX' => "gindex",
+ 'OSSL_PKEY_PARAM_FFC_PCOUNTER' => "pcounter",
+ 'OSSL_PKEY_PARAM_FFC_SEED' => "seed",
+ 'OSSL_PKEY_PARAM_FFC_COFACTOR' => "j",
+ 'OSSL_PKEY_PARAM_FFC_H' => "hindex",
+ 'OSSL_PKEY_PARAM_FFC_VALIDATE_PQ' => "validate-pq",
+ 'OSSL_PKEY_PARAM_FFC_VALIDATE_G' => "validate-g",
+ 'OSSL_PKEY_PARAM_FFC_VALIDATE_LEGACY' => "validate-legacy",
# Diffie-Hellman params
- 'PKEY_PARAM_DH_GENERATOR' => "safeprime-generator",
- 'PKEY_PARAM_DH_PRIV_LEN' => "priv_len",
+ 'OSSL_PKEY_PARAM_DH_GENERATOR' => "safeprime-generator",
+ 'OSSL_PKEY_PARAM_DH_PRIV_LEN' => "priv_len",
# Elliptic Curve Domain Parameters
- 'PKEY_PARAM_EC_PUB_X' => "qx",
- 'PKEY_PARAM_EC_PUB_Y' => "qy",
+ 'OSSL_PKEY_PARAM_EC_PUB_X' => "qx",
+ 'OSSL_PKEY_PARAM_EC_PUB_Y' => "qy",
# Elliptic Curve Explicit Domain Parameters
- 'PKEY_PARAM_EC_FIELD_TYPE' => "field-type",
- 'PKEY_PARAM_EC_P' => "p",
- 'PKEY_PARAM_EC_A' => "a",
- 'PKEY_PARAM_EC_B' => "b",
- 'PKEY_PARAM_EC_GENERATOR' => "generator",
- 'PKEY_PARAM_EC_ORDER' => "order",
- 'PKEY_PARAM_EC_COFACTOR' => "cofactor",
- 'PKEY_PARAM_EC_SEED' => "seed",
- 'PKEY_PARAM_EC_CHAR2_M' => "m",
- 'PKEY_PARAM_EC_CHAR2_TYPE' => "basis-type",
- 'PKEY_PARAM_EC_CHAR2_TP_BASIS' => "tp",
- 'PKEY_PARAM_EC_CHAR2_PP_K1' => "k1",
- 'PKEY_PARAM_EC_CHAR2_PP_K2' => "k2",
- 'PKEY_PARAM_EC_CHAR2_PP_K3' => "k3",
- 'PKEY_PARAM_EC_DECODED_FROM_EXPLICIT_PARAMS' => "decoded-from-explicit",
+ 'OSSL_PKEY_PARAM_EC_FIELD_TYPE' => "field-type",
+ 'OSSL_PKEY_PARAM_EC_P' => "p",
+ 'OSSL_PKEY_PARAM_EC_A' => "a",
+ 'OSSL_PKEY_PARAM_EC_B' => "b",
+ 'OSSL_PKEY_PARAM_EC_GENERATOR' => "generator",
+ 'OSSL_PKEY_PARAM_EC_ORDER' => "order",
+ 'OSSL_PKEY_PARAM_EC_COFACTOR' => "cofactor",
+ 'OSSL_PKEY_PARAM_EC_SEED' => "seed",
+ 'OSSL_PKEY_PARAM_EC_CHAR2_M' => "m",
+ 'OSSL_PKEY_PARAM_EC_CHAR2_TYPE' => "basis-type",
+ 'OSSL_PKEY_PARAM_EC_CHAR2_TP_BASIS' => "tp",
+ 'OSSL_PKEY_PARAM_EC_CHAR2_PP_K1' => "k1",
+ 'OSSL_PKEY_PARAM_EC_CHAR2_PP_K2' => "k2",
+ 'OSSL_PKEY_PARAM_EC_CHAR2_PP_K3' => "k3",
+ 'OSSL_PKEY_PARAM_EC_DECODED_FROM_EXPLICIT_PARAMS' => "decoded-from-explicit",
# Elliptic Curve Key Parameters
- 'PKEY_PARAM_USE_COFACTOR_FLAG' => "use-cofactor-flag",
- 'PKEY_PARAM_USE_COFACTOR_ECDH' => '*PKEY_PARAM_USE_COFACTOR_FLAG',
+ 'OSSL_PKEY_PARAM_USE_COFACTOR_FLAG' => "use-cofactor-flag",
+ 'OSSL_PKEY_PARAM_USE_COFACTOR_ECDH' => '*OSSL_PKEY_PARAM_USE_COFACTOR_FLAG',
# RSA Keys
#
@@ -376,212 +376,212 @@ my %params = (
# (the base i for the coefficients is 2, not 1, at least as implied by
# RFC 8017)
- 'PKEY_PARAM_RSA_N' => "n",
- 'PKEY_PARAM_RSA_E' => "e",
- 'PKEY_PARAM_RSA_D' => "d",
- 'PKEY_PARAM_RSA_FACTOR' => "rsa-factor",
- 'PKEY_PARAM_RSA_EXPONENT' => "rsa-exponent",
- 'PKEY_PARAM_RSA_COEFFICIENT' => "rsa-coefficient",
- 'PKEY_PARAM_RSA_FACTOR1' => "rsa-factor1",
- 'PKEY_PARAM_RSA_FACTOR2' => "rsa-factor2",
- 'PKEY_PARAM_RSA_FACTOR3' => "rsa-factor3",
- 'PKEY_PARAM_RSA_FACTOR4' => "rsa-factor4",
- 'PKEY_PARAM_RSA_FACTOR5' => "rsa-factor5",
- 'PKEY_PARAM_RSA_FACTOR6' => "rsa-factor6",
- 'PKEY_PARAM_RSA_FACTOR7' => "rsa-factor7",
- 'PKEY_PARAM_RSA_FACTOR8' => "rsa-factor8",
- 'PKEY_PARAM_RSA_FACTOR9' => "rsa-factor9",
- 'PKEY_PARAM_RSA_FACTOR10' => "rsa-factor10",
- 'PKEY_PARAM_RSA_EXPONENT1' => "rsa-exponent1",
- 'PKEY_PARAM_RSA_EXPONENT2' => "rsa-exponent2",
- 'PKEY_PARAM_RSA_EXPONENT3' => "rsa-exponent3",
- 'PKEY_PARAM_RSA_EXPONENT4' => "rsa-exponent4",
- 'PKEY_PARAM_RSA_EXPONENT5' => "rsa-exponent5",
- 'PKEY_PARAM_RSA_EXPONENT6' => "rsa-exponent6",
- 'PKEY_PARAM_RSA_EXPONENT7' => "rsa-exponent7",
- 'PKEY_PARAM_RSA_EXPONENT8' => "rsa-exponent8",
- 'PKEY_PARAM_RSA_EXPONENT9' => "rsa-exponent9",
- 'PKEY_PARAM_RSA_EXPONENT10' => "rsa-exponent10",
- 'PKEY_PARAM_RSA_COEFFICIENT1' => "rsa-coefficient1",
- 'PKEY_PARAM_RSA_COEFFICIENT2' => "rsa-coefficient2",
- 'PKEY_PARAM_RSA_COEFFICIENT3' => "rsa-coefficient3",
- 'PKEY_PARAM_RSA_COEFFICIENT4' => "rsa-coefficient4",
- 'PKEY_PARAM_RSA_COEFFICIENT5' => "rsa-coefficient5",
- 'PKEY_PARAM_RSA_COEFFICIENT6' => "rsa-coefficient6",
- 'PKEY_PARAM_RSA_COEFFICIENT7' => "rsa-coefficient7",
- 'PKEY_PARAM_RSA_COEFFICIENT8' => "rsa-coefficient8",
- 'PKEY_PARAM_RSA_COEFFICIENT9' => "rsa-coefficient9",
+ 'OSSL_PKEY_PARAM_RSA_N' => "n",
+ 'OSSL_PKEY_PARAM_RSA_E' => "e",
+ 'OSSL_PKEY_PARAM_RSA_D' => "d",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR' => "rsa-factor",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT' => "rsa-exponent",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT' => "rsa-coefficient",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR1' => "rsa-factor1",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR2' => "rsa-factor2",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR3' => "rsa-factor3",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR4' => "rsa-factor4",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR5' => "rsa-factor5",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR6' => "rsa-factor6",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR7' => "rsa-factor7",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR8' => "rsa-factor8",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR9' => "rsa-factor9",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR10' => "rsa-factor10",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT1' => "rsa-exponent1",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT2' => "rsa-exponent2",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT3' => "rsa-exponent3",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT4' => "rsa-exponent4",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT5' => "rsa-exponent5",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT6' => "rsa-exponent6",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT7' => "rsa-exponent7",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT8' => "rsa-exponent8",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT9' => "rsa-exponent9",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT10' => "rsa-exponent10",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT1' => "rsa-coefficient1",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT2' => "rsa-coefficient2",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT3' => "rsa-coefficient3",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT4' => "rsa-coefficient4",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT5' => "rsa-coefficient5",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT6' => "rsa-coefficient6",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT7' => "rsa-coefficient7",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT8' => "rsa-coefficient8",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT9' => "rsa-coefficient9",
# Key generation parameters
- 'PKEY_PARAM_RSA_BITS' => '*PKEY_PARAM_BITS',
- 'PKEY_PARAM_RSA_PRIMES' => "primes",
- 'PKEY_PARAM_RSA_DIGEST' => '*PKEY_PARAM_DIGEST',
- 'PKEY_PARAM_RSA_DIGEST_PROPS' => '*PKEY_PARAM_PROPERTIES',
- 'PKEY_PARAM_RSA_MASKGENFUNC' => '*PKEY_PARAM_MASKGENFUNC',
- 'PKEY_PARAM_RSA_MGF1_DIGEST' => '*PKEY_PARAM_MGF1_DIGEST',
- 'PKEY_PARAM_RSA_PSS_SALTLEN' => "saltlen",
- 'PKEY_PARAM_RSA_DERIVE_FROM_PQ' => "rsa-derive-from-pq",
+ 'OSSL_PKEY_PARAM_RSA_BITS' => '*OSSL_PKEY_PARAM_BITS',
+ 'OSSL_PKEY_PARAM_RSA_PRIMES' => "primes",
+ 'OSSL_PKEY_PARAM_RSA_DIGEST' => '*OSSL_PKEY_PARAM_DIGEST',
+ 'OSSL_PKEY_PARAM_RSA_DIGEST_PROPS' => '*OSSL_PKEY_PARAM_PROPERTIES',
+ 'OSSL_PKEY_PARAM_RSA_MASKGENFUNC' => '*OSSL_PKEY_PARAM_MASKGENFUNC',
+ 'OSSL_PKEY_PARAM_RSA_MGF1_DIGEST' => '*OSSL_PKEY_PARAM_MGF1_DIGEST',
+ 'OSSL_PKEY_PARAM_RSA_PSS_SALTLEN' => "saltlen",
+ 'OSSL_PKEY_PARAM_RSA_DERIVE_FROM_PQ' => "rsa-derive-from-pq",
# EC, X25519 and X448 Key generation parameters
- 'PKEY_PARAM_DHKEM_IKM' => "dhkem-ikm",
+ 'OSSL_PKEY_PARAM_DHKEM_IKM' => "dhkem-ikm",
# ML-KEM parameters
- 'PKEY_PARAM_ML_KEM_SEED' => "seed",
- 'PKEY_PARAM_ML_KEM_PREFER_SEED' => "ml-kem.prefer_seed",
- 'PKEY_PARAM_ML_KEM_RETAIN_SEED' => "ml-kem.retain_seed",
- 'PKEY_PARAM_ML_KEM_INPUT_FORMATS' => "ml-kem.input_formats",
- 'PKEY_PARAM_ML_KEM_OUTPUT_FORMATS' => "ml-kem.output_formats",
- 'PKEY_PARAM_ML_KEM_IMPORT_PCT_TYPE' => "ml-kem.import_pct_type",
+ 'OSSL_PKEY_PARAM_ML_KEM_SEED' => "seed",
+ 'OSSL_PKEY_PARAM_ML_KEM_PREFER_SEED' => "ml-kem.prefer_seed",
+ 'OSSL_PKEY_PARAM_ML_KEM_RETAIN_SEED' => "ml-kem.retain_seed",
+ 'OSSL_PKEY_PARAM_ML_KEM_INPUT_FORMATS' => "ml-kem.input_formats",
+ 'OSSL_PKEY_PARAM_ML_KEM_OUTPUT_FORMATS' => "ml-kem.output_formats",
+ 'OSSL_PKEY_PARAM_ML_KEM_IMPORT_PCT_TYPE' => "ml-kem.import_pct_type",
# Key generation parameters
- 'PKEY_PARAM_FFC_TYPE' => "type",
- 'PKEY_PARAM_FFC_PBITS' => "pbits",
- 'PKEY_PARAM_FFC_QBITS' => "qbits",
- 'PKEY_PARAM_FFC_DIGEST' => '*PKEY_PARAM_DIGEST',
- 'PKEY_PARAM_FFC_DIGEST_PROPS' => '*PKEY_PARAM_PROPERTIES',
-
- 'PKEY_PARAM_EC_ENCODING' => "encoding",# utf8_string
- 'PKEY_PARAM_EC_POINT_CONVERSION_FORMAT' => "point-format",
- 'PKEY_PARAM_EC_GROUP_CHECK_TYPE' => "group-check",
- 'PKEY_PARAM_EC_INCLUDE_PUBLIC' => "include-public",
- 'PKEY_PARAM_FIPS_SIGN_CHECK' => "sign-check",
- 'PKEY_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_PKEY_PARAM_FFC_TYPE' => "type",
+ 'OSSL_PKEY_PARAM_FFC_PBITS' => "pbits",
+ 'OSSL_PKEY_PARAM_FFC_QBITS' => "qbits",
+ 'OSSL_PKEY_PARAM_FFC_DIGEST' => '*OSSL_PKEY_PARAM_DIGEST',
+ 'OSSL_PKEY_PARAM_FFC_DIGEST_PROPS' => '*OSSL_PKEY_PARAM_PROPERTIES',
+
+ 'OSSL_PKEY_PARAM_EC_ENCODING' => "encoding",# utf8_string
+ 'OSSL_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT' => "point-format",
+ 'OSSL_PKEY_PARAM_EC_GROUP_CHECK_TYPE' => "group-check",
+ 'OSSL_PKEY_PARAM_EC_INCLUDE_PUBLIC' => "include-public",
+ 'OSSL_PKEY_PARAM_FIPS_SIGN_CHECK' => "sign-check",
+ 'OSSL_PKEY_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
# ML_DSA Key generation parameter
- 'PKEY_PARAM_ML_DSA_SEED' => "seed",
- 'PKEY_PARAM_ML_DSA_RETAIN_SEED' => "ml-dsa.retain_seed",
- 'PKEY_PARAM_ML_DSA_PREFER_SEED' => "ml-dsa.prefer_seed",
- 'PKEY_PARAM_ML_DSA_INPUT_FORMATS' => "ml-dsa.input_formats",
- 'PKEY_PARAM_ML_DSA_OUTPUT_FORMATS' => "ml-dsa.output_formats",
+ 'OSSL_PKEY_PARAM_ML_DSA_SEED' => "seed",
+ 'OSSL_PKEY_PARAM_ML_DSA_RETAIN_SEED' => "ml-dsa.retain_seed",
+ 'OSSL_PKEY_PARAM_ML_DSA_PREFER_SEED' => "ml-dsa.prefer_seed",
+ 'OSSL_PKEY_PARAM_ML_DSA_INPUT_FORMATS' => "ml-dsa.input_formats",
+ 'OSSL_PKEY_PARAM_ML_DSA_OUTPUT_FORMATS' => "ml-dsa.output_formats",
# SLH_DSA Key generation parameters
- 'PKEY_PARAM_SLH_DSA_SEED' => "seed",
+ 'OSSL_PKEY_PARAM_SLH_DSA_SEED' => "seed",
# Key Exchange parameters
- 'EXCHANGE_PARAM_PAD' => "pad",# uint
- 'EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE' => "ecdh-cofactor-mode",# int
- 'EXCHANGE_PARAM_KDF_TYPE' => "kdf-type",# utf8_string
- 'EXCHANGE_PARAM_KDF_DIGEST' => "kdf-digest",# utf8_string
- 'EXCHANGE_PARAM_KDF_DIGEST_PROPS' => "kdf-digest-props",# utf8_string
- 'EXCHANGE_PARAM_KDF_OUTLEN' => "kdf-outlen",# size_t
+ 'OSSL_EXCHANGE_PARAM_PAD' => "pad",# uint
+ 'OSSL_EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE' => "ecdh-cofactor-mode",# int
+ 'OSSL_EXCHANGE_PARAM_KDF_TYPE' => "kdf-type",# utf8_string
+ 'OSSL_EXCHANGE_PARAM_KDF_DIGEST' => "kdf-digest",# utf8_string
+ 'OSSL_EXCHANGE_PARAM_KDF_DIGEST_PROPS' => "kdf-digest-props",# utf8_string
+ 'OSSL_EXCHANGE_PARAM_KDF_OUTLEN' => "kdf-outlen",# size_t
# The following parameter is an octet_string on set and an octet_ptr on get
- 'EXCHANGE_PARAM_KDF_UKM' => "kdf-ukm",
- 'EXCHANGE_PARAM_FIPS_DIGEST_CHECK' => '*PKEY_PARAM_FIPS_DIGEST_CHECK',
- 'EXCHANGE_PARAM_FIPS_KEY_CHECK' => '*PKEY_PARAM_FIPS_KEY_CHECK',
- 'EXCHANGE_PARAM_FIPS_ECDH_COFACTOR_CHECK' => '*PROV_PARAM_ECDH_COFACTOR_CHECK',
- 'EXCHANGE_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_EXCHANGE_PARAM_KDF_UKM' => "kdf-ukm",
+ 'OSSL_EXCHANGE_PARAM_FIPS_DIGEST_CHECK' => '*OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK',
+ 'OSSL_EXCHANGE_PARAM_FIPS_KEY_CHECK' => '*OSSL_PKEY_PARAM_FIPS_KEY_CHECK',
+ 'OSSL_EXCHANGE_PARAM_FIPS_ECDH_COFACTOR_CHECK' => '*OSSL_PROV_PARAM_ECDH_COFACTOR_CHECK',
+ 'OSSL_EXCHANGE_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
# Signature parameters
- 'SIGNATURE_PARAM_ALGORITHM_ID' => '*PKEY_PARAM_ALGORITHM_ID',
- 'SIGNATURE_PARAM_ALGORITHM_ID_PARAMS' => '*PKEY_PARAM_ALGORITHM_ID_PARAMS',
- 'SIGNATURE_PARAM_PAD_MODE' => '*PKEY_PARAM_PAD_MODE',
- 'SIGNATURE_PARAM_DIGEST' => '*PKEY_PARAM_DIGEST',
- 'SIGNATURE_PARAM_PROPERTIES' => '*PKEY_PARAM_PROPERTIES',
- 'SIGNATURE_PARAM_PSS_SALTLEN' => "saltlen",
- 'SIGNATURE_PARAM_MGF1_DIGEST' => '*PKEY_PARAM_MGF1_DIGEST',
- 'SIGNATURE_PARAM_MGF1_PROPERTIES' => '*PKEY_PARAM_MGF1_PROPERTIES',
- 'SIGNATURE_PARAM_DIGEST_SIZE' => '*PKEY_PARAM_DIGEST_SIZE',
- 'SIGNATURE_PARAM_NONCE_TYPE' => "nonce-type",
- 'SIGNATURE_PARAM_INSTANCE' => "instance",
- 'SIGNATURE_PARAM_CONTEXT_STRING' => "context-string",
- 'SIGNATURE_PARAM_FIPS_DIGEST_CHECK' => '*PKEY_PARAM_FIPS_DIGEST_CHECK',
- 'SIGNATURE_PARAM_FIPS_VERIFY_MESSAGE' => 'verify-message',
- 'SIGNATURE_PARAM_FIPS_KEY_CHECK' => '*PKEY_PARAM_FIPS_KEY_CHECK',
- 'SIGNATURE_PARAM_FIPS_SIGN_CHECK' => '*PKEY_PARAM_FIPS_SIGN_CHECK',
- 'SIGNATURE_PARAM_FIPS_RSA_PSS_SALTLEN_CHECK' => "rsa-pss-saltlen-check",
- 'SIGNATURE_PARAM_FIPS_SIGN_X931_PAD_CHECK' => "sign-x931-pad-check",
- 'SIGNATURE_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
- 'SIGNATURE_PARAM_SIGNATURE' => "signature",
- 'SIGNATURE_PARAM_MESSAGE_ENCODING' => "message-encoding",
- 'SIGNATURE_PARAM_DETERMINISTIC' => "deterministic",
- 'SIGNATURE_PARAM_MU' => "mu", # int
- 'SIGNATURE_PARAM_TEST_ENTROPY' => "test-entropy",
- 'SIGNATURE_PARAM_ADD_RANDOM' => "additional-random",
+ 'OSSL_SIGNATURE_PARAM_ALGORITHM_ID' => '*OSSL_PKEY_PARAM_ALGORITHM_ID',
+ 'OSSL_SIGNATURE_PARAM_ALGORITHM_ID_PARAMS' => '*OSSL_PKEY_PARAM_ALGORITHM_ID_PARAMS',
+ 'OSSL_SIGNATURE_PARAM_PAD_MODE' => '*OSSL_PKEY_PARAM_PAD_MODE',
+ 'OSSL_SIGNATURE_PARAM_DIGEST' => '*OSSL_PKEY_PARAM_DIGEST',
+ 'OSSL_SIGNATURE_PARAM_PROPERTIES' => '*OSSL_PKEY_PARAM_PROPERTIES',
+ 'OSSL_SIGNATURE_PARAM_PSS_SALTLEN' => "saltlen",
+ 'OSSL_SIGNATURE_PARAM_MGF1_DIGEST' => '*OSSL_PKEY_PARAM_MGF1_DIGEST',
+ 'OSSL_SIGNATURE_PARAM_MGF1_PROPERTIES' => '*OSSL_PKEY_PARAM_MGF1_PROPERTIES',
+ 'OSSL_SIGNATURE_PARAM_DIGEST_SIZE' => '*OSSL_PKEY_PARAM_DIGEST_SIZE',
+ 'OSSL_SIGNATURE_PARAM_NONCE_TYPE' => "nonce-type",
+ 'OSSL_SIGNATURE_PARAM_INSTANCE' => "instance",
+ 'OSSL_SIGNATURE_PARAM_CONTEXT_STRING' => "context-string",
+ 'OSSL_SIGNATURE_PARAM_FIPS_DIGEST_CHECK' => '*OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK',
+ 'OSSL_SIGNATURE_PARAM_FIPS_VERIFY_MESSAGE' => 'verify-message',
+ 'OSSL_SIGNATURE_PARAM_FIPS_KEY_CHECK' => '*OSSL_PKEY_PARAM_FIPS_KEY_CHECK',
+ 'OSSL_SIGNATURE_PARAM_FIPS_SIGN_CHECK' => '*OSSL_PKEY_PARAM_FIPS_SIGN_CHECK',
+ 'OSSL_SIGNATURE_PARAM_FIPS_RSA_PSS_SALTLEN_CHECK' => "rsa-pss-saltlen-check",
+ 'OSSL_SIGNATURE_PARAM_FIPS_SIGN_X931_PAD_CHECK' => "sign-x931-pad-check",
+ 'OSSL_SIGNATURE_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_SIGNATURE_PARAM_SIGNATURE' => "signature",
+ 'OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING' => "message-encoding",
+ 'OSSL_SIGNATURE_PARAM_DETERMINISTIC' => "deterministic",
+ 'OSSL_SIGNATURE_PARAM_MU' => "mu", # int
+ 'OSSL_SIGNATURE_PARAM_TEST_ENTROPY' => "test-entropy",
+ 'OSSL_SIGNATURE_PARAM_ADD_RANDOM' => "additional-random",
# Asym cipher parameters
- 'ASYM_CIPHER_PARAM_DIGEST' => '*PKEY_PARAM_DIGEST',
- 'ASYM_CIPHER_PARAM_PROPERTIES' => '*PKEY_PARAM_PROPERTIES',
- 'ASYM_CIPHER_PARAM_ENGINE' => '*PKEY_PARAM_ENGINE',
- 'ASYM_CIPHER_PARAM_PAD_MODE' => '*PKEY_PARAM_PAD_MODE',
- 'ASYM_CIPHER_PARAM_MGF1_DIGEST' => '*PKEY_PARAM_MGF1_DIGEST',
- 'ASYM_CIPHER_PARAM_MGF1_DIGEST_PROPS' => '*PKEY_PARAM_MGF1_PROPERTIES',
- 'ASYM_CIPHER_PARAM_OAEP_DIGEST' => '*ALG_PARAM_DIGEST',
- 'ASYM_CIPHER_PARAM_OAEP_DIGEST_PROPS' => "digest-props",
+ 'OSSL_ASYM_CIPHER_PARAM_DIGEST' => '*OSSL_PKEY_PARAM_DIGEST',
+ 'OSSL_ASYM_CIPHER_PARAM_PROPERTIES' => '*OSSL_PKEY_PARAM_PROPERTIES',
+ 'OSSL_ASYM_CIPHER_PARAM_ENGINE' => '*OSSL_PKEY_PARAM_ENGINE',
+ 'OSSL_ASYM_CIPHER_PARAM_PAD_MODE' => '*OSSL_PKEY_PARAM_PAD_MODE',
+ 'OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST' => '*OSSL_PKEY_PARAM_MGF1_DIGEST',
+ 'OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST_PROPS' => '*OSSL_PKEY_PARAM_MGF1_PROPERTIES',
+ 'OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST' => '*OSSL_ALG_PARAM_DIGEST',
+ 'OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST_PROPS' => "digest-props",
# The following parameter is an octet_string on set and an octet_ptr on get
- 'ASYM_CIPHER_PARAM_OAEP_LABEL' => "oaep-label",
- 'ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION' => "tls-client-version",
- 'ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION' => "tls-negotiated-version",
- 'ASYM_CIPHER_PARAM_IMPLICIT_REJECTION' => "implicit-rejection",
- 'ASYM_CIPHER_PARAM_FIPS_RSA_PKCS15_PAD_DISABLED' => '*PROV_PARAM_RSA_PKCS15_PAD_DISABLED',
- 'ASYM_CIPHER_PARAM_FIPS_KEY_CHECK' => '*PKEY_PARAM_FIPS_KEY_CHECK',
- 'ASYM_CIPHER_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL' => "oaep-label",
+ 'OSSL_ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION' => "tls-client-version",
+ 'OSSL_ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION' => "tls-negotiated-version",
+ 'OSSL_ASYM_CIPHER_PARAM_IMPLICIT_REJECTION' => "implicit-rejection",
+ 'OSSL_ASYM_CIPHER_PARAM_FIPS_RSA_PKCS15_PAD_DISABLED' => '*OSSL_PROV_PARAM_RSA_PKCS15_PAD_DISABLED',
+ 'OSSL_ASYM_CIPHER_PARAM_FIPS_KEY_CHECK' => '*OSSL_PKEY_PARAM_FIPS_KEY_CHECK',
+ 'OSSL_ASYM_CIPHER_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
# Encoder / decoder parameters
- 'ENCODER_PARAM_CIPHER' => '*ALG_PARAM_CIPHER',
- 'ENCODER_PARAM_PROPERTIES' => '*ALG_PARAM_PROPERTIES',
+ 'OSSL_ENCODER_PARAM_CIPHER' => '*OSSL_ALG_PARAM_CIPHER',
+ 'OSSL_ENCODER_PARAM_PROPERTIES' => '*OSSL_ALG_PARAM_PROPERTIES',
# Currently PVK only, but reusable for others as needed
- 'ENCODER_PARAM_ENCRYPT_LEVEL' => "encrypt-level",
- 'ENCODER_PARAM_SAVE_PARAMETERS' => "save-parameters",# integer
+ 'OSSL_ENCODER_PARAM_ENCRYPT_LEVEL' => "encrypt-level",
+ 'OSSL_ENCODER_PARAM_SAVE_PARAMETERS' => "save-parameters",# integer
- 'DECODER_PARAM_PROPERTIES' => '*ALG_PARAM_PROPERTIES',
+ 'OSSL_DECODER_PARAM_PROPERTIES' => '*OSSL_ALG_PARAM_PROPERTIES',
# Passphrase callback parameters
- 'PASSPHRASE_PARAM_INFO' => "info",
+ 'OSSL_PASSPHRASE_PARAM_INFO' => "info",
# Keygen callback parameters, from provider to libcrypto
- 'GEN_PARAM_POTENTIAL' => "potential",# integer
- 'GEN_PARAM_ITERATION' => "iteration",# integer
+ 'OSSL_GEN_PARAM_POTENTIAL' => "potential",# integer
+ 'OSSL_GEN_PARAM_ITERATION' => "iteration",# integer
# ACVP Test parameters : These should not be used normally
- 'PKEY_PARAM_RSA_TEST_XP1' => "xp1",
- 'PKEY_PARAM_RSA_TEST_XP2' => "xp2",
- 'PKEY_PARAM_RSA_TEST_XP' => "xp",
- 'PKEY_PARAM_RSA_TEST_XQ1' => "xq1",
- 'PKEY_PARAM_RSA_TEST_XQ2' => "xq2",
- 'PKEY_PARAM_RSA_TEST_XQ' => "xq",
- 'PKEY_PARAM_RSA_TEST_P1' => "p1",
- 'PKEY_PARAM_RSA_TEST_P2' => "p2",
- 'PKEY_PARAM_RSA_TEST_Q1' => "q1",
- 'PKEY_PARAM_RSA_TEST_Q2' => "q2",
- 'SIGNATURE_PARAM_KAT' => "kat",
+ 'OSSL_PKEY_PARAM_RSA_TEST_XP1' => "xp1",
+ 'OSSL_PKEY_PARAM_RSA_TEST_XP2' => "xp2",
+ 'OSSL_PKEY_PARAM_RSA_TEST_XP' => "xp",
+ 'OSSL_PKEY_PARAM_RSA_TEST_XQ1' => "xq1",
+ 'OSSL_PKEY_PARAM_RSA_TEST_XQ2' => "xq2",
+ 'OSSL_PKEY_PARAM_RSA_TEST_XQ' => "xq",
+ 'OSSL_PKEY_PARAM_RSA_TEST_P1' => "p1",
+ 'OSSL_PKEY_PARAM_RSA_TEST_P2' => "p2",
+ 'OSSL_PKEY_PARAM_RSA_TEST_Q1' => "q1",
+ 'OSSL_PKEY_PARAM_RSA_TEST_Q2' => "q2",
+ 'OSSL_SIGNATURE_PARAM_KAT' => "kat",
# KEM parameters
- 'KEM_PARAM_OPERATION' => "operation",
- 'KEM_PARAM_IKME' => "ikme",
- 'KEM_PARAM_FIPS_KEY_CHECK' => '*PKEY_PARAM_FIPS_KEY_CHECK',
- 'KEM_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_KEM_PARAM_OPERATION' => "operation",
+ 'OSSL_KEM_PARAM_IKME' => "ikme",
+ 'OSSL_KEM_PARAM_FIPS_KEY_CHECK' => '*OSSL_PKEY_PARAM_FIPS_KEY_CHECK',
+ 'OSSL_KEM_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
# Capabilities
# TLS-GROUP Capability
- 'CAPABILITY_TLS_GROUP_NAME' => "tls-group-name",
- 'CAPABILITY_TLS_GROUP_NAME_INTERNAL' => "tls-group-name-internal",
- 'CAPABILITY_TLS_GROUP_ID' => "tls-group-id",
- 'CAPABILITY_TLS_GROUP_ALG' => "tls-group-alg",
- 'CAPABILITY_TLS_GROUP_SECURITY_BITS' => "tls-group-sec-bits",
- 'CAPABILITY_TLS_GROUP_IS_KEM' => "tls-group-is-kem",
- 'CAPABILITY_TLS_GROUP_MIN_TLS' => "tls-min-tls",
- 'CAPABILITY_TLS_GROUP_MAX_TLS' => "tls-max-tls",
- 'CAPABILITY_TLS_GROUP_MIN_DTLS' => "tls-min-dtls",
- 'CAPABILITY_TLS_GROUP_MAX_DTLS' => "tls-max-dtls",
+ 'OSSL_CAPABILITY_TLS_GROUP_NAME' => "tls-group-name",
+ 'OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL' => "tls-group-name-internal",
+ 'OSSL_CAPABILITY_TLS_GROUP_ID' => "tls-group-id",
+ 'OSSL_CAPABILITY_TLS_GROUP_ALG' => "tls-group-alg",
+ 'OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS' => "tls-group-sec-bits",
+ 'OSSL_CAPABILITY_TLS_GROUP_IS_KEM' => "tls-group-is-kem",
+ 'OSSL_CAPABILITY_TLS_GROUP_MIN_TLS' => "tls-min-tls",
+ 'OSSL_CAPABILITY_TLS_GROUP_MAX_TLS' => "tls-max-tls",
+ 'OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS' => "tls-min-dtls",
+ 'OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS' => "tls-max-dtls",
# TLS-SIGALG Capability
- 'CAPABILITY_TLS_SIGALG_IANA_NAME' => "tls-sigalg-iana-name",
- 'CAPABILITY_TLS_SIGALG_CODE_POINT' => "tls-sigalg-code-point",
- 'CAPABILITY_TLS_SIGALG_NAME' => "tls-sigalg-name",
- 'CAPABILITY_TLS_SIGALG_OID' => "tls-sigalg-oid",
- 'CAPABILITY_TLS_SIGALG_SIG_NAME' => "tls-sigalg-sig-name",
- 'CAPABILITY_TLS_SIGALG_SIG_OID' => "tls-sigalg-sig-oid",
- 'CAPABILITY_TLS_SIGALG_HASH_NAME' => "tls-sigalg-hash-name",
- 'CAPABILITY_TLS_SIGALG_HASH_OID' => "tls-sigalg-hash-oid",
- 'CAPABILITY_TLS_SIGALG_KEYTYPE' => "tls-sigalg-keytype",
- 'CAPABILITY_TLS_SIGALG_KEYTYPE_OID' => "tls-sigalg-keytype-oid",
- 'CAPABILITY_TLS_SIGALG_SECURITY_BITS' => "tls-sigalg-sec-bits",
- 'CAPABILITY_TLS_SIGALG_MIN_TLS' => "tls-min-tls",
- 'CAPABILITY_TLS_SIGALG_MAX_TLS' => "tls-max-tls",
- 'CAPABILITY_TLS_SIGALG_MIN_DTLS' => "tls-min-dtls",
- 'CAPABILITY_TLS_SIGALG_MAX_DTLS' => "tls-max-dtls",
+ 'OSSL_CAPABILITY_TLS_SIGALG_IANA_NAME' => "tls-sigalg-iana-name",
+ 'OSSL_CAPABILITY_TLS_SIGALG_CODE_POINT' => "tls-sigalg-code-point",
+ 'OSSL_CAPABILITY_TLS_SIGALG_NAME' => "tls-sigalg-name",
+ 'OSSL_CAPABILITY_TLS_SIGALG_OID' => "tls-sigalg-oid",
+ 'OSSL_CAPABILITY_TLS_SIGALG_SIG_NAME' => "tls-sigalg-sig-name",
+ 'OSSL_CAPABILITY_TLS_SIGALG_SIG_OID' => "tls-sigalg-sig-oid",
+ 'OSSL_CAPABILITY_TLS_SIGALG_HASH_NAME' => "tls-sigalg-hash-name",
+ 'OSSL_CAPABILITY_TLS_SIGALG_HASH_OID' => "tls-sigalg-hash-oid",
+ 'OSSL_CAPABILITY_TLS_SIGALG_KEYTYPE' => "tls-sigalg-keytype",
+ 'OSSL_CAPABILITY_TLS_SIGALG_KEYTYPE_OID' => "tls-sigalg-keytype-oid",
+ 'OSSL_CAPABILITY_TLS_SIGALG_SECURITY_BITS' => "tls-sigalg-sec-bits",
+ 'OSSL_CAPABILITY_TLS_SIGALG_MIN_TLS' => "tls-min-tls",
+ 'OSSL_CAPABILITY_TLS_SIGALG_MAX_TLS' => "tls-max-tls",
+ 'OSSL_CAPABILITY_TLS_SIGALG_MIN_DTLS' => "tls-min-dtls",
+ 'OSSL_CAPABILITY_TLS_SIGALG_MAX_DTLS' => "tls-max-dtls",
# storemgmt parameters
@@ -598,36 +598,36 @@ my %params = (
# are used as search criteria.
# (STORE_PARAM_DIGEST is used with STORE_PARAM_FINGERPRINT)
- 'STORE_PARAM_EXPECT' => "expect", # INTEGER
- 'STORE_PARAM_SUBJECT' => "subject", # DER blob => OCTET_STRING
- 'STORE_PARAM_ISSUER' => "name", # DER blob => OCTET_STRING
- 'STORE_PARAM_SERIAL' => "serial", # INTEGER
- 'STORE_PARAM_DIGEST' => "digest", # UTF8_STRING
- 'STORE_PARAM_FINGERPRINT' => "fingerprint", # OCTET_STRING
- 'STORE_PARAM_ALIAS' => "alias", # UTF8_STRING
+ 'OSSL_STORE_PARAM_EXPECT' => "expect", # INTEGER
+ 'OSSL_STORE_PARAM_SUBJECT' => "subject", # DER blob => OCTET_STRING
+ 'OSSL_STORE_PARAM_ISSUER' => "name", # DER blob => OCTET_STRING
+ 'OSSL_STORE_PARAM_SERIAL' => "serial", # INTEGER
+ 'OSSL_STORE_PARAM_DIGEST' => "digest", # UTF8_STRING
+ 'OSSL_STORE_PARAM_FINGERPRINT' => "fingerprint", # OCTET_STRING
+ 'OSSL_STORE_PARAM_ALIAS' => "alias", # UTF8_STRING
# You may want to pass properties for the provider implementation to use
- 'STORE_PARAM_PROPERTIES' => "properties", # utf8_string
+ 'OSSL_STORE_PARAM_PROPERTIES' => "properties", # utf8_string
# DECODER input type if a decoder is used by the store
- 'STORE_PARAM_INPUT_TYPE' => "input-type", # UTF8_STRING
+ 'OSSL_STORE_PARAM_INPUT_TYPE' => "input-type", # UTF8_STRING
# Libssl record layer
- 'LIBSSL_RECORD_LAYER_PARAM_OPTIONS' => "options",
- 'LIBSSL_RECORD_LAYER_PARAM_MODE' => "mode",
- 'LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD' => "read_ahead",
- 'LIBSSL_RECORD_LAYER_READ_BUFFER_LEN' => "read_buffer_len",
- 'LIBSSL_RECORD_LAYER_PARAM_USE_ETM' => "use_etm",
- 'LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC' => "stream_mac",
- 'LIBSSL_RECORD_LAYER_PARAM_TLSTREE' => "tlstree",
- 'LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN' => "max_frag_len",
- 'LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA' => "max_early_data",
- 'LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING' => "block_padding",
- 'LIBSSL_RECORD_LAYER_PARAM_HS_PADDING' => "hs_padding",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS' => "options",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_MODE' => "mode",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD' => "read_ahead",
+ 'OSSL_LIBSSL_RECORD_LAYER_READ_BUFFER_LEN' => "read_buffer_len",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_USE_ETM' => "use_etm",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC' => "stream_mac",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_TLSTREE' => "tlstree",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN' => "max_frag_len",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA' => "max_early_data",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING' => "block_padding",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_HS_PADDING' => "hs_padding",
# Symmetric Key parametes
- 'SKEY_PARAM_RAW_BYTES' => "raw-bytes",
- 'SKEY_PARAM_KEY_LENGTH' => "key-length",
+ 'OSSL_SKEY_PARAM_RAW_BYTES' => "raw-bytes",
+ 'OSSL_SKEY_PARAM_KEY_LENGTH' => "key-length",
);
sub output_ifdef {
@@ -663,10 +663,10 @@ sub generate_public_macros {
foreach my $name (keys %params) {
my $val = $params{$name};
- my $def = '# define OSSL_' . $name . ' ';
+ my $def = '# define ' . $name . ' ';
if (substr($val, 0, 1) eq '*') {
- $def .= 'OSSL_' . substr($val, 1);
+ $def .= substr($val, 1);
} else {
$def .= '"' . $val . '"';
}
@@ -873,7 +873,7 @@ sub output_param_decoder {
}
}
output_ifdef($ifdefs{$pident});
- print " OSSL_PARAM_$ptype(OSSL_$pname, NULL";
+ print " OSSL_PARAM_$ptype($pname, NULL";
print ", 0" if $ptype eq "octet_string" || $ptype eq "octet_ptr"
|| $ptype eq "utf8_string" || $ptype eq "utf8_ptr"
|| $ptype eq "BN";