root
/
openssl
mirror of https://github.com/openssl/openssl.git
1
0
Fork 0
Code Issues Actions 7 Packages Projects Releases Wiki Activity

Add OSSL_ prefix back onto param names 

Reviewed-by: Matt Caswell <matt@openssl.org>
Reviewed-by: Tomas Mraz <tomas@openssl.org>
Reviewed-by: Dmitry Belyavskiy <beldmit@gmail.com>
(Merged from https://github.com/openssl/openssl/pull/28529)
This commit is contained in:
Pauli 2025-09-12 19:03:12 +10:00
parent 4732ce799c
commit d1ba5857c0
73 changed files with 1188 additions and 1188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
providers/implementations/asymciphers/rsa_enc.c.in
View File

@ -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[])

8
providers/implementations/asymciphers/sm2_enc.c.in
View File

@ -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[])

20
providers/implementations/ciphers/cipher_chacha20_poly1305.c.in
View File

@ -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(

56
providers/implementations/ciphers/ciphercommon.c.in
View File

@ -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

22
providers/implementations/ciphers/ciphercommon_ccm.c.in
View File

@ -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(

28
providers/implementations/ciphers/ciphercommon_gcm.c.in
View File

@ -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(

4
providers/implementations/digests/blake2_prov.c.in
View File

@ -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,

8
providers/implementations/digests/digestcommon.c.in
View File

@ -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,

8
providers/implementations/digests/sha3_prov.c.in
View File

@ -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,

2
providers/implementations/encode_decode/decode_der2key.c.in
View File

@ -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)

2
providers/implementations/encode_decode/decode_epki2pki.c.in
View File

@ -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)

4
providers/implementations/encode_decode/decode_pem2der.c.in
View File

@ -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)

2
providers/implementations/encode_decode/decode_pvk2key.c.in
View File

@ -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)

2
providers/implementations/encode_decode/decode_spki2typespki.c.in
View File

@ -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)

6
providers/implementations/encode_decode/encode_key2any.c.in
View File

@ -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)

2
providers/implementations/encode_decode/encode_key2ms.c.in
View File

@ -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)

30
providers/implementations/exchange/dh_exch.c.in
View File

@ -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,

30
providers/implementations/exchange/ecdh_exch.c.in
View File

@ -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

2
providers/implementations/exchange/ecx_exch.c.in
View File

@ -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

12
providers/implementations/include/prov/blake2_params.inc.in
View File

@ -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'],
)); -}

26
providers/implementations/kdfs/argon2.c.in
View File

@ -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[])

70
providers/implementations/kdfs/hkdf.c.in
View File

@ -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[])

14
providers/implementations/kdfs/hmacdrbg_kdf.c.in
View File

@ -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,

32
providers/implementations/kdfs/kbkdf.c.in
View File

@ -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[])

12
providers/implementations/kdfs/krb5kdf.c.in
View File

@ -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[])

14
providers/implementations/kdfs/pbkdf1.c.in
View File

@ -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[])

18
providers/implementations/kdfs/pbkdf2.c.in
View File

@ -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[])

16
providers/implementations/kdfs/pkcs12kdf.c.in
View File

@ -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[])

12
providers/implementations/kdfs/pvkkdf.c.in
View File

@ -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[])

16
providers/implementations/kdfs/scrypt.c.in
View File

@ -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[])

22
providers/implementations/kdfs/sshkdf.c.in
View File

@ -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[])

46
providers/implementations/kdfs/sskdf.c.in
View File

@ -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[])

20
providers/implementations/kdfs/tls1_prf.c.in
View File

@ -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[])

32
providers/implementations/kdfs/x942kdf.c.in
View File

@ -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[])

4
providers/implementations/kem/ec_kem.c.in
View File

@ -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[])

4
providers/implementations/kem/ecx_kem.c.in
View File

@ -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[])

2
providers/implementations/kem/ml_kem_kem.c.in
View File

@ -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[])

6
providers/implementations/kem/rsa_kem.c.in
View File

@ -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[])

84
providers/implementations/keymgmt/dh_kmgmt.c.in
View File

@ -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,

52
providers/implementations/keymgmt/dsa_kmgmt.c.in
View File

@ -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)

44
providers/implementations/keymgmt/ecx_kmgmt.c.in
View File

@ -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[])

2
providers/implementations/keymgmt/lms_kmgmt.c.in
View File

@ -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[])

32
providers/implementations/keymgmt/mac_legacy_kmgmt.c.in
View File

@ -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[])

26
providers/implementations/keymgmt/ml_dsa_kmgmt.c.in
View File

@ -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[])

32
providers/implementations/keymgmt/ml_kem_kmgmt.c.in
View File

@ -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[])

22
providers/implementations/keymgmt/mlx_kmgmt.c.in
View File

@ -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[])

22
providers/implementations/keymgmt/slh_dsa_kmgmt.c.in
View File

@ -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[])

18
providers/implementations/keymgmt/template_kmgmt.c.in
View File

@ -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[])

16
providers/implementations/macs/cmac_prov.c.in
View File

@ -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,

12
providers/implementations/macs/gmac_prov.c.in
View File

@ -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,

18
providers/implementations/macs/hmac_prov.c.in
View File

@ -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,

24
providers/implementations/macs/kmac_prov.c.in
View File

@ -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,

4
providers/implementations/macs/poly1305_prov.c.in
View File

@ -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,

14
providers/implementations/macs/siphash_prov.c.in
View File

@ -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,

44
providers/implementations/rands/drbg_ctr.c.in
View File

@ -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[])

44
providers/implementations/rands/drbg_hash.c.in
View File

@ -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[])

48
providers/implementations/rands/drbg_hmac.c.in
View File

@ -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[])

8
providers/implementations/rands/fips_crng_test.c.in
View File

@ -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[])

6
providers/implementations/rands/seed_src.c.in
View File

@ -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[])

6
providers/implementations/rands/seed_src_jitter.c.in
View File

@ -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[])

20
providers/implementations/rands/test_rng.c.in
View File

@ -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[])

30
providers/implementations/signature/dsa_sig.c.in
View File

@ -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,

36
providers/implementations/signature/ecdsa_sig.c.in
View File

@ -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,

8
providers/implementations/signature/eddsa_sig.c.in
View File

@ -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 *

24
providers/implementations/signature/ml_dsa_sig.c.in
View File

@ -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,

64
providers/implementations/signature/rsa_sig.c.in
View File

@ -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,

10
providers/implementations/signature/slh_dsa_sig.c.in
View File

@ -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,

12
providers/implementations/signature/sm2_sig.c.in
View File

@ -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[])

2
providers/implementations/skeymgmt/generic.c.in
View File

@ -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[])

8
providers/implementations/storemgmt/file_store.c.in
View File

@ -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)

2
providers/implementations/storemgmt/file_store_any2obj.c.in
View File

@ -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[])

4
providers/implementations/storemgmt/winstore_store.c.in
View File

@ -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[])

922
util/perl/OpenSSL/paramnames.pm
View File

File diff suppressed because it is too large Load Diff