From d1ba5857c0fc88086559aa8ecb8a54223e6e70ca Mon Sep 17 00:00:00 2001 From: Pauli Date: Fri, 12 Sep 2025 19:03:12 +1000 Subject: [PATCH] Add OSSL_ prefix back onto param names Reviewed-by: Matt Caswell Reviewed-by: Tomas Mraz Reviewed-by: Dmitry Belyavskiy (Merged from https://github.com/openssl/openssl/pull/28529) --- .../implementations/asymciphers/rsa_enc.c.in | 42 +- .../implementations/asymciphers/sm2_enc.c.in | 8 +- .../ciphers/cipher_chacha20_poly1305.c.in | 20 +- .../implementations/ciphers/ciphercommon.c.in | 56 +- .../ciphers/ciphercommon_ccm.c.in | 22 +- .../ciphers/ciphercommon_gcm.c.in | 28 +- .../implementations/digests/blake2_prov.c.in | 4 +- .../implementations/digests/digestcommon.c.in | 8 +- .../implementations/digests/sha3_prov.c.in | 8 +- .../encode_decode/decode_der2key.c.in | 2 +- .../encode_decode/decode_epki2pki.c.in | 2 +- .../encode_decode/decode_pem2der.c.in | 4 +- .../encode_decode/decode_pvk2key.c.in | 2 +- .../encode_decode/decode_spki2typespki.c.in | 2 +- .../encode_decode/encode_key2any.c.in | 6 +- .../encode_decode/encode_key2ms.c.in | 2 +- .../implementations/exchange/dh_exch.c.in | 30 +- .../implementations/exchange/ecdh_exch.c.in | 30 +- .../implementations/exchange/ecx_exch.c.in | 2 +- .../include/prov/blake2_params.inc.in | 12 +- providers/implementations/kdfs/argon2.c.in | 26 +- providers/implementations/kdfs/hkdf.c.in | 70 +- .../implementations/kdfs/hmacdrbg_kdf.c.in | 14 +- providers/implementations/kdfs/kbkdf.c.in | 32 +- providers/implementations/kdfs/krb5kdf.c.in | 12 +- providers/implementations/kdfs/pbkdf1.c.in | 14 +- providers/implementations/kdfs/pbkdf2.c.in | 18 +- providers/implementations/kdfs/pkcs12kdf.c.in | 16 +- providers/implementations/kdfs/pvkkdf.c.in | 12 +- providers/implementations/kdfs/scrypt.c.in | 16 +- providers/implementations/kdfs/sshkdf.c.in | 22 +- providers/implementations/kdfs/sskdf.c.in | 46 +- providers/implementations/kdfs/tls1_prf.c.in | 20 +- providers/implementations/kdfs/x942kdf.c.in | 32 +- providers/implementations/kem/ec_kem.c.in | 4 +- providers/implementations/kem/ecx_kem.c.in | 4 +- providers/implementations/kem/ml_kem_kem.c.in | 2 +- providers/implementations/kem/rsa_kem.c.in | 6 +- .../implementations/keymgmt/dh_kmgmt.c.in | 84 +- .../implementations/keymgmt/dsa_kmgmt.c.in | 52 +- .../implementations/keymgmt/ecx_kmgmt.c.in | 44 +- .../implementations/keymgmt/lms_kmgmt.c.in | 2 +- .../keymgmt/mac_legacy_kmgmt.c.in | 32 +- .../implementations/keymgmt/ml_dsa_kmgmt.c.in | 26 +- .../implementations/keymgmt/ml_kem_kmgmt.c.in | 32 +- .../implementations/keymgmt/mlx_kmgmt.c.in | 22 +- .../keymgmt/slh_dsa_kmgmt.c.in | 22 +- .../keymgmt/template_kmgmt.c.in | 18 +- providers/implementations/macs/cmac_prov.c.in | 16 +- providers/implementations/macs/gmac_prov.c.in | 12 +- providers/implementations/macs/hmac_prov.c.in | 18 +- providers/implementations/macs/kmac_prov.c.in | 24 +- .../implementations/macs/poly1305_prov.c.in | 4 +- .../implementations/macs/siphash_prov.c.in | 14 +- providers/implementations/rands/drbg_ctr.c.in | 44 +- .../implementations/rands/drbg_hash.c.in | 44 +- .../implementations/rands/drbg_hmac.c.in | 48 +- .../implementations/rands/fips_crng_test.c.in | 8 +- providers/implementations/rands/seed_src.c.in | 6 +- .../rands/seed_src_jitter.c.in | 6 +- providers/implementations/rands/test_rng.c.in | 20 +- .../implementations/signature/dsa_sig.c.in | 30 +- .../implementations/signature/ecdsa_sig.c.in | 36 +- .../implementations/signature/eddsa_sig.c.in | 8 +- .../implementations/signature/ml_dsa_sig.c.in | 24 +- .../implementations/signature/rsa_sig.c.in | 64 +- .../signature/slh_dsa_sig.c.in | 10 +- .../implementations/signature/sm2_sig.c.in | 12 +- .../implementations/skeymgmt/generic.c.in | 2 +- .../implementations/storemgmt/file_store.c.in | 8 +- .../storemgmt/file_store_any2obj.c.in | 2 +- .../storemgmt/winstore_store.c.in | 4 +- util/perl/OpenSSL/paramnames.pm | 926 +++++++++--------- 73 files changed, 1190 insertions(+), 1190 deletions(-) diff --git a/providers/implementations/asymciphers/rsa_enc.c.in b/providers/implementations/asymciphers/rsa_enc.c.in index 6d1e97d934d..6fcb6f74f59 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 21bc746b57c..a8271a83419 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 deb5c2046e1..8a474395dd2 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 77412a841b6..b0d88f89d8e 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 8ff30b9bed2..56bfb6d3dc2 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 27bd48bd698..4964f15e67d 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 3651f8783ec..5ec80bf1777 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 5dd3f032b49..ad9cec04be7 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 20e2959a3d3..ef1701ff0ff 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 d3258ddf1a9..22e7ad58030 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 3e684a8cfe0..3c3b794d865 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 8bb94525ab2..7512da13092 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 bfa5a2ee3d6..8dfd57bb0d8 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 f84035fb183..210f2f5efde 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 d9faeea3e74..d293f2256eb 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 319fc279a30..ec3f3050a79 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 779b2cec96b..0aa4c85bb99 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 69cae378aab..43e1b78d589 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 9ffb98252c1..5fa6595cedf 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 cca0dcff561..37d9f158bae 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 fc65074d3ee..3b99b5b5486 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 3e0bbb53f3d..5f118bb9caf 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 4629872d9a3..64fd2b4f2c7 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 69c37964911..8131e8a56aa 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 25fb96b003c..03878b0b3f8 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 12b7b6f8de8..3441d33cb47 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 cdffbfc90cd..ea625502791 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 ff216d8ff5c..1495bcd2a6b 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 37073de2357..59a67f0e137 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 0543d1f5947..4462b60dadd 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 8e09a65ebb6..8ef5b688eb8 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 0928e0e2598..3b3cada8d34 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 f1a63eae50f..8dc4e44cd69 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 e71ab93b782..5b4dd086099 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 ef73e9ceb30..370ef833ada 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 7458664e9a0..bb9037dc4db 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 5c361ae8893..1c9a816e02c 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 9a0d6434c19..1613dd7307e 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 740d38c1bfd..44e89999037 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 d636f28a672..d329b6ab89b 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 932b573ff66..1a75cd1c32b 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 7ba2c9d229c..8b6a941444d 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 630cd9771b9..2eefe6bc9a3 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 fb1005918d0..9a550133cbc 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 8b995015ba9..e92241a8458 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 7738b2d4544..b52bd343df8 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 e2690731efa..129a11f92e9 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 cd4620f4123..9095188b1e0 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 f8c2db4d487..0d3b3d5d6dd 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 b3d6578c334..0b60ac77392 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 4d9bb3ec784..e6ca3484038 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 6046d2ddcc7..630851cc8e1 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 3dc95f68e2e..fe833c59662 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 ab574d1f1cb..5d8433e16d2 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 9d129ef9db3..347ecf1ae6a 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 7fdfe7c7d12..cf518007216 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 4a52b5ed08b..a0ab3995593 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 ab0812288ce..4be6aaa3622 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 b6a1a6e381d..36c8d70a987 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 1139c7395a4..4d73f075741 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 70a8691686a..f6389d36621 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 5b64a0cd160..b208992ee19 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 741f5ffc473..d2e954b1af6 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 5e37351a41c..1ef925253d6 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 6717fcfdd41..a12618ac715 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 2c9d0c85f6d..90b6f5d154e 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 abe099f898d..909691637c9 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 ec73fbfe427..0ce7f752e77 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 cbb1d42c32a..d32624b9308 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 c2483faca34..c1007af34cc 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 eef6f6f03ca..c21c3ad3723 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 610d44eaa72..5539e1e8467 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 cf5be346eb9..f51833dfc15 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"; -- 2.47.3