}
{- 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)
}
{- 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[])
}
{- 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)
}
{- 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[])
}
{- 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[])
}
{- 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(
* 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)
#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
#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
#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
}
{- 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(
}
{- 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(
}
{- 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(
{- 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(
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,
}
{- 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,
#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,
}
{- 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,
}
{- 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,
}
{- 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)
}
{- 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)
}
{- 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)
}
{- 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)
}
{- 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)
}
{- 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)
}
{- 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)
}
{- 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[])
}
{- 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,
}
{- 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
}
{- 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
#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
#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'],
)); -}
}
{- 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[],
}
{- 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[])
#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[])
}
{- 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,
#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[])
#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[])
}
{- 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[])
}
{- 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,
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
#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[])
}
{- 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[])
#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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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)
}
{- 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[])
#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[])
}
{- 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)
#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,
#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[])
}
{- 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[])
}
{- 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)
}
{- 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[])
#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 */
}
{- 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[])
}
{- 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[])
}
{- 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[])
#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[])
#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[])
#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[])
#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[])
#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[])
#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[])
#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[])
}
{- 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'],
)); -}
/**
}
{- 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)
}
{- 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[])
}
{- 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)
}
{- 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)
}
{- 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)
}
{- 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[])
}
{- 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 {
}
{- 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)
}
{- 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)
}
{- 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[])
}
{- 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[])
}
{- 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)
}
{- 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[])
}
{- 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,
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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,
}
{- 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,
}
{- 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)
}
{- 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,
}
{- 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,
}
{- 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,
#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)
}
{- 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,
}
{- 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,
}
{- 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)
}
{- 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,
}
{- 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,
}
{- 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,
#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[])
#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[])
#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[])
#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[])
#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[])
#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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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[])
}
{- 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)
#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[])
#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,
}
{- 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)
#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[])
#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,
}
{- 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)
}
{- 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
#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 *
#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[])
}
{- 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,
}
{- 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)
#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[])
}
{- 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,
}
{- 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[])
}
{- 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,
}
{- 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)
}
{- 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[])
}
{- 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[])
*/
{- 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)
}
{- 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[])
}
{- 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[])
my %params = (
# Well known parameter names that core passes to providers
- 'PROV_PARAM_CORE_VERSION' => "openssl-version",# utf8_ptr
- 'PROV_PARAM_CORE_PROV_NAME' => "provider-name", # utf8_ptr
- 'PROV_PARAM_CORE_MODULE_FILENAME' => "module-filename",# utf8_ptr
+ 'OSSL_PROV_PARAM_CORE_VERSION' => "openssl-version",# utf8_ptr
+ 'OSSL_PROV_PARAM_CORE_PROV_NAME' => "provider-name", # utf8_ptr
+ 'OSSL_PROV_PARAM_CORE_MODULE_FILENAME' => "module-filename",# utf8_ptr
# Well known parameter names that Providers can define
- 'PROV_PARAM_NAME' => "name", # utf8_ptr
- 'PROV_PARAM_VERSION' => "version", # utf8_ptr
- 'PROV_PARAM_BUILDINFO' => "buildinfo", # utf8_ptr
- 'PROV_PARAM_STATUS' => "status", # uint
- 'PROV_PARAM_SECURITY_CHECKS' => "security-checks", # uint
- 'PROV_PARAM_HMAC_KEY_CHECK' => "hmac-key-check", # uint
- 'PROV_PARAM_KMAC_KEY_CHECK' => "kmac-key-check", # uint
- 'PROV_PARAM_TLS1_PRF_EMS_CHECK' => "tls1-prf-ems-check", # uint
- 'PROV_PARAM_NO_SHORT_MAC' => "no-short-mac", # uint
- 'PROV_PARAM_DRBG_TRUNC_DIGEST' => "drbg-no-trunc-md", # uint
- 'PROV_PARAM_HKDF_DIGEST_CHECK' => "hkdf-digest-check", # uint
- 'PROV_PARAM_TLS13_KDF_DIGEST_CHECK' => "tls13-kdf-digest-check", # uint
- 'PROV_PARAM_TLS1_PRF_DIGEST_CHECK' => "tls1-prf-digest-check", # uint
- 'PROV_PARAM_SSHKDF_DIGEST_CHECK' => "sshkdf-digest-check", # uint
- 'PROV_PARAM_SSKDF_DIGEST_CHECK' => "sskdf-digest-check", # uint
- 'PROV_PARAM_X963KDF_DIGEST_CHECK' => "x963kdf-digest-check", # uint
- 'PROV_PARAM_DSA_SIGN_DISABLED' => "dsa-sign-disabled", # uint
- 'PROV_PARAM_TDES_ENCRYPT_DISABLED' => "tdes-encrypt-disabled", # uint
- 'PROV_PARAM_RSA_PSS_SALTLEN_CHECK' => "rsa-pss-saltlen-check", # uint
- 'PROV_PARAM_RSA_SIGN_X931_PAD_DISABLED' => "rsa-sign-x931-pad-disabled", # uint
- 'PROV_PARAM_RSA_PKCS15_PAD_DISABLED' => "rsa-pkcs15-pad-disabled", # uint
- 'PROV_PARAM_HKDF_KEY_CHECK' => "hkdf-key-check", # uint
- 'PROV_PARAM_KBKDF_KEY_CHECK' => "kbkdf-key-check", # uint
- 'PROV_PARAM_TLS13_KDF_KEY_CHECK' => "tls13-kdf-key-check", # uint
- 'PROV_PARAM_TLS1_PRF_KEY_CHECK' => "tls1-prf-key-check", # uint
- 'PROV_PARAM_SSHKDF_KEY_CHECK' => "sshkdf-key-check", # uint
- 'PROV_PARAM_SSKDF_KEY_CHECK' => "sskdf-key-check", # uint
- 'PROV_PARAM_X963KDF_KEY_CHECK' => "x963kdf-key-check", # uint
- 'PROV_PARAM_X942KDF_KEY_CHECK' => "x942kdf-key-check", # uint
- 'PROV_PARAM_PBKDF2_LOWER_BOUND_CHECK' => "pbkdf2-lower-bound-check", # uint
- 'PROV_PARAM_ECDH_COFACTOR_CHECK' => "ecdh-cofactor-check", # uint
- 'PROV_PARAM_SIGNATURE_DIGEST_CHECK' => "signature-digest-check", # uint
+ 'OSSL_PROV_PARAM_NAME' => "name", # utf8_ptr
+ 'OSSL_PROV_PARAM_VERSION' => "version", # utf8_ptr
+ 'OSSL_PROV_PARAM_BUILDINFO' => "buildinfo", # utf8_ptr
+ 'OSSL_PROV_PARAM_STATUS' => "status", # uint
+ 'OSSL_PROV_PARAM_SECURITY_CHECKS' => "security-checks", # uint
+ 'OSSL_PROV_PARAM_HMAC_KEY_CHECK' => "hmac-key-check", # uint
+ 'OSSL_PROV_PARAM_KMAC_KEY_CHECK' => "kmac-key-check", # uint
+ 'OSSL_PROV_PARAM_TLS1_PRF_EMS_CHECK' => "tls1-prf-ems-check", # uint
+ 'OSSL_PROV_PARAM_NO_SHORT_MAC' => "no-short-mac", # uint
+ 'OSSL_PROV_PARAM_DRBG_TRUNC_DIGEST' => "drbg-no-trunc-md", # uint
+ 'OSSL_PROV_PARAM_HKDF_DIGEST_CHECK' => "hkdf-digest-check", # uint
+ 'OSSL_PROV_PARAM_TLS13_KDF_DIGEST_CHECK' => "tls13-kdf-digest-check", # uint
+ 'OSSL_PROV_PARAM_TLS1_PRF_DIGEST_CHECK' => "tls1-prf-digest-check", # uint
+ 'OSSL_PROV_PARAM_SSHKDF_DIGEST_CHECK' => "sshkdf-digest-check", # uint
+ 'OSSL_PROV_PARAM_SSKDF_DIGEST_CHECK' => "sskdf-digest-check", # uint
+ 'OSSL_PROV_PARAM_X963KDF_DIGEST_CHECK' => "x963kdf-digest-check", # uint
+ 'OSSL_PROV_PARAM_DSA_SIGN_DISABLED' => "dsa-sign-disabled", # uint
+ 'OSSL_PROV_PARAM_TDES_ENCRYPT_DISABLED' => "tdes-encrypt-disabled", # uint
+ 'OSSL_PROV_PARAM_RSA_PSS_SALTLEN_CHECK' => "rsa-pss-saltlen-check", # uint
+ 'OSSL_PROV_PARAM_RSA_SIGN_X931_PAD_DISABLED' => "rsa-sign-x931-pad-disabled", # uint
+ 'OSSL_PROV_PARAM_RSA_PKCS15_PAD_DISABLED' => "rsa-pkcs15-pad-disabled", # uint
+ 'OSSL_PROV_PARAM_HKDF_KEY_CHECK' => "hkdf-key-check", # uint
+ 'OSSL_PROV_PARAM_KBKDF_KEY_CHECK' => "kbkdf-key-check", # uint
+ 'OSSL_PROV_PARAM_TLS13_KDF_KEY_CHECK' => "tls13-kdf-key-check", # uint
+ 'OSSL_PROV_PARAM_TLS1_PRF_KEY_CHECK' => "tls1-prf-key-check", # uint
+ 'OSSL_PROV_PARAM_SSHKDF_KEY_CHECK' => "sshkdf-key-check", # uint
+ 'OSSL_PROV_PARAM_SSKDF_KEY_CHECK' => "sskdf-key-check", # uint
+ 'OSSL_PROV_PARAM_X963KDF_KEY_CHECK' => "x963kdf-key-check", # uint
+ 'OSSL_PROV_PARAM_X942KDF_KEY_CHECK' => "x942kdf-key-check", # uint
+ 'OSSL_PROV_PARAM_PBKDF2_LOWER_BOUND_CHECK' => "pbkdf2-lower-bound-check", # uint
+ 'OSSL_PROV_PARAM_ECDH_COFACTOR_CHECK' => "ecdh-cofactor-check", # uint
+ 'OSSL_PROV_PARAM_SIGNATURE_DIGEST_CHECK' => "signature-digest-check", # uint
# Self test callback parameters
- 'PROV_PARAM_SELF_TEST_PHASE' => "st-phase",# utf8_string
- 'PROV_PARAM_SELF_TEST_TYPE' => "st-type", # utf8_string
- 'PROV_PARAM_SELF_TEST_DESC' => "st-desc", # utf8_string
+ 'OSSL_PROV_PARAM_SELF_TEST_PHASE' => "st-phase",# utf8_string
+ 'OSSL_PROV_PARAM_SELF_TEST_TYPE' => "st-type", # utf8_string
+ 'OSSL_PROV_PARAM_SELF_TEST_DESC' => "st-desc", # utf8_string
# Provider-native object abstractions
#
# This set of parameter names is explained in detail in provider-object(7)
# (doc/man7/provider-object.pod)
- 'OBJECT_PARAM_TYPE' => "type", # INTEGER
- 'OBJECT_PARAM_DATA_TYPE' => "data-type",# UTF8_STRING
- 'OBJECT_PARAM_DATA_STRUCTURE' => "data-structure",# UTF8_STRING
- 'OBJECT_PARAM_REFERENCE' => "reference",# OCTET_STRING
- 'OBJECT_PARAM_DATA' => "data",# OCTET_STRING or UTF8_STRING
- 'OBJECT_PARAM_DESC' => "desc", # UTF8_STRING
- 'OBJECT_PARAM_INPUT_TYPE' => "input-type", # UTF8_STRING
+ 'OSSL_OBJECT_PARAM_TYPE' => "type", # INTEGER
+ 'OSSL_OBJECT_PARAM_DATA_TYPE' => "data-type",# UTF8_STRING
+ 'OSSL_OBJECT_PARAM_DATA_STRUCTURE' => "data-structure",# UTF8_STRING
+ 'OSSL_OBJECT_PARAM_REFERENCE' => "reference",# OCTET_STRING
+ 'OSSL_OBJECT_PARAM_DATA' => "data",# OCTET_STRING or UTF8_STRING
+ 'OSSL_OBJECT_PARAM_DESC' => "desc", # UTF8_STRING
+ 'OSSL_OBJECT_PARAM_INPUT_TYPE' => "input-type", # UTF8_STRING
# Algorithm parameters
# If "engine",or "properties",are specified, they should always be paired
# Note these are common names that are shared by many types (such as kdf, mac,
# and pkey) e.g: see MAC_PARAM_DIGEST below.
- 'ALG_PARAM_DIGEST' => "digest", # utf8_string
- 'ALG_PARAM_CIPHER' => "cipher", # utf8_string
- 'ALG_PARAM_ENGINE' => "engine", # utf8_string
- 'ALG_PARAM_MAC' => "mac", # utf8_string
- 'ALG_PARAM_PROPERTIES' => "properties", # utf8_string
- 'ALG_PARAM_FIPS_APPROVED_INDICATOR' => 'fips-indicator', # int, -1, 0 or 1
- 'ALG_PARAM_SECURITY_CATEGORY' => "security-category", # int, 0 .. 5
+ 'OSSL_ALG_PARAM_DIGEST' => "digest", # utf8_string
+ 'OSSL_ALG_PARAM_CIPHER' => "cipher", # utf8_string
+ 'OSSL_ALG_PARAM_ENGINE' => "engine", # utf8_string
+ 'OSSL_ALG_PARAM_MAC' => "mac", # utf8_string
+ 'OSSL_ALG_PARAM_PROPERTIES' => "properties", # utf8_string
+ 'OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR' => 'fips-indicator', # int, -1, 0 or 1
+ 'OSSL_ALG_PARAM_SECURITY_CATEGORY' => "security-category", # int, 0 .. 5
# For any operation that deals with AlgorithmIdentifier, they should
# implement both of these.
# ALG_PARAM_ALGORITHM_ID_PARAMS is intended to be both settable
# and gettable, to allow the calling application to pass or get
# AlgID parameters to and from the provided implementation.
- 'ALG_PARAM_ALGORITHM_ID' => "algorithm-id", # octet_string (DER)
- 'ALG_PARAM_ALGORITHM_ID_PARAMS' => "algorithm-id-params", # octet_string
+ 'OSSL_ALG_PARAM_ALGORITHM_ID' => "algorithm-id", # octet_string (DER)
+ 'OSSL_ALG_PARAM_ALGORITHM_ID_PARAMS' => "algorithm-id-params", # octet_string
# cipher parameters
- 'CIPHER_PARAM_PADDING' => "padding", # uint
- 'CIPHER_PARAM_USE_BITS' => "use-bits", # uint
- 'CIPHER_PARAM_TLS_VERSION' => "tls-version", # uint
- 'CIPHER_PARAM_TLS_MAC' => "tls-mac", # octet_ptr
- 'CIPHER_PARAM_TLS_MAC_SIZE' => "tls-mac-size",# size_t
- 'CIPHER_PARAM_MODE' => "mode", # uint
- 'CIPHER_PARAM_BLOCK_SIZE' => "blocksize", # size_t
- 'CIPHER_PARAM_AEAD' => "aead", # int, 0 or 1
- 'CIPHER_PARAM_CUSTOM_IV' => "custom-iv", # int, 0 or 1
- 'CIPHER_PARAM_CTS' => "cts", # int, 0 or 1
- 'CIPHER_PARAM_TLS1_MULTIBLOCK' => "tls-multi", # int, 0 or 1
- 'CIPHER_PARAM_HAS_RAND_KEY' => "has-randkey", # int, 0 or 1
- 'CIPHER_PARAM_KEYLEN' => "keylen", # size_t
- 'CIPHER_PARAM_IVLEN' => "ivlen", # size_t
- 'CIPHER_PARAM_IV' => "iv", # octet_string OR octet_ptr
- 'CIPHER_PARAM_UPDATED_IV' => "updated-iv", # octet_string OR octet_ptr
- 'CIPHER_PARAM_NUM' => "num", # uint
- 'CIPHER_PARAM_ROUNDS' => "rounds", # uint
- 'CIPHER_PARAM_AEAD_TAG' => "tag", # octet_string
- 'CIPHER_PARAM_PIPELINE_AEAD_TAG' => "pipeline-tag",# octet_ptr
- 'CIPHER_PARAM_AEAD_TLS1_AAD' => "tlsaad", # octet_string
- 'CIPHER_PARAM_AEAD_TLS1_AAD_PAD' => "tlsaadpad", # size_t
- 'CIPHER_PARAM_AEAD_TLS1_IV_FIXED' => "tlsivfixed", # octet_string
- 'CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN' => "tlsivgen", # octet_string
- 'CIPHER_PARAM_AEAD_TLS1_SET_IV_INV' => "tlsivinv", # octet_string
- 'CIPHER_PARAM_AEAD_IVLEN' => '*CIPHER_PARAM_IVLEN',
- 'CIPHER_PARAM_AEAD_IV_GENERATED' => "iv-generated", # uint
- 'CIPHER_PARAM_AEAD_TAGLEN' => "taglen", # size_t
- 'CIPHER_PARAM_AEAD_MAC_KEY' => "mackey", # octet_string
- 'CIPHER_PARAM_RANDOM_KEY' => "randkey", # octet_string
- 'CIPHER_PARAM_RC2_KEYBITS' => "keybits", # size_t
- 'CIPHER_PARAM_SPEED' => "speed", # uint
- 'CIPHER_PARAM_CTS_MODE' => "cts_mode", # utf8_string
- 'CIPHER_PARAM_DECRYPT_ONLY' => "decrypt-only", # int, 0 or 1
- 'CIPHER_PARAM_FIPS_ENCRYPT_CHECK' => "encrypt-check", # int
- 'CIPHER_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
- 'CIPHER_PARAM_ALGORITHM_ID' => '*ALG_PARAM_ALGORITHM_ID',
+ 'OSSL_CIPHER_PARAM_PADDING' => "padding", # uint
+ 'OSSL_CIPHER_PARAM_USE_BITS' => "use-bits", # uint
+ 'OSSL_CIPHER_PARAM_TLS_VERSION' => "tls-version", # uint
+ 'OSSL_CIPHER_PARAM_TLS_MAC' => "tls-mac", # octet_ptr
+ 'OSSL_CIPHER_PARAM_TLS_MAC_SIZE' => "tls-mac-size",# size_t
+ 'OSSL_CIPHER_PARAM_MODE' => "mode", # uint
+ 'OSSL_CIPHER_PARAM_BLOCK_SIZE' => "blocksize", # size_t
+ 'OSSL_CIPHER_PARAM_AEAD' => "aead", # int, 0 or 1
+ 'OSSL_CIPHER_PARAM_CUSTOM_IV' => "custom-iv", # int, 0 or 1
+ 'OSSL_CIPHER_PARAM_CTS' => "cts", # int, 0 or 1
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK' => "tls-multi", # int, 0 or 1
+ 'OSSL_CIPHER_PARAM_HAS_RAND_KEY' => "has-randkey", # int, 0 or 1
+ 'OSSL_CIPHER_PARAM_KEYLEN' => "keylen", # size_t
+ 'OSSL_CIPHER_PARAM_IVLEN' => "ivlen", # size_t
+ 'OSSL_CIPHER_PARAM_IV' => "iv", # octet_string OR octet_ptr
+ 'OSSL_CIPHER_PARAM_UPDATED_IV' => "updated-iv", # octet_string OR octet_ptr
+ 'OSSL_CIPHER_PARAM_NUM' => "num", # uint
+ 'OSSL_CIPHER_PARAM_ROUNDS' => "rounds", # uint
+ 'OSSL_CIPHER_PARAM_AEAD_TAG' => "tag", # octet_string
+ 'OSSL_CIPHER_PARAM_PIPELINE_AEAD_TAG' => "pipeline-tag",# octet_ptr
+ 'OSSL_CIPHER_PARAM_AEAD_TLS1_AAD' => "tlsaad", # octet_string
+ 'OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD' => "tlsaadpad", # size_t
+ 'OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED' => "tlsivfixed", # octet_string
+ 'OSSL_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN' => "tlsivgen", # octet_string
+ 'OSSL_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV' => "tlsivinv", # octet_string
+ 'OSSL_CIPHER_PARAM_AEAD_IVLEN' => '*OSSL_CIPHER_PARAM_IVLEN',
+ 'OSSL_CIPHER_PARAM_AEAD_IV_GENERATED' => "iv-generated", # uint
+ 'OSSL_CIPHER_PARAM_AEAD_TAGLEN' => "taglen", # size_t
+ 'OSSL_CIPHER_PARAM_AEAD_MAC_KEY' => "mackey", # octet_string
+ 'OSSL_CIPHER_PARAM_RANDOM_KEY' => "randkey", # octet_string
+ 'OSSL_CIPHER_PARAM_RC2_KEYBITS' => "keybits", # size_t
+ 'OSSL_CIPHER_PARAM_SPEED' => "speed", # uint
+ 'OSSL_CIPHER_PARAM_CTS_MODE' => "cts_mode", # utf8_string
+ 'OSSL_CIPHER_PARAM_DECRYPT_ONLY' => "decrypt-only", # int, 0 or 1
+ 'OSSL_CIPHER_PARAM_FIPS_ENCRYPT_CHECK' => "encrypt-check", # int
+ 'OSSL_CIPHER_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_CIPHER_PARAM_ALGORITHM_ID' => '*OSSL_ALG_PARAM_ALGORITHM_ID',
# Historically, CIPHER_PARAM_ALGORITHM_ID_PARAMS_OLD was used. For the
# time being, the old libcrypto functions will use both, so old providers
# continue to work.
# New providers are encouraged to use CIPHER_PARAM_ALGORITHM_ID_PARAMS.
- 'CIPHER_PARAM_ALGORITHM_ID_PARAMS' => '*ALG_PARAM_ALGORITHM_ID_PARAMS',
- 'CIPHER_PARAM_ALGORITHM_ID_PARAMS_OLD' => "alg_id_param", # octet_string
- 'CIPHER_PARAM_XTS_STANDARD' => "xts_standard",# utf8_string
- 'CIPHER_PARAM_ENCRYPT_THEN_MAC' => "encrypt-then-mac",# int, 0 or 1
- 'CIPHER_HMAC_PARAM_MAC' => "*CIPHER_PARAM_AEAD_TAG",
-
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT' => "tls1multi_maxsndfrag",# uint
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE' => "tls1multi_maxbufsz", # size_t
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE' => "tls1multi_interleave",# uint
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_AAD' => "tls1multi_aad", # octet_string
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN' => "tls1multi_aadpacklen",# uint
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_ENC' => "tls1multi_enc", # octet_string
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN' => "tls1multi_encin", # octet_string
- 'CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN' => "tls1multi_enclen", # size_t
+ 'OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS' => '*OSSL_ALG_PARAM_ALGORITHM_ID_PARAMS',
+ 'OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS_OLD' => "alg_id_param", # octet_string
+ 'OSSL_CIPHER_PARAM_XTS_STANDARD' => "xts_standard",# utf8_string
+ 'OSSL_CIPHER_PARAM_ENCRYPT_THEN_MAC' => "encrypt-then-mac",# int, 0 or 1
+ 'OSSL_CIPHER_HMAC_PARAM_MAC' => "*OSSL_CIPHER_PARAM_AEAD_TAG",
+
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT' => "tls1multi_maxsndfrag",# uint
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE' => "tls1multi_maxbufsz", # size_t
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE' => "tls1multi_interleave",# uint
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD' => "tls1multi_aad", # octet_string
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN' => "tls1multi_aadpacklen",# uint
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC' => "tls1multi_enc", # octet_string
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN' => "tls1multi_encin", # octet_string
+ 'OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN' => "tls1multi_enclen", # size_t
# digest parameters
- 'DIGEST_PARAM_XOFLEN' => "xoflen", # size_t
- 'DIGEST_PARAM_SSL3_MS' => "ssl3-ms", # octet string
- 'DIGEST_PARAM_PAD_TYPE' => "pad-type", # uint
- 'DIGEST_PARAM_MICALG' => "micalg", # utf8 string
- 'DIGEST_PARAM_BLOCK_SIZE' => "blocksize", # size_t
- 'DIGEST_PARAM_SIZE' => "size", # size_t
- 'DIGEST_PARAM_XOF' => "xof", # int, 0 or 1
- 'DIGEST_PARAM_ALGID_ABSENT' => "algid-absent", # int, 0 or 1
+ 'OSSL_DIGEST_PARAM_XOFLEN' => "xoflen", # size_t
+ 'OSSL_DIGEST_PARAM_SSL3_MS' => "ssl3-ms", # octet string
+ 'OSSL_DIGEST_PARAM_PAD_TYPE' => "pad-type", # uint
+ 'OSSL_DIGEST_PARAM_MICALG' => "micalg", # utf8 string
+ 'OSSL_DIGEST_PARAM_BLOCK_SIZE' => "blocksize", # size_t
+ 'OSSL_DIGEST_PARAM_SIZE' => "size", # size_t
+ 'OSSL_DIGEST_PARAM_XOF' => "xof", # int, 0 or 1
+ 'OSSL_DIGEST_PARAM_ALGID_ABSENT' => "algid-absent", # int, 0 or 1
# MAC parameters
- 'MAC_PARAM_KEY' => "key", # octet string
- 'MAC_PARAM_IV' => "iv", # octet string
- 'MAC_PARAM_CUSTOM' => "custom", # utf8 string
- 'MAC_PARAM_SALT' => "salt", # octet string
- 'MAC_PARAM_XOF' => "xof", # int, 0 or 1
- 'MAC_PARAM_DIGEST_NOINIT' => "digest-noinit", # int, 0 or 1
- 'MAC_PARAM_DIGEST_ONESHOT' => "digest-oneshot",# int, 0 or 1
- 'MAC_PARAM_C_ROUNDS' => "c-rounds", # unsigned int
- 'MAC_PARAM_D_ROUNDS' => "d-rounds", # unsigned int
+ 'OSSL_MAC_PARAM_KEY' => "key", # octet string
+ 'OSSL_MAC_PARAM_IV' => "iv", # octet string
+ 'OSSL_MAC_PARAM_CUSTOM' => "custom", # utf8 string
+ 'OSSL_MAC_PARAM_SALT' => "salt", # octet string
+ 'OSSL_MAC_PARAM_XOF' => "xof", # int, 0 or 1
+ 'OSSL_MAC_PARAM_DIGEST_NOINIT' => "digest-noinit", # int, 0 or 1
+ 'OSSL_MAC_PARAM_DIGEST_ONESHOT' => "digest-oneshot",# int, 0 or 1
+ 'OSSL_MAC_PARAM_C_ROUNDS' => "c-rounds", # unsigned int
+ 'OSSL_MAC_PARAM_D_ROUNDS' => "d-rounds", # unsigned int
# If "engine",or "properties",are specified, they should always be paired
# with "cipher",or "digest".
- 'MAC_PARAM_CIPHER' => '*ALG_PARAM_CIPHER', # utf8 string
- 'MAC_PARAM_DIGEST' => '*ALG_PARAM_DIGEST', # utf8 string
- 'MAC_PARAM_PROPERTIES' => '*ALG_PARAM_PROPERTIES', # utf8 string
- 'MAC_PARAM_SIZE' => "size", # size_t
- 'MAC_PARAM_BLOCK_SIZE' => "block-size", # size_t
- 'MAC_PARAM_TLS_DATA_SIZE' => "tls-data-size", # size_t
- 'MAC_PARAM_FIPS_NO_SHORT_MAC' =>'*PROV_PARAM_NO_SHORT_MAC',
- 'MAC_PARAM_FIPS_KEY_CHECK' => '*PKEY_PARAM_FIPS_KEY_CHECK',
- 'MAC_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
- 'MAC_PARAM_FIPS_NO_SHORT_MAC' => '*PROV_PARAM_NO_SHORT_MAC',
+ 'OSSL_MAC_PARAM_CIPHER' => '*OSSL_ALG_PARAM_CIPHER', # utf8 string
+ 'OSSL_MAC_PARAM_DIGEST' => '*OSSL_ALG_PARAM_DIGEST', # utf8 string
+ 'OSSL_MAC_PARAM_PROPERTIES' => '*OSSL_ALG_PARAM_PROPERTIES', # utf8 string
+ 'OSSL_MAC_PARAM_SIZE' => "size", # size_t
+ 'OSSL_MAC_PARAM_BLOCK_SIZE' => "block-size", # size_t
+ 'OSSL_MAC_PARAM_TLS_DATA_SIZE' => "tls-data-size", # size_t
+ 'OSSL_MAC_PARAM_FIPS_NO_SHORT_MAC' =>'*OSSL_PROV_PARAM_NO_SHORT_MAC',
+ 'OSSL_MAC_PARAM_FIPS_KEY_CHECK' => '*OSSL_PKEY_PARAM_FIPS_KEY_CHECK',
+ 'OSSL_MAC_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_MAC_PARAM_FIPS_NO_SHORT_MAC' => '*OSSL_PROV_PARAM_NO_SHORT_MAC',
# KDF / PRF parameters
- 'KDF_PARAM_SECRET' => "secret", # octet string
- 'KDF_PARAM_KEY' => "key", # octet string
- 'KDF_PARAM_SALT' => "salt", # octet string
- 'KDF_PARAM_PASSWORD' => "pass", # octet string
- 'KDF_PARAM_PREFIX' => "prefix", # octet string
- 'KDF_PARAM_LABEL' => "label", # octet string
- 'KDF_PARAM_DATA' => "data", # octet string
- 'KDF_PARAM_DIGEST' => '*ALG_PARAM_DIGEST', # utf8 string
- 'KDF_PARAM_CIPHER' => '*ALG_PARAM_CIPHER', # utf8 string
- 'KDF_PARAM_MAC' => '*ALG_PARAM_MAC', # utf8 string
- 'KDF_PARAM_MAC_SIZE' => "maclen", # size_t
- 'KDF_PARAM_PROPERTIES' => '*ALG_PARAM_PROPERTIES', # utf8 string
- 'KDF_PARAM_ITER' => "iter", # unsigned int
- 'KDF_PARAM_MODE' => "mode", # utf8 string or int
- 'KDF_PARAM_PKCS5' => "pkcs5", # int
- 'KDF_PARAM_UKM' => "ukm", # octet string
- 'KDF_PARAM_CEK_ALG' => "cekalg", # utf8 string
- 'KDF_PARAM_SCRYPT_N' => "n", # uint64_t
- 'KDF_PARAM_SCRYPT_R' => "r", # uint32_t
- 'KDF_PARAM_SCRYPT_P' => "p", # uint32_t
- 'KDF_PARAM_SCRYPT_MAXMEM' => "maxmem_bytes", # uint64_t
- 'KDF_PARAM_INFO' => "info", # octet string
- 'KDF_PARAM_SEED' => "seed", # octet string
- 'KDF_PARAM_SSHKDF_XCGHASH' => "xcghash", # octet string
- 'KDF_PARAM_SSHKDF_SESSION_ID' => "session_id", # octet string
- 'KDF_PARAM_SSHKDF_TYPE' => "type", # int
- 'KDF_PARAM_SIZE' => "size", # size_t
- 'KDF_PARAM_CONSTANT' => "constant", # octet string
- 'KDF_PARAM_PKCS12_ID' => "id", # int
- 'KDF_PARAM_KBKDF_USE_L' => "use-l", # int
- 'KDF_PARAM_KBKDF_USE_SEPARATOR' => "use-separator", # int
- 'KDF_PARAM_KBKDF_R' => "r", # int
- 'KDF_PARAM_X942_ACVPINFO' => "acvp-info",
- 'KDF_PARAM_X942_PARTYUINFO' => "partyu-info",
- 'KDF_PARAM_X942_PARTYVINFO' => "partyv-info",
- 'KDF_PARAM_X942_SUPP_PUBINFO' => "supp-pubinfo",
- 'KDF_PARAM_X942_SUPP_PRIVINFO' => "supp-privinfo",
- 'KDF_PARAM_X942_USE_KEYBITS' => "use-keybits",
- 'KDF_PARAM_HMACDRBG_ENTROPY' => "entropy",
- 'KDF_PARAM_HMACDRBG_NONCE' => "nonce",
- 'KDF_PARAM_THREADS' => "threads", # uint32_t
- 'KDF_PARAM_EARLY_CLEAN' => "early_clean", # uint32_t
- 'KDF_PARAM_ARGON2_AD' => "ad", # octet string
- 'KDF_PARAM_ARGON2_LANES' => "lanes", # uint32_t
- 'KDF_PARAM_ARGON2_MEMCOST' => "memcost", # uint32_t
- 'KDF_PARAM_ARGON2_VERSION' => "version", # uint32_t
- 'KDF_PARAM_FIPS_EMS_CHECK' => "ems_check", # int
- 'KDF_PARAM_FIPS_DIGEST_CHECK' => '*PKEY_PARAM_FIPS_DIGEST_CHECK',
- 'KDF_PARAM_FIPS_KEY_CHECK' => '*PKEY_PARAM_FIPS_KEY_CHECK',
- 'KDF_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_KDF_PARAM_SECRET' => "secret", # octet string
+ 'OSSL_KDF_PARAM_KEY' => "key", # octet string
+ 'OSSL_KDF_PARAM_SALT' => "salt", # octet string
+ 'OSSL_KDF_PARAM_PASSWORD' => "pass", # octet string
+ 'OSSL_KDF_PARAM_PREFIX' => "prefix", # octet string
+ 'OSSL_KDF_PARAM_LABEL' => "label", # octet string
+ 'OSSL_KDF_PARAM_DATA' => "data", # octet string
+ 'OSSL_KDF_PARAM_DIGEST' => '*OSSL_ALG_PARAM_DIGEST', # utf8 string
+ 'OSSL_KDF_PARAM_CIPHER' => '*OSSL_ALG_PARAM_CIPHER', # utf8 string
+ 'OSSL_KDF_PARAM_MAC' => '*OSSL_ALG_PARAM_MAC', # utf8 string
+ 'OSSL_KDF_PARAM_MAC_SIZE' => "maclen", # size_t
+ 'OSSL_KDF_PARAM_PROPERTIES' => '*OSSL_ALG_PARAM_PROPERTIES', # utf8 string
+ 'OSSL_KDF_PARAM_ITER' => "iter", # unsigned int
+ 'OSSL_KDF_PARAM_MODE' => "mode", # utf8 string or int
+ 'OSSL_KDF_PARAM_PKCS5' => "pkcs5", # int
+ 'OSSL_KDF_PARAM_UKM' => "ukm", # octet string
+ 'OSSL_KDF_PARAM_CEK_ALG' => "cekalg", # utf8 string
+ 'OSSL_KDF_PARAM_SCRYPT_N' => "n", # uint64_t
+ 'OSSL_KDF_PARAM_SCRYPT_R' => "r", # uint32_t
+ 'OSSL_KDF_PARAM_SCRYPT_P' => "p", # uint32_t
+ 'OSSL_KDF_PARAM_SCRYPT_MAXMEM' => "maxmem_bytes", # uint64_t
+ 'OSSL_KDF_PARAM_INFO' => "info", # octet string
+ 'OSSL_KDF_PARAM_SEED' => "seed", # octet string
+ 'OSSL_KDF_PARAM_SSHKDF_XCGHASH' => "xcghash", # octet string
+ 'OSSL_KDF_PARAM_SSHKDF_SESSION_ID' => "session_id", # octet string
+ 'OSSL_KDF_PARAM_SSHKDF_TYPE' => "type", # int
+ 'OSSL_KDF_PARAM_SIZE' => "size", # size_t
+ 'OSSL_KDF_PARAM_CONSTANT' => "constant", # octet string
+ 'OSSL_KDF_PARAM_PKCS12_ID' => "id", # int
+ 'OSSL_KDF_PARAM_KBKDF_USE_L' => "use-l", # int
+ 'OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR' => "use-separator", # int
+ 'OSSL_KDF_PARAM_KBKDF_R' => "r", # int
+ 'OSSL_KDF_PARAM_X942_ACVPINFO' => "acvp-info",
+ 'OSSL_KDF_PARAM_X942_PARTYUINFO' => "partyu-info",
+ 'OSSL_KDF_PARAM_X942_PARTYVINFO' => "partyv-info",
+ 'OSSL_KDF_PARAM_X942_SUPP_PUBINFO' => "supp-pubinfo",
+ 'OSSL_KDF_PARAM_X942_SUPP_PRIVINFO' => "supp-privinfo",
+ 'OSSL_KDF_PARAM_X942_USE_KEYBITS' => "use-keybits",
+ 'OSSL_KDF_PARAM_HMACDRBG_ENTROPY' => "entropy",
+ 'OSSL_KDF_PARAM_HMACDRBG_NONCE' => "nonce",
+ 'OSSL_KDF_PARAM_THREADS' => "threads", # uint32_t
+ 'OSSL_KDF_PARAM_EARLY_CLEAN' => "early_clean", # uint32_t
+ 'OSSL_KDF_PARAM_ARGON2_AD' => "ad", # octet string
+ 'OSSL_KDF_PARAM_ARGON2_LANES' => "lanes", # uint32_t
+ 'OSSL_KDF_PARAM_ARGON2_MEMCOST' => "memcost", # uint32_t
+ 'OSSL_KDF_PARAM_ARGON2_VERSION' => "version", # uint32_t
+ 'OSSL_KDF_PARAM_FIPS_EMS_CHECK' => "ems_check", # int
+ 'OSSL_KDF_PARAM_FIPS_DIGEST_CHECK' => '*OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK',
+ 'OSSL_KDF_PARAM_FIPS_KEY_CHECK' => '*OSSL_PKEY_PARAM_FIPS_KEY_CHECK',
+ 'OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
# Known RAND names
- 'RAND_PARAM_STATE' => "state",
- 'RAND_PARAM_STRENGTH' => "strength",
- 'RAND_PARAM_MAX_REQUEST' => "max_request",
- 'RAND_PARAM_TEST_ENTROPY' => "test_entropy",
- 'RAND_PARAM_TEST_NONCE' => "test_nonce",
- 'RAND_PARAM_GENERATE' => "generate",
- 'RAND_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_RAND_PARAM_STATE' => "state",
+ 'OSSL_RAND_PARAM_STRENGTH' => "strength",
+ 'OSSL_RAND_PARAM_MAX_REQUEST' => "max_request",
+ 'OSSL_RAND_PARAM_TEST_ENTROPY' => "test_entropy",
+ 'OSSL_RAND_PARAM_TEST_NONCE' => "test_nonce",
+ 'OSSL_RAND_PARAM_GENERATE' => "generate",
+ 'OSSL_RAND_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
# RAND/DRBG names
- 'DRBG_PARAM_RESEED_REQUESTS' => "reseed_requests",
- 'DRBG_PARAM_RESEED_TIME_INTERVAL' => "reseed_time_interval",
- 'DRBG_PARAM_MIN_ENTROPYLEN' => "min_entropylen",
- 'DRBG_PARAM_MAX_ENTROPYLEN' => "max_entropylen",
- 'DRBG_PARAM_MIN_NONCELEN' => "min_noncelen",
- 'DRBG_PARAM_MAX_NONCELEN' => "max_noncelen",
- 'DRBG_PARAM_MAX_PERSLEN' => "max_perslen",
- 'DRBG_PARAM_MAX_ADINLEN' => "max_adinlen",
- 'DRBG_PARAM_RESEED_COUNTER' => "reseed_counter",
- 'DRBG_PARAM_RESEED_TIME' => "reseed_time",
- 'DRBG_PARAM_PROPERTIES' => '*ALG_PARAM_PROPERTIES',
- 'DRBG_PARAM_DIGEST' => '*ALG_PARAM_DIGEST',
- 'DRBG_PARAM_CIPHER' => '*ALG_PARAM_CIPHER',
- 'DRBG_PARAM_MAC' => '*ALG_PARAM_MAC',
- 'DRBG_PARAM_USE_DF' => "use_derivation_function",
- 'DRBG_PARAM_FIPS_DIGEST_CHECK' => '*PKEY_PARAM_FIPS_DIGEST_CHECK',
- 'DRBG_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_DRBG_PARAM_RESEED_REQUESTS' => "reseed_requests",
+ 'OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL' => "reseed_time_interval",
+ 'OSSL_DRBG_PARAM_MIN_ENTROPYLEN' => "min_entropylen",
+ 'OSSL_DRBG_PARAM_MAX_ENTROPYLEN' => "max_entropylen",
+ 'OSSL_DRBG_PARAM_MIN_NONCELEN' => "min_noncelen",
+ 'OSSL_DRBG_PARAM_MAX_NONCELEN' => "max_noncelen",
+ 'OSSL_DRBG_PARAM_MAX_PERSLEN' => "max_perslen",
+ 'OSSL_DRBG_PARAM_MAX_ADINLEN' => "max_adinlen",
+ 'OSSL_DRBG_PARAM_RESEED_COUNTER' => "reseed_counter",
+ 'OSSL_DRBG_PARAM_RESEED_TIME' => "reseed_time",
+ 'OSSL_DRBG_PARAM_PROPERTIES' => '*OSSL_ALG_PARAM_PROPERTIES',
+ 'OSSL_DRBG_PARAM_DIGEST' => '*OSSL_ALG_PARAM_DIGEST',
+ 'OSSL_DRBG_PARAM_CIPHER' => '*OSSL_ALG_PARAM_CIPHER',
+ 'OSSL_DRBG_PARAM_MAC' => '*OSSL_ALG_PARAM_MAC',
+ 'OSSL_DRBG_PARAM_USE_DF' => "use_derivation_function",
+ 'OSSL_DRBG_PARAM_FIPS_DIGEST_CHECK' => '*OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK',
+ 'OSSL_DRBG_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
# DRBG call back parameters
- 'DRBG_PARAM_ENTROPY_REQUIRED' => "entropy_required",
- 'DRBG_PARAM_PREDICTION_RESISTANCE' => "prediction_resistance",
- 'DRBG_PARAM_MIN_LENGTH' => "minium_length",
- 'DRBG_PARAM_MAX_LENGTH' => "maxium_length",
- 'DRBG_PARAM_RANDOM_DATA' => "random_data",
- 'DRBG_PARAM_SIZE' => "size",
+ 'OSSL_DRBG_PARAM_ENTROPY_REQUIRED' => "entropy_required",
+ 'OSSL_DRBG_PARAM_PREDICTION_RESISTANCE' => "prediction_resistance",
+ 'OSSL_DRBG_PARAM_MIN_LENGTH' => "minium_length",
+ 'OSSL_DRBG_PARAM_MAX_LENGTH' => "maxium_length",
+ 'OSSL_DRBG_PARAM_RANDOM_DATA' => "random_data",
+ 'OSSL_DRBG_PARAM_SIZE' => "size",
# PKEY parameters
# Common PKEY parameters
- 'PKEY_PARAM_BITS' => "bits",# integer
- 'PKEY_PARAM_MAX_SIZE' => "max-size",# integer
- 'PKEY_PARAM_SECURITY_BITS' => "security-bits",# integer
- 'PKEY_PARAM_SECURITY_CATEGORY' => '*ALG_PARAM_SECURITY_CATEGORY',
- 'PKEY_PARAM_DIGEST' => '*ALG_PARAM_DIGEST',
- 'PKEY_PARAM_CIPHER' => '*ALG_PARAM_CIPHER', # utf8 string
- 'PKEY_PARAM_ENGINE' => '*ALG_PARAM_ENGINE', # utf8 string
- 'PKEY_PARAM_PROPERTIES' => '*ALG_PARAM_PROPERTIES',
- 'PKEY_PARAM_DEFAULT_DIGEST' => "default-digest",# utf8 string
- 'PKEY_PARAM_MANDATORY_DIGEST' => "mandatory-digest",# utf8 string
- 'PKEY_PARAM_PAD_MODE' => "pad-mode",
- 'PKEY_PARAM_DIGEST_SIZE' => "digest-size",
- 'PKEY_PARAM_MASKGENFUNC' => "mgf",
- 'PKEY_PARAM_MGF1_DIGEST' => "mgf1-digest",
- 'PKEY_PARAM_MGF1_PROPERTIES' => "mgf1-properties",
- 'PKEY_PARAM_ENCODED_PUBLIC_KEY' => "encoded-pub-key",
- 'PKEY_PARAM_GROUP_NAME' => "group",
- 'PKEY_PARAM_DIST_ID' => "distid",
- 'PKEY_PARAM_PUB_KEY' => "pub",
- 'PKEY_PARAM_PRIV_KEY' => "priv",
+ 'OSSL_PKEY_PARAM_BITS' => "bits",# integer
+ 'OSSL_PKEY_PARAM_MAX_SIZE' => "max-size",# integer
+ 'OSSL_PKEY_PARAM_SECURITY_BITS' => "security-bits",# integer
+ 'OSSL_PKEY_PARAM_SECURITY_CATEGORY' => '*OSSL_ALG_PARAM_SECURITY_CATEGORY',
+ 'OSSL_PKEY_PARAM_DIGEST' => '*OSSL_ALG_PARAM_DIGEST',
+ 'OSSL_PKEY_PARAM_CIPHER' => '*OSSL_ALG_PARAM_CIPHER', # utf8 string
+ 'OSSL_PKEY_PARAM_ENGINE' => '*OSSL_ALG_PARAM_ENGINE', # utf8 string
+ 'OSSL_PKEY_PARAM_PROPERTIES' => '*OSSL_ALG_PARAM_PROPERTIES',
+ 'OSSL_PKEY_PARAM_DEFAULT_DIGEST' => "default-digest",# utf8 string
+ 'OSSL_PKEY_PARAM_MANDATORY_DIGEST' => "mandatory-digest",# utf8 string
+ 'OSSL_PKEY_PARAM_PAD_MODE' => "pad-mode",
+ 'OSSL_PKEY_PARAM_DIGEST_SIZE' => "digest-size",
+ 'OSSL_PKEY_PARAM_MASKGENFUNC' => "mgf",
+ 'OSSL_PKEY_PARAM_MGF1_DIGEST' => "mgf1-digest",
+ 'OSSL_PKEY_PARAM_MGF1_PROPERTIES' => "mgf1-properties",
+ 'OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY' => "encoded-pub-key",
+ 'OSSL_PKEY_PARAM_GROUP_NAME' => "group",
+ 'OSSL_PKEY_PARAM_DIST_ID' => "distid",
+ 'OSSL_PKEY_PARAM_PUB_KEY' => "pub",
+ 'OSSL_PKEY_PARAM_PRIV_KEY' => "priv",
# PKEY_PARAM_IMPLICIT_REJECTION isn't actually used, or meaningful. We keep
# it for API stability, but please use ASYM_CIPHER_PARAM_IMPLICIT_REJECTION
# instead.
- 'PKEY_PARAM_IMPLICIT_REJECTION' => "implicit-rejection",
- 'PKEY_PARAM_FIPS_DIGEST_CHECK' => "digest-check",
- 'PKEY_PARAM_FIPS_KEY_CHECK' => "key-check",
- 'PKEY_PARAM_ALGORITHM_ID' => '*ALG_PARAM_ALGORITHM_ID',
- 'PKEY_PARAM_ALGORITHM_ID_PARAMS' => '*ALG_PARAM_ALGORITHM_ID_PARAMS',
- 'PKEY_PARAM_CMS_RI_TYPE' => "ri-type", # integer
- 'PKEY_PARAM_CMS_KEMRI_KDF_ALGORITHM' => "kemri-kdf-alg",
+ 'OSSL_PKEY_PARAM_IMPLICIT_REJECTION' => "implicit-rejection",
+ 'OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK' => "digest-check",
+ 'OSSL_PKEY_PARAM_FIPS_KEY_CHECK' => "key-check",
+ 'OSSL_PKEY_PARAM_ALGORITHM_ID' => '*OSSL_ALG_PARAM_ALGORITHM_ID',
+ 'OSSL_PKEY_PARAM_ALGORITHM_ID_PARAMS' => '*OSSL_ALG_PARAM_ALGORITHM_ID_PARAMS',
+ 'OSSL_PKEY_PARAM_CMS_RI_TYPE' => "ri-type", # integer
+ 'OSSL_PKEY_PARAM_CMS_KEMRI_KDF_ALGORITHM' => "kemri-kdf-alg",
# Diffie-Hellman/DSA Parameters
- 'PKEY_PARAM_FFC_P' => "p",
- 'PKEY_PARAM_FFC_G' => "g",
- 'PKEY_PARAM_FFC_Q' => "q",
- 'PKEY_PARAM_FFC_GINDEX' => "gindex",
- 'PKEY_PARAM_FFC_PCOUNTER' => "pcounter",
- 'PKEY_PARAM_FFC_SEED' => "seed",
- 'PKEY_PARAM_FFC_COFACTOR' => "j",
- 'PKEY_PARAM_FFC_H' => "hindex",
- 'PKEY_PARAM_FFC_VALIDATE_PQ' => "validate-pq",
- 'PKEY_PARAM_FFC_VALIDATE_G' => "validate-g",
- 'PKEY_PARAM_FFC_VALIDATE_LEGACY' => "validate-legacy",
+ 'OSSL_PKEY_PARAM_FFC_P' => "p",
+ 'OSSL_PKEY_PARAM_FFC_G' => "g",
+ 'OSSL_PKEY_PARAM_FFC_Q' => "q",
+ 'OSSL_PKEY_PARAM_FFC_GINDEX' => "gindex",
+ 'OSSL_PKEY_PARAM_FFC_PCOUNTER' => "pcounter",
+ 'OSSL_PKEY_PARAM_FFC_SEED' => "seed",
+ 'OSSL_PKEY_PARAM_FFC_COFACTOR' => "j",
+ 'OSSL_PKEY_PARAM_FFC_H' => "hindex",
+ 'OSSL_PKEY_PARAM_FFC_VALIDATE_PQ' => "validate-pq",
+ 'OSSL_PKEY_PARAM_FFC_VALIDATE_G' => "validate-g",
+ 'OSSL_PKEY_PARAM_FFC_VALIDATE_LEGACY' => "validate-legacy",
# Diffie-Hellman params
- 'PKEY_PARAM_DH_GENERATOR' => "safeprime-generator",
- 'PKEY_PARAM_DH_PRIV_LEN' => "priv_len",
+ 'OSSL_PKEY_PARAM_DH_GENERATOR' => "safeprime-generator",
+ 'OSSL_PKEY_PARAM_DH_PRIV_LEN' => "priv_len",
# Elliptic Curve Domain Parameters
- 'PKEY_PARAM_EC_PUB_X' => "qx",
- 'PKEY_PARAM_EC_PUB_Y' => "qy",
+ 'OSSL_PKEY_PARAM_EC_PUB_X' => "qx",
+ 'OSSL_PKEY_PARAM_EC_PUB_Y' => "qy",
# Elliptic Curve Explicit Domain Parameters
- 'PKEY_PARAM_EC_FIELD_TYPE' => "field-type",
- 'PKEY_PARAM_EC_P' => "p",
- 'PKEY_PARAM_EC_A' => "a",
- 'PKEY_PARAM_EC_B' => "b",
- 'PKEY_PARAM_EC_GENERATOR' => "generator",
- 'PKEY_PARAM_EC_ORDER' => "order",
- 'PKEY_PARAM_EC_COFACTOR' => "cofactor",
- 'PKEY_PARAM_EC_SEED' => "seed",
- 'PKEY_PARAM_EC_CHAR2_M' => "m",
- 'PKEY_PARAM_EC_CHAR2_TYPE' => "basis-type",
- 'PKEY_PARAM_EC_CHAR2_TP_BASIS' => "tp",
- 'PKEY_PARAM_EC_CHAR2_PP_K1' => "k1",
- 'PKEY_PARAM_EC_CHAR2_PP_K2' => "k2",
- 'PKEY_PARAM_EC_CHAR2_PP_K3' => "k3",
- 'PKEY_PARAM_EC_DECODED_FROM_EXPLICIT_PARAMS' => "decoded-from-explicit",
+ 'OSSL_PKEY_PARAM_EC_FIELD_TYPE' => "field-type",
+ 'OSSL_PKEY_PARAM_EC_P' => "p",
+ 'OSSL_PKEY_PARAM_EC_A' => "a",
+ 'OSSL_PKEY_PARAM_EC_B' => "b",
+ 'OSSL_PKEY_PARAM_EC_GENERATOR' => "generator",
+ 'OSSL_PKEY_PARAM_EC_ORDER' => "order",
+ 'OSSL_PKEY_PARAM_EC_COFACTOR' => "cofactor",
+ 'OSSL_PKEY_PARAM_EC_SEED' => "seed",
+ 'OSSL_PKEY_PARAM_EC_CHAR2_M' => "m",
+ 'OSSL_PKEY_PARAM_EC_CHAR2_TYPE' => "basis-type",
+ 'OSSL_PKEY_PARAM_EC_CHAR2_TP_BASIS' => "tp",
+ 'OSSL_PKEY_PARAM_EC_CHAR2_PP_K1' => "k1",
+ 'OSSL_PKEY_PARAM_EC_CHAR2_PP_K2' => "k2",
+ 'OSSL_PKEY_PARAM_EC_CHAR2_PP_K3' => "k3",
+ 'OSSL_PKEY_PARAM_EC_DECODED_FROM_EXPLICIT_PARAMS' => "decoded-from-explicit",
# Elliptic Curve Key Parameters
- 'PKEY_PARAM_USE_COFACTOR_FLAG' => "use-cofactor-flag",
- 'PKEY_PARAM_USE_COFACTOR_ECDH' => '*PKEY_PARAM_USE_COFACTOR_FLAG',
+ 'OSSL_PKEY_PARAM_USE_COFACTOR_FLAG' => "use-cofactor-flag",
+ 'OSSL_PKEY_PARAM_USE_COFACTOR_ECDH' => '*OSSL_PKEY_PARAM_USE_COFACTOR_FLAG',
# RSA Keys
#
# (the base i for the coefficients is 2, not 1, at least as implied by
# RFC 8017)
- 'PKEY_PARAM_RSA_N' => "n",
- 'PKEY_PARAM_RSA_E' => "e",
- 'PKEY_PARAM_RSA_D' => "d",
- 'PKEY_PARAM_RSA_FACTOR' => "rsa-factor",
- 'PKEY_PARAM_RSA_EXPONENT' => "rsa-exponent",
- 'PKEY_PARAM_RSA_COEFFICIENT' => "rsa-coefficient",
- 'PKEY_PARAM_RSA_FACTOR1' => "rsa-factor1",
- 'PKEY_PARAM_RSA_FACTOR2' => "rsa-factor2",
- 'PKEY_PARAM_RSA_FACTOR3' => "rsa-factor3",
- 'PKEY_PARAM_RSA_FACTOR4' => "rsa-factor4",
- 'PKEY_PARAM_RSA_FACTOR5' => "rsa-factor5",
- 'PKEY_PARAM_RSA_FACTOR6' => "rsa-factor6",
- 'PKEY_PARAM_RSA_FACTOR7' => "rsa-factor7",
- 'PKEY_PARAM_RSA_FACTOR8' => "rsa-factor8",
- 'PKEY_PARAM_RSA_FACTOR9' => "rsa-factor9",
- 'PKEY_PARAM_RSA_FACTOR10' => "rsa-factor10",
- 'PKEY_PARAM_RSA_EXPONENT1' => "rsa-exponent1",
- 'PKEY_PARAM_RSA_EXPONENT2' => "rsa-exponent2",
- 'PKEY_PARAM_RSA_EXPONENT3' => "rsa-exponent3",
- 'PKEY_PARAM_RSA_EXPONENT4' => "rsa-exponent4",
- 'PKEY_PARAM_RSA_EXPONENT5' => "rsa-exponent5",
- 'PKEY_PARAM_RSA_EXPONENT6' => "rsa-exponent6",
- 'PKEY_PARAM_RSA_EXPONENT7' => "rsa-exponent7",
- 'PKEY_PARAM_RSA_EXPONENT8' => "rsa-exponent8",
- 'PKEY_PARAM_RSA_EXPONENT9' => "rsa-exponent9",
- 'PKEY_PARAM_RSA_EXPONENT10' => "rsa-exponent10",
- 'PKEY_PARAM_RSA_COEFFICIENT1' => "rsa-coefficient1",
- 'PKEY_PARAM_RSA_COEFFICIENT2' => "rsa-coefficient2",
- 'PKEY_PARAM_RSA_COEFFICIENT3' => "rsa-coefficient3",
- 'PKEY_PARAM_RSA_COEFFICIENT4' => "rsa-coefficient4",
- 'PKEY_PARAM_RSA_COEFFICIENT5' => "rsa-coefficient5",
- 'PKEY_PARAM_RSA_COEFFICIENT6' => "rsa-coefficient6",
- 'PKEY_PARAM_RSA_COEFFICIENT7' => "rsa-coefficient7",
- 'PKEY_PARAM_RSA_COEFFICIENT8' => "rsa-coefficient8",
- 'PKEY_PARAM_RSA_COEFFICIENT9' => "rsa-coefficient9",
+ 'OSSL_PKEY_PARAM_RSA_N' => "n",
+ 'OSSL_PKEY_PARAM_RSA_E' => "e",
+ 'OSSL_PKEY_PARAM_RSA_D' => "d",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR' => "rsa-factor",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT' => "rsa-exponent",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT' => "rsa-coefficient",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR1' => "rsa-factor1",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR2' => "rsa-factor2",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR3' => "rsa-factor3",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR4' => "rsa-factor4",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR5' => "rsa-factor5",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR6' => "rsa-factor6",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR7' => "rsa-factor7",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR8' => "rsa-factor8",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR9' => "rsa-factor9",
+ 'OSSL_PKEY_PARAM_RSA_FACTOR10' => "rsa-factor10",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT1' => "rsa-exponent1",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT2' => "rsa-exponent2",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT3' => "rsa-exponent3",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT4' => "rsa-exponent4",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT5' => "rsa-exponent5",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT6' => "rsa-exponent6",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT7' => "rsa-exponent7",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT8' => "rsa-exponent8",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT9' => "rsa-exponent9",
+ 'OSSL_PKEY_PARAM_RSA_EXPONENT10' => "rsa-exponent10",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT1' => "rsa-coefficient1",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT2' => "rsa-coefficient2",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT3' => "rsa-coefficient3",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT4' => "rsa-coefficient4",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT5' => "rsa-coefficient5",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT6' => "rsa-coefficient6",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT7' => "rsa-coefficient7",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT8' => "rsa-coefficient8",
+ 'OSSL_PKEY_PARAM_RSA_COEFFICIENT9' => "rsa-coefficient9",
# Key generation parameters
- 'PKEY_PARAM_RSA_BITS' => '*PKEY_PARAM_BITS',
- 'PKEY_PARAM_RSA_PRIMES' => "primes",
- 'PKEY_PARAM_RSA_DIGEST' => '*PKEY_PARAM_DIGEST',
- 'PKEY_PARAM_RSA_DIGEST_PROPS' => '*PKEY_PARAM_PROPERTIES',
- 'PKEY_PARAM_RSA_MASKGENFUNC' => '*PKEY_PARAM_MASKGENFUNC',
- 'PKEY_PARAM_RSA_MGF1_DIGEST' => '*PKEY_PARAM_MGF1_DIGEST',
- 'PKEY_PARAM_RSA_PSS_SALTLEN' => "saltlen",
- 'PKEY_PARAM_RSA_DERIVE_FROM_PQ' => "rsa-derive-from-pq",
+ 'OSSL_PKEY_PARAM_RSA_BITS' => '*OSSL_PKEY_PARAM_BITS',
+ 'OSSL_PKEY_PARAM_RSA_PRIMES' => "primes",
+ 'OSSL_PKEY_PARAM_RSA_DIGEST' => '*OSSL_PKEY_PARAM_DIGEST',
+ 'OSSL_PKEY_PARAM_RSA_DIGEST_PROPS' => '*OSSL_PKEY_PARAM_PROPERTIES',
+ 'OSSL_PKEY_PARAM_RSA_MASKGENFUNC' => '*OSSL_PKEY_PARAM_MASKGENFUNC',
+ 'OSSL_PKEY_PARAM_RSA_MGF1_DIGEST' => '*OSSL_PKEY_PARAM_MGF1_DIGEST',
+ 'OSSL_PKEY_PARAM_RSA_PSS_SALTLEN' => "saltlen",
+ 'OSSL_PKEY_PARAM_RSA_DERIVE_FROM_PQ' => "rsa-derive-from-pq",
# EC, X25519 and X448 Key generation parameters
- 'PKEY_PARAM_DHKEM_IKM' => "dhkem-ikm",
+ 'OSSL_PKEY_PARAM_DHKEM_IKM' => "dhkem-ikm",
# ML-KEM parameters
- 'PKEY_PARAM_ML_KEM_SEED' => "seed",
- 'PKEY_PARAM_ML_KEM_PREFER_SEED' => "ml-kem.prefer_seed",
- 'PKEY_PARAM_ML_KEM_RETAIN_SEED' => "ml-kem.retain_seed",
- 'PKEY_PARAM_ML_KEM_INPUT_FORMATS' => "ml-kem.input_formats",
- 'PKEY_PARAM_ML_KEM_OUTPUT_FORMATS' => "ml-kem.output_formats",
- 'PKEY_PARAM_ML_KEM_IMPORT_PCT_TYPE' => "ml-kem.import_pct_type",
+ 'OSSL_PKEY_PARAM_ML_KEM_SEED' => "seed",
+ 'OSSL_PKEY_PARAM_ML_KEM_PREFER_SEED' => "ml-kem.prefer_seed",
+ 'OSSL_PKEY_PARAM_ML_KEM_RETAIN_SEED' => "ml-kem.retain_seed",
+ 'OSSL_PKEY_PARAM_ML_KEM_INPUT_FORMATS' => "ml-kem.input_formats",
+ 'OSSL_PKEY_PARAM_ML_KEM_OUTPUT_FORMATS' => "ml-kem.output_formats",
+ 'OSSL_PKEY_PARAM_ML_KEM_IMPORT_PCT_TYPE' => "ml-kem.import_pct_type",
# Key generation parameters
- 'PKEY_PARAM_FFC_TYPE' => "type",
- 'PKEY_PARAM_FFC_PBITS' => "pbits",
- 'PKEY_PARAM_FFC_QBITS' => "qbits",
- 'PKEY_PARAM_FFC_DIGEST' => '*PKEY_PARAM_DIGEST',
- 'PKEY_PARAM_FFC_DIGEST_PROPS' => '*PKEY_PARAM_PROPERTIES',
-
- 'PKEY_PARAM_EC_ENCODING' => "encoding",# utf8_string
- 'PKEY_PARAM_EC_POINT_CONVERSION_FORMAT' => "point-format",
- 'PKEY_PARAM_EC_GROUP_CHECK_TYPE' => "group-check",
- 'PKEY_PARAM_EC_INCLUDE_PUBLIC' => "include-public",
- 'PKEY_PARAM_FIPS_SIGN_CHECK' => "sign-check",
- 'PKEY_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_PKEY_PARAM_FFC_TYPE' => "type",
+ 'OSSL_PKEY_PARAM_FFC_PBITS' => "pbits",
+ 'OSSL_PKEY_PARAM_FFC_QBITS' => "qbits",
+ 'OSSL_PKEY_PARAM_FFC_DIGEST' => '*OSSL_PKEY_PARAM_DIGEST',
+ 'OSSL_PKEY_PARAM_FFC_DIGEST_PROPS' => '*OSSL_PKEY_PARAM_PROPERTIES',
+
+ 'OSSL_PKEY_PARAM_EC_ENCODING' => "encoding",# utf8_string
+ 'OSSL_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT' => "point-format",
+ 'OSSL_PKEY_PARAM_EC_GROUP_CHECK_TYPE' => "group-check",
+ 'OSSL_PKEY_PARAM_EC_INCLUDE_PUBLIC' => "include-public",
+ 'OSSL_PKEY_PARAM_FIPS_SIGN_CHECK' => "sign-check",
+ 'OSSL_PKEY_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
# ML_DSA Key generation parameter
- 'PKEY_PARAM_ML_DSA_SEED' => "seed",
- 'PKEY_PARAM_ML_DSA_RETAIN_SEED' => "ml-dsa.retain_seed",
- 'PKEY_PARAM_ML_DSA_PREFER_SEED' => "ml-dsa.prefer_seed",
- 'PKEY_PARAM_ML_DSA_INPUT_FORMATS' => "ml-dsa.input_formats",
- 'PKEY_PARAM_ML_DSA_OUTPUT_FORMATS' => "ml-dsa.output_formats",
+ 'OSSL_PKEY_PARAM_ML_DSA_SEED' => "seed",
+ 'OSSL_PKEY_PARAM_ML_DSA_RETAIN_SEED' => "ml-dsa.retain_seed",
+ 'OSSL_PKEY_PARAM_ML_DSA_PREFER_SEED' => "ml-dsa.prefer_seed",
+ 'OSSL_PKEY_PARAM_ML_DSA_INPUT_FORMATS' => "ml-dsa.input_formats",
+ 'OSSL_PKEY_PARAM_ML_DSA_OUTPUT_FORMATS' => "ml-dsa.output_formats",
# SLH_DSA Key generation parameters
- 'PKEY_PARAM_SLH_DSA_SEED' => "seed",
+ 'OSSL_PKEY_PARAM_SLH_DSA_SEED' => "seed",
# Key Exchange parameters
- 'EXCHANGE_PARAM_PAD' => "pad",# uint
- 'EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE' => "ecdh-cofactor-mode",# int
- 'EXCHANGE_PARAM_KDF_TYPE' => "kdf-type",# utf8_string
- 'EXCHANGE_PARAM_KDF_DIGEST' => "kdf-digest",# utf8_string
- 'EXCHANGE_PARAM_KDF_DIGEST_PROPS' => "kdf-digest-props",# utf8_string
- 'EXCHANGE_PARAM_KDF_OUTLEN' => "kdf-outlen",# size_t
+ 'OSSL_EXCHANGE_PARAM_PAD' => "pad",# uint
+ 'OSSL_EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE' => "ecdh-cofactor-mode",# int
+ 'OSSL_EXCHANGE_PARAM_KDF_TYPE' => "kdf-type",# utf8_string
+ 'OSSL_EXCHANGE_PARAM_KDF_DIGEST' => "kdf-digest",# utf8_string
+ 'OSSL_EXCHANGE_PARAM_KDF_DIGEST_PROPS' => "kdf-digest-props",# utf8_string
+ 'OSSL_EXCHANGE_PARAM_KDF_OUTLEN' => "kdf-outlen",# size_t
# The following parameter is an octet_string on set and an octet_ptr on get
- 'EXCHANGE_PARAM_KDF_UKM' => "kdf-ukm",
- 'EXCHANGE_PARAM_FIPS_DIGEST_CHECK' => '*PKEY_PARAM_FIPS_DIGEST_CHECK',
- 'EXCHANGE_PARAM_FIPS_KEY_CHECK' => '*PKEY_PARAM_FIPS_KEY_CHECK',
- 'EXCHANGE_PARAM_FIPS_ECDH_COFACTOR_CHECK' => '*PROV_PARAM_ECDH_COFACTOR_CHECK',
- 'EXCHANGE_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_EXCHANGE_PARAM_KDF_UKM' => "kdf-ukm",
+ 'OSSL_EXCHANGE_PARAM_FIPS_DIGEST_CHECK' => '*OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK',
+ 'OSSL_EXCHANGE_PARAM_FIPS_KEY_CHECK' => '*OSSL_PKEY_PARAM_FIPS_KEY_CHECK',
+ 'OSSL_EXCHANGE_PARAM_FIPS_ECDH_COFACTOR_CHECK' => '*OSSL_PROV_PARAM_ECDH_COFACTOR_CHECK',
+ 'OSSL_EXCHANGE_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
# Signature parameters
- 'SIGNATURE_PARAM_ALGORITHM_ID' => '*PKEY_PARAM_ALGORITHM_ID',
- 'SIGNATURE_PARAM_ALGORITHM_ID_PARAMS' => '*PKEY_PARAM_ALGORITHM_ID_PARAMS',
- 'SIGNATURE_PARAM_PAD_MODE' => '*PKEY_PARAM_PAD_MODE',
- 'SIGNATURE_PARAM_DIGEST' => '*PKEY_PARAM_DIGEST',
- 'SIGNATURE_PARAM_PROPERTIES' => '*PKEY_PARAM_PROPERTIES',
- 'SIGNATURE_PARAM_PSS_SALTLEN' => "saltlen",
- 'SIGNATURE_PARAM_MGF1_DIGEST' => '*PKEY_PARAM_MGF1_DIGEST',
- 'SIGNATURE_PARAM_MGF1_PROPERTIES' => '*PKEY_PARAM_MGF1_PROPERTIES',
- 'SIGNATURE_PARAM_DIGEST_SIZE' => '*PKEY_PARAM_DIGEST_SIZE',
- 'SIGNATURE_PARAM_NONCE_TYPE' => "nonce-type",
- 'SIGNATURE_PARAM_INSTANCE' => "instance",
- 'SIGNATURE_PARAM_CONTEXT_STRING' => "context-string",
- 'SIGNATURE_PARAM_FIPS_DIGEST_CHECK' => '*PKEY_PARAM_FIPS_DIGEST_CHECK',
- 'SIGNATURE_PARAM_FIPS_VERIFY_MESSAGE' => 'verify-message',
- 'SIGNATURE_PARAM_FIPS_KEY_CHECK' => '*PKEY_PARAM_FIPS_KEY_CHECK',
- 'SIGNATURE_PARAM_FIPS_SIGN_CHECK' => '*PKEY_PARAM_FIPS_SIGN_CHECK',
- 'SIGNATURE_PARAM_FIPS_RSA_PSS_SALTLEN_CHECK' => "rsa-pss-saltlen-check",
- 'SIGNATURE_PARAM_FIPS_SIGN_X931_PAD_CHECK' => "sign-x931-pad-check",
- 'SIGNATURE_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
- 'SIGNATURE_PARAM_SIGNATURE' => "signature",
- 'SIGNATURE_PARAM_MESSAGE_ENCODING' => "message-encoding",
- 'SIGNATURE_PARAM_DETERMINISTIC' => "deterministic",
- 'SIGNATURE_PARAM_MU' => "mu", # int
- 'SIGNATURE_PARAM_TEST_ENTROPY' => "test-entropy",
- 'SIGNATURE_PARAM_ADD_RANDOM' => "additional-random",
+ 'OSSL_SIGNATURE_PARAM_ALGORITHM_ID' => '*OSSL_PKEY_PARAM_ALGORITHM_ID',
+ 'OSSL_SIGNATURE_PARAM_ALGORITHM_ID_PARAMS' => '*OSSL_PKEY_PARAM_ALGORITHM_ID_PARAMS',
+ 'OSSL_SIGNATURE_PARAM_PAD_MODE' => '*OSSL_PKEY_PARAM_PAD_MODE',
+ 'OSSL_SIGNATURE_PARAM_DIGEST' => '*OSSL_PKEY_PARAM_DIGEST',
+ 'OSSL_SIGNATURE_PARAM_PROPERTIES' => '*OSSL_PKEY_PARAM_PROPERTIES',
+ 'OSSL_SIGNATURE_PARAM_PSS_SALTLEN' => "saltlen",
+ 'OSSL_SIGNATURE_PARAM_MGF1_DIGEST' => '*OSSL_PKEY_PARAM_MGF1_DIGEST',
+ 'OSSL_SIGNATURE_PARAM_MGF1_PROPERTIES' => '*OSSL_PKEY_PARAM_MGF1_PROPERTIES',
+ 'OSSL_SIGNATURE_PARAM_DIGEST_SIZE' => '*OSSL_PKEY_PARAM_DIGEST_SIZE',
+ 'OSSL_SIGNATURE_PARAM_NONCE_TYPE' => "nonce-type",
+ 'OSSL_SIGNATURE_PARAM_INSTANCE' => "instance",
+ 'OSSL_SIGNATURE_PARAM_CONTEXT_STRING' => "context-string",
+ 'OSSL_SIGNATURE_PARAM_FIPS_DIGEST_CHECK' => '*OSSL_PKEY_PARAM_FIPS_DIGEST_CHECK',
+ 'OSSL_SIGNATURE_PARAM_FIPS_VERIFY_MESSAGE' => 'verify-message',
+ 'OSSL_SIGNATURE_PARAM_FIPS_KEY_CHECK' => '*OSSL_PKEY_PARAM_FIPS_KEY_CHECK',
+ 'OSSL_SIGNATURE_PARAM_FIPS_SIGN_CHECK' => '*OSSL_PKEY_PARAM_FIPS_SIGN_CHECK',
+ 'OSSL_SIGNATURE_PARAM_FIPS_RSA_PSS_SALTLEN_CHECK' => "rsa-pss-saltlen-check",
+ 'OSSL_SIGNATURE_PARAM_FIPS_SIGN_X931_PAD_CHECK' => "sign-x931-pad-check",
+ 'OSSL_SIGNATURE_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_SIGNATURE_PARAM_SIGNATURE' => "signature",
+ 'OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING' => "message-encoding",
+ 'OSSL_SIGNATURE_PARAM_DETERMINISTIC' => "deterministic",
+ 'OSSL_SIGNATURE_PARAM_MU' => "mu", # int
+ 'OSSL_SIGNATURE_PARAM_TEST_ENTROPY' => "test-entropy",
+ 'OSSL_SIGNATURE_PARAM_ADD_RANDOM' => "additional-random",
# Asym cipher parameters
- 'ASYM_CIPHER_PARAM_DIGEST' => '*PKEY_PARAM_DIGEST',
- 'ASYM_CIPHER_PARAM_PROPERTIES' => '*PKEY_PARAM_PROPERTIES',
- 'ASYM_CIPHER_PARAM_ENGINE' => '*PKEY_PARAM_ENGINE',
- 'ASYM_CIPHER_PARAM_PAD_MODE' => '*PKEY_PARAM_PAD_MODE',
- 'ASYM_CIPHER_PARAM_MGF1_DIGEST' => '*PKEY_PARAM_MGF1_DIGEST',
- 'ASYM_CIPHER_PARAM_MGF1_DIGEST_PROPS' => '*PKEY_PARAM_MGF1_PROPERTIES',
- 'ASYM_CIPHER_PARAM_OAEP_DIGEST' => '*ALG_PARAM_DIGEST',
- 'ASYM_CIPHER_PARAM_OAEP_DIGEST_PROPS' => "digest-props",
+ 'OSSL_ASYM_CIPHER_PARAM_DIGEST' => '*OSSL_PKEY_PARAM_DIGEST',
+ 'OSSL_ASYM_CIPHER_PARAM_PROPERTIES' => '*OSSL_PKEY_PARAM_PROPERTIES',
+ 'OSSL_ASYM_CIPHER_PARAM_ENGINE' => '*OSSL_PKEY_PARAM_ENGINE',
+ 'OSSL_ASYM_CIPHER_PARAM_PAD_MODE' => '*OSSL_PKEY_PARAM_PAD_MODE',
+ 'OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST' => '*OSSL_PKEY_PARAM_MGF1_DIGEST',
+ 'OSSL_ASYM_CIPHER_PARAM_MGF1_DIGEST_PROPS' => '*OSSL_PKEY_PARAM_MGF1_PROPERTIES',
+ 'OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST' => '*OSSL_ALG_PARAM_DIGEST',
+ 'OSSL_ASYM_CIPHER_PARAM_OAEP_DIGEST_PROPS' => "digest-props",
# The following parameter is an octet_string on set and an octet_ptr on get
- 'ASYM_CIPHER_PARAM_OAEP_LABEL' => "oaep-label",
- 'ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION' => "tls-client-version",
- 'ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION' => "tls-negotiated-version",
- 'ASYM_CIPHER_PARAM_IMPLICIT_REJECTION' => "implicit-rejection",
- 'ASYM_CIPHER_PARAM_FIPS_RSA_PKCS15_PAD_DISABLED' => '*PROV_PARAM_RSA_PKCS15_PAD_DISABLED',
- 'ASYM_CIPHER_PARAM_FIPS_KEY_CHECK' => '*PKEY_PARAM_FIPS_KEY_CHECK',
- 'ASYM_CIPHER_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_ASYM_CIPHER_PARAM_OAEP_LABEL' => "oaep-label",
+ 'OSSL_ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION' => "tls-client-version",
+ 'OSSL_ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION' => "tls-negotiated-version",
+ 'OSSL_ASYM_CIPHER_PARAM_IMPLICIT_REJECTION' => "implicit-rejection",
+ 'OSSL_ASYM_CIPHER_PARAM_FIPS_RSA_PKCS15_PAD_DISABLED' => '*OSSL_PROV_PARAM_RSA_PKCS15_PAD_DISABLED',
+ 'OSSL_ASYM_CIPHER_PARAM_FIPS_KEY_CHECK' => '*OSSL_PKEY_PARAM_FIPS_KEY_CHECK',
+ 'OSSL_ASYM_CIPHER_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
# Encoder / decoder parameters
- 'ENCODER_PARAM_CIPHER' => '*ALG_PARAM_CIPHER',
- 'ENCODER_PARAM_PROPERTIES' => '*ALG_PARAM_PROPERTIES',
+ 'OSSL_ENCODER_PARAM_CIPHER' => '*OSSL_ALG_PARAM_CIPHER',
+ 'OSSL_ENCODER_PARAM_PROPERTIES' => '*OSSL_ALG_PARAM_PROPERTIES',
# Currently PVK only, but reusable for others as needed
- 'ENCODER_PARAM_ENCRYPT_LEVEL' => "encrypt-level",
- 'ENCODER_PARAM_SAVE_PARAMETERS' => "save-parameters",# integer
+ 'OSSL_ENCODER_PARAM_ENCRYPT_LEVEL' => "encrypt-level",
+ 'OSSL_ENCODER_PARAM_SAVE_PARAMETERS' => "save-parameters",# integer
- 'DECODER_PARAM_PROPERTIES' => '*ALG_PARAM_PROPERTIES',
+ 'OSSL_DECODER_PARAM_PROPERTIES' => '*OSSL_ALG_PARAM_PROPERTIES',
# Passphrase callback parameters
- 'PASSPHRASE_PARAM_INFO' => "info",
+ 'OSSL_PASSPHRASE_PARAM_INFO' => "info",
# Keygen callback parameters, from provider to libcrypto
- 'GEN_PARAM_POTENTIAL' => "potential",# integer
- 'GEN_PARAM_ITERATION' => "iteration",# integer
+ 'OSSL_GEN_PARAM_POTENTIAL' => "potential",# integer
+ 'OSSL_GEN_PARAM_ITERATION' => "iteration",# integer
# ACVP Test parameters : These should not be used normally
- 'PKEY_PARAM_RSA_TEST_XP1' => "xp1",
- 'PKEY_PARAM_RSA_TEST_XP2' => "xp2",
- 'PKEY_PARAM_RSA_TEST_XP' => "xp",
- 'PKEY_PARAM_RSA_TEST_XQ1' => "xq1",
- 'PKEY_PARAM_RSA_TEST_XQ2' => "xq2",
- 'PKEY_PARAM_RSA_TEST_XQ' => "xq",
- 'PKEY_PARAM_RSA_TEST_P1' => "p1",
- 'PKEY_PARAM_RSA_TEST_P2' => "p2",
- 'PKEY_PARAM_RSA_TEST_Q1' => "q1",
- 'PKEY_PARAM_RSA_TEST_Q2' => "q2",
- 'SIGNATURE_PARAM_KAT' => "kat",
+ 'OSSL_PKEY_PARAM_RSA_TEST_XP1' => "xp1",
+ 'OSSL_PKEY_PARAM_RSA_TEST_XP2' => "xp2",
+ 'OSSL_PKEY_PARAM_RSA_TEST_XP' => "xp",
+ 'OSSL_PKEY_PARAM_RSA_TEST_XQ1' => "xq1",
+ 'OSSL_PKEY_PARAM_RSA_TEST_XQ2' => "xq2",
+ 'OSSL_PKEY_PARAM_RSA_TEST_XQ' => "xq",
+ 'OSSL_PKEY_PARAM_RSA_TEST_P1' => "p1",
+ 'OSSL_PKEY_PARAM_RSA_TEST_P2' => "p2",
+ 'OSSL_PKEY_PARAM_RSA_TEST_Q1' => "q1",
+ 'OSSL_PKEY_PARAM_RSA_TEST_Q2' => "q2",
+ 'OSSL_SIGNATURE_PARAM_KAT' => "kat",
# KEM parameters
- 'KEM_PARAM_OPERATION' => "operation",
- 'KEM_PARAM_IKME' => "ikme",
- 'KEM_PARAM_FIPS_KEY_CHECK' => '*PKEY_PARAM_FIPS_KEY_CHECK',
- 'KEM_PARAM_FIPS_APPROVED_INDICATOR' => '*ALG_PARAM_FIPS_APPROVED_INDICATOR',
+ 'OSSL_KEM_PARAM_OPERATION' => "operation",
+ 'OSSL_KEM_PARAM_IKME' => "ikme",
+ 'OSSL_KEM_PARAM_FIPS_KEY_CHECK' => '*OSSL_PKEY_PARAM_FIPS_KEY_CHECK',
+ 'OSSL_KEM_PARAM_FIPS_APPROVED_INDICATOR' => '*OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR',
# Capabilities
# TLS-GROUP Capability
- 'CAPABILITY_TLS_GROUP_NAME' => "tls-group-name",
- 'CAPABILITY_TLS_GROUP_NAME_INTERNAL' => "tls-group-name-internal",
- 'CAPABILITY_TLS_GROUP_ID' => "tls-group-id",
- 'CAPABILITY_TLS_GROUP_ALG' => "tls-group-alg",
- 'CAPABILITY_TLS_GROUP_SECURITY_BITS' => "tls-group-sec-bits",
- 'CAPABILITY_TLS_GROUP_IS_KEM' => "tls-group-is-kem",
- 'CAPABILITY_TLS_GROUP_MIN_TLS' => "tls-min-tls",
- 'CAPABILITY_TLS_GROUP_MAX_TLS' => "tls-max-tls",
- 'CAPABILITY_TLS_GROUP_MIN_DTLS' => "tls-min-dtls",
- 'CAPABILITY_TLS_GROUP_MAX_DTLS' => "tls-max-dtls",
+ 'OSSL_CAPABILITY_TLS_GROUP_NAME' => "tls-group-name",
+ 'OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL' => "tls-group-name-internal",
+ 'OSSL_CAPABILITY_TLS_GROUP_ID' => "tls-group-id",
+ 'OSSL_CAPABILITY_TLS_GROUP_ALG' => "tls-group-alg",
+ 'OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS' => "tls-group-sec-bits",
+ 'OSSL_CAPABILITY_TLS_GROUP_IS_KEM' => "tls-group-is-kem",
+ 'OSSL_CAPABILITY_TLS_GROUP_MIN_TLS' => "tls-min-tls",
+ 'OSSL_CAPABILITY_TLS_GROUP_MAX_TLS' => "tls-max-tls",
+ 'OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS' => "tls-min-dtls",
+ 'OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS' => "tls-max-dtls",
# TLS-SIGALG Capability
- 'CAPABILITY_TLS_SIGALG_IANA_NAME' => "tls-sigalg-iana-name",
- 'CAPABILITY_TLS_SIGALG_CODE_POINT' => "tls-sigalg-code-point",
- 'CAPABILITY_TLS_SIGALG_NAME' => "tls-sigalg-name",
- 'CAPABILITY_TLS_SIGALG_OID' => "tls-sigalg-oid",
- 'CAPABILITY_TLS_SIGALG_SIG_NAME' => "tls-sigalg-sig-name",
- 'CAPABILITY_TLS_SIGALG_SIG_OID' => "tls-sigalg-sig-oid",
- 'CAPABILITY_TLS_SIGALG_HASH_NAME' => "tls-sigalg-hash-name",
- 'CAPABILITY_TLS_SIGALG_HASH_OID' => "tls-sigalg-hash-oid",
- 'CAPABILITY_TLS_SIGALG_KEYTYPE' => "tls-sigalg-keytype",
- 'CAPABILITY_TLS_SIGALG_KEYTYPE_OID' => "tls-sigalg-keytype-oid",
- 'CAPABILITY_TLS_SIGALG_SECURITY_BITS' => "tls-sigalg-sec-bits",
- 'CAPABILITY_TLS_SIGALG_MIN_TLS' => "tls-min-tls",
- 'CAPABILITY_TLS_SIGALG_MAX_TLS' => "tls-max-tls",
- 'CAPABILITY_TLS_SIGALG_MIN_DTLS' => "tls-min-dtls",
- 'CAPABILITY_TLS_SIGALG_MAX_DTLS' => "tls-max-dtls",
+ 'OSSL_CAPABILITY_TLS_SIGALG_IANA_NAME' => "tls-sigalg-iana-name",
+ 'OSSL_CAPABILITY_TLS_SIGALG_CODE_POINT' => "tls-sigalg-code-point",
+ 'OSSL_CAPABILITY_TLS_SIGALG_NAME' => "tls-sigalg-name",
+ 'OSSL_CAPABILITY_TLS_SIGALG_OID' => "tls-sigalg-oid",
+ 'OSSL_CAPABILITY_TLS_SIGALG_SIG_NAME' => "tls-sigalg-sig-name",
+ 'OSSL_CAPABILITY_TLS_SIGALG_SIG_OID' => "tls-sigalg-sig-oid",
+ 'OSSL_CAPABILITY_TLS_SIGALG_HASH_NAME' => "tls-sigalg-hash-name",
+ 'OSSL_CAPABILITY_TLS_SIGALG_HASH_OID' => "tls-sigalg-hash-oid",
+ 'OSSL_CAPABILITY_TLS_SIGALG_KEYTYPE' => "tls-sigalg-keytype",
+ 'OSSL_CAPABILITY_TLS_SIGALG_KEYTYPE_OID' => "tls-sigalg-keytype-oid",
+ 'OSSL_CAPABILITY_TLS_SIGALG_SECURITY_BITS' => "tls-sigalg-sec-bits",
+ 'OSSL_CAPABILITY_TLS_SIGALG_MIN_TLS' => "tls-min-tls",
+ 'OSSL_CAPABILITY_TLS_SIGALG_MAX_TLS' => "tls-max-tls",
+ 'OSSL_CAPABILITY_TLS_SIGALG_MIN_DTLS' => "tls-min-dtls",
+ 'OSSL_CAPABILITY_TLS_SIGALG_MAX_DTLS' => "tls-max-dtls",
# storemgmt parameters
# are used as search criteria.
# (STORE_PARAM_DIGEST is used with STORE_PARAM_FINGERPRINT)
- 'STORE_PARAM_EXPECT' => "expect", # INTEGER
- 'STORE_PARAM_SUBJECT' => "subject", # DER blob => OCTET_STRING
- 'STORE_PARAM_ISSUER' => "name", # DER blob => OCTET_STRING
- 'STORE_PARAM_SERIAL' => "serial", # INTEGER
- 'STORE_PARAM_DIGEST' => "digest", # UTF8_STRING
- 'STORE_PARAM_FINGERPRINT' => "fingerprint", # OCTET_STRING
- 'STORE_PARAM_ALIAS' => "alias", # UTF8_STRING
+ 'OSSL_STORE_PARAM_EXPECT' => "expect", # INTEGER
+ 'OSSL_STORE_PARAM_SUBJECT' => "subject", # DER blob => OCTET_STRING
+ 'OSSL_STORE_PARAM_ISSUER' => "name", # DER blob => OCTET_STRING
+ 'OSSL_STORE_PARAM_SERIAL' => "serial", # INTEGER
+ 'OSSL_STORE_PARAM_DIGEST' => "digest", # UTF8_STRING
+ 'OSSL_STORE_PARAM_FINGERPRINT' => "fingerprint", # OCTET_STRING
+ 'OSSL_STORE_PARAM_ALIAS' => "alias", # UTF8_STRING
# You may want to pass properties for the provider implementation to use
- 'STORE_PARAM_PROPERTIES' => "properties", # utf8_string
+ 'OSSL_STORE_PARAM_PROPERTIES' => "properties", # utf8_string
# DECODER input type if a decoder is used by the store
- 'STORE_PARAM_INPUT_TYPE' => "input-type", # UTF8_STRING
+ 'OSSL_STORE_PARAM_INPUT_TYPE' => "input-type", # UTF8_STRING
# Libssl record layer
- 'LIBSSL_RECORD_LAYER_PARAM_OPTIONS' => "options",
- 'LIBSSL_RECORD_LAYER_PARAM_MODE' => "mode",
- 'LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD' => "read_ahead",
- 'LIBSSL_RECORD_LAYER_READ_BUFFER_LEN' => "read_buffer_len",
- 'LIBSSL_RECORD_LAYER_PARAM_USE_ETM' => "use_etm",
- 'LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC' => "stream_mac",
- 'LIBSSL_RECORD_LAYER_PARAM_TLSTREE' => "tlstree",
- 'LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN' => "max_frag_len",
- 'LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA' => "max_early_data",
- 'LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING' => "block_padding",
- 'LIBSSL_RECORD_LAYER_PARAM_HS_PADDING' => "hs_padding",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS' => "options",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_MODE' => "mode",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD' => "read_ahead",
+ 'OSSL_LIBSSL_RECORD_LAYER_READ_BUFFER_LEN' => "read_buffer_len",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_USE_ETM' => "use_etm",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC' => "stream_mac",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_TLSTREE' => "tlstree",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN' => "max_frag_len",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA' => "max_early_data",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING' => "block_padding",
+ 'OSSL_LIBSSL_RECORD_LAYER_PARAM_HS_PADDING' => "hs_padding",
# Symmetric Key parametes
- 'SKEY_PARAM_RAW_BYTES' => "raw-bytes",
- 'SKEY_PARAM_KEY_LENGTH' => "key-length",
+ 'OSSL_SKEY_PARAM_RAW_BYTES' => "raw-bytes",
+ 'OSSL_SKEY_PARAM_KEY_LENGTH' => "key-length",
);
sub output_ifdef {
foreach my $name (keys %params) {
my $val = $params{$name};
- my $def = '# define OSSL_' . $name . ' ';
+ my $def = '# define ' . $name . ' ';
if (substr($val, 0, 1) eq '*') {
- $def .= 'OSSL_' . substr($val, 1);
+ $def .= substr($val, 1);
} else {
$def .= '"' . $val . '"';
}
}
}
output_ifdef($ifdefs{$pident});
- print " OSSL_PARAM_$ptype(OSSL_$pname, NULL";
+ print " OSSL_PARAM_$ptype($pname, NULL";
print ", 0" if $ptype eq "octet_string" || $ptype eq "octet_ptr"
|| $ptype eq "utf8_string" || $ptype eq "utf8_ptr"
|| $ptype eq "BN";
projects / thirdparty / openssl.git / commitdiff
