Also convert the names to lower case.
Reviewed-by: Richard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/13014)
static void base_teardown(void *provctx)
{
- BIO_meth_free(PROV_CTX_get0_core_bio_method(provctx));
- PROV_CTX_free(provctx);
+ BIO_meth_free(ossl_prov_ctx_get0_core_bio_method(provctx));
+ ossl_prov_ctx_free(provctx);
}
/* Functions we provide to the core */
* This only works for built-in providers. Most providers should
* create their own library context.
*/
- if ((*provctx = PROV_CTX_new()) == NULL
+ if ((*provctx = ossl_prov_ctx_new()) == NULL
|| (corebiometh = bio_prov_init_bio_method()) == NULL) {
- PROV_CTX_free(*provctx);
+ ossl_prov_ctx_free(*provctx);
*provctx = NULL;
return 0;
}
- PROV_CTX_set0_library_context(*provctx, (OPENSSL_CTX *)c_get_libctx(handle));
- PROV_CTX_set0_handle(*provctx, handle);
- PROV_CTX_set0_core_bio_method(*provctx, corebiometh);
+ ossl_prov_ctx_set0_library_context(*provctx,
+ (OPENSSL_CTX *)c_get_libctx(handle));
+ ossl_prov_ctx_set0_handle(*provctx, handle);
+ ossl_prov_ctx_set0_core_bio_method(*provctx, corebiometh);
*out = base_dispatch_table;
BIO *bio_new_from_core_bio(PROV_CTX *provctx, OSSL_CORE_BIO *corebio)
{
BIO *outbio;
- BIO_METHOD *corebiometh = PROV_CTX_get0_core_bio_method(provctx);
+ BIO_METHOD *corebiometh = ossl_prov_ctx_get0_core_bio_method(provctx);
if (corebiometh == NULL)
return NULL;
* fetching functions.
*/
# define PROV_LIBRARY_CONTEXT_OF(provctx) \
- PROV_CTX_get0_library_context((provctx))
+ ossl_prov_ctx_get0_library_context((provctx))
-PROV_CTX *PROV_CTX_new(void);
-void PROV_CTX_free(PROV_CTX *ctx);
-void PROV_CTX_set0_library_context(PROV_CTX *ctx, OPENSSL_CTX *libctx);
-void PROV_CTX_set0_handle(PROV_CTX *ctx, const OSSL_CORE_HANDLE *handle);
-void PROV_CTX_set0_core_bio_method(PROV_CTX *ctx, BIO_METHOD *corebiometh);
-OPENSSL_CTX *PROV_CTX_get0_library_context(PROV_CTX *ctx);
-const OSSL_CORE_HANDLE *PROV_CTX_get0_handle(PROV_CTX *ctx);
-BIO_METHOD *PROV_CTX_get0_core_bio_method(PROV_CTX *ctx);
+PROV_CTX *ossl_prov_ctx_new(void);
+void ossl_prov_ctx_free(PROV_CTX *ctx);
+void ossl_prov_ctx_set0_library_context(PROV_CTX *ctx, OPENSSL_CTX *libctx);
+void ossl_prov_ctx_set0_handle(PROV_CTX *ctx, const OSSL_CORE_HANDLE *handle);
+void ossl_prov_ctx_set0_core_bio_method(PROV_CTX *ctx, BIO_METHOD *corebiometh);
+OPENSSL_CTX *ossl_prov_ctx_get0_library_context(PROV_CTX *ctx);
+const OSSL_CORE_HANDLE *ossl_prov_ctx_get0_handle(PROV_CTX *ctx);
+BIO_METHOD *ossl_prov_ctx_get0_core_bio_method(PROV_CTX *ctx);
#endif
#include "prov/provider_ctx.h"
#include "prov/bio.h"
-PROV_CTX *PROV_CTX_new(void)
+PROV_CTX *ossl_prov_ctx_new(void)
{
return OPENSSL_zalloc(sizeof(PROV_CTX));
}
-void PROV_CTX_free(PROV_CTX *ctx)
+void ossl_prov_ctx_free(PROV_CTX *ctx)
{
OPENSSL_free(ctx);
}
-void PROV_CTX_set0_library_context(PROV_CTX *ctx, OPENSSL_CTX *libctx)
+void ossl_prov_ctx_set0_library_context(PROV_CTX *ctx, OPENSSL_CTX *libctx)
{
if (ctx != NULL)
ctx->libctx = libctx;
}
-void PROV_CTX_set0_handle(PROV_CTX *ctx, const OSSL_CORE_HANDLE *handle)
+void ossl_prov_ctx_set0_handle(PROV_CTX *ctx, const OSSL_CORE_HANDLE *handle)
{
if (ctx != NULL)
ctx->handle = handle;
}
-void PROV_CTX_set0_core_bio_method(PROV_CTX *ctx, BIO_METHOD *corebiometh)
+void ossl_prov_ctx_set0_core_bio_method(PROV_CTX *ctx, BIO_METHOD *corebiometh)
{
if (ctx != NULL)
ctx->corebiometh = corebiometh;
}
-OPENSSL_CTX *PROV_CTX_get0_library_context(PROV_CTX *ctx)
+OPENSSL_CTX *ossl_prov_ctx_get0_library_context(PROV_CTX *ctx)
{
if (ctx == NULL)
return NULL;
return ctx->libctx;
}
-const OSSL_CORE_HANDLE *PROV_CTX_get0_handle(PROV_CTX *ctx)
+const OSSL_CORE_HANDLE *ossl_prov_ctx_get0_handle(PROV_CTX *ctx)
{
if (ctx == NULL)
return NULL;
return ctx->handle;
}
-BIO_METHOD *PROV_CTX_get0_core_bio_method(PROV_CTX *ctx)
+BIO_METHOD *ossl_prov_ctx_get0_core_bio_method(PROV_CTX *ctx)
{
if (ctx == NULL)
return NULL;
static void deflt_teardown(void *provctx)
{
- BIO_meth_free(PROV_CTX_get0_core_bio_method(provctx));
- PROV_CTX_free(provctx);
+ BIO_meth_free(ossl_prov_ctx_get0_core_bio_method(provctx));
+ ossl_prov_ctx_free(provctx);
}
/* Functions we provide to the core */
* This only works for built-in providers. Most providers should
* create their own library context.
*/
- if ((*provctx = PROV_CTX_new()) == NULL
+ if ((*provctx = ossl_prov_ctx_new()) == NULL
|| (corebiometh = bio_prov_init_bio_method()) == NULL) {
- PROV_CTX_free(*provctx);
+ ossl_prov_ctx_free(*provctx);
*provctx = NULL;
return 0;
}
- PROV_CTX_set0_library_context(*provctx, (OPENSSL_CTX *)c_get_libctx(handle));
- PROV_CTX_set0_handle(*provctx, handle);
- PROV_CTX_set0_core_bio_method(*provctx, corebiometh);
+ ossl_prov_ctx_set0_library_context(*provctx,
+ (OPENSSL_CTX *)c_get_libctx(handle));
+ ossl_prov_ctx_set0_handle(*provctx, handle);
+ ossl_prov_ctx_set0_core_bio_method(*provctx, corebiometh);
*out = deflt_dispatch_table;
case OSSL_OP_DIGEST:
return fips_digests;
case OSSL_OP_CIPHER:
- ossl_prov_cache_exported_algorithms(fips_ciphers, exported_fips_ciphers);
+ ossl_prov_cache_exported_algorithms(fips_ciphers,
+ exported_fips_ciphers);
return exported_fips_ciphers;
case OSSL_OP_MAC:
return fips_macs;
static void fips_teardown(void *provctx)
{
OPENSSL_CTX_free(PROV_LIBRARY_CONTEXT_OF(provctx));
- PROV_CTX_free(provctx);
+ ossl_prov_ctx_free(provctx);
}
static void fips_intern_teardown(void *provctx)
* We know that the library context is the same as for the outer provider,
* so no need to destroy it here.
*/
- PROV_CTX_free(provctx);
+ ossl_prov_ctx_free(provctx);
}
/* Functions we provide to the core */
fips_security_checks = 0;
/* Create a context. */
- if ((*provctx = PROV_CTX_new()) == NULL
+ if ((*provctx = ossl_prov_ctx_new()) == NULL
|| (libctx = OPENSSL_CTX_new()) == NULL) {
/*
* We free libctx separately here and only here because it hasn't
OPENSSL_CTX_free(libctx);
goto err;
}
- PROV_CTX_set0_library_context(*provctx, libctx);
- PROV_CTX_set0_handle(*provctx, handle);
+ ossl_prov_ctx_set0_library_context(*provctx, libctx);
+ ossl_prov_ctx_set0_handle(*provctx, handle);
if ((fgbl = openssl_ctx_get_data(libctx, OPENSSL_CTX_FIPS_PROV_INDEX,
&fips_prov_ossl_ctx_method)) == NULL)
if (c_internal_get_libctx == NULL)
return 0;
- if ((*provctx = PROV_CTX_new()) == NULL)
+ if ((*provctx = ossl_prov_ctx_new()) == NULL)
return 0;
/*
* internal provider. This is not something that most providers would be
* able to do.
*/
- PROV_CTX_set0_library_context(*provctx,
- (OPENSSL_CTX *)c_internal_get_libctx(handle));
- PROV_CTX_set0_handle(*provctx, handle);
+ ossl_prov_ctx_set0_library_context(
+ *provctx, (OPENSSL_CTX *)c_internal_get_libctx(handle)
+ );
+ ossl_prov_ctx_set0_handle(*provctx, handle);
*out = intern_dispatch_table;
return 1;
if (!EVP_RAND_set_ctx_params(test, drbg_params))
goto err;
- /* This calls PROV_DRBG_reseed() internally when prediction_resistance = 1 */
+ /*
+ * This calls ossl_prov_drbg_reseed() internally when
+ * prediction_resistance = 1
+ */
if (!EVP_RAND_generate(drbg, out, t->expectedlen, strength,
prediction_resistance,
t->entropyaddin2, t->entropyaddin2len))
if (!EVP_RAND_uninstantiate(drbg))
goto err;
/*
- * Check that the DRBG data has been zeroized after PROV_DRBG_uninstantiate.
+ * Check that the DRBG data has been zeroized after
+ * ossl_prov_drbg_uninstantiate.
*/
if (!EVP_RAND_verify_zeroization(drbg))
goto err;
} PROV_AES_CTX;
-#define PROV_CIPHER_HW_aes_ofb PROV_CIPHER_HW_aes_ofb128
-#define PROV_CIPHER_HW_aes_cfb PROV_CIPHER_HW_aes_cfb128
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aes_ecb(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aes_cbc(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aes_ofb128(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aes_cfb128(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aes_cfb1(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aes_cfb8(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aes_ctr(size_t keybits);
+#define ossl_prov_cipher_hw_aes_ofb ossl_prov_cipher_hw_aes_ofb128
+#define ossl_prov_cipher_hw_aes_cfb ossl_prov_cipher_hw_aes_cfb128
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aes_ecb(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aes_cbc(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aes_ofb128(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aes_cfb128(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aes_cfb1(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aes_cfb8(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aes_ctr(size_t keybits);
ctx = OPENSSL_zalloc(sizeof(*ctx));
if (ctx != NULL)
base_init(provctx, &ctx->base_ctx,
- PROV_CIPHER_HW_aes_cbc_hmac_sha1(), kbits, blkbits,
+ ossl_prov_cipher_hw_aes_cbc_hmac_sha1(), kbits, blkbits,
ivbits, flags);
return ctx;
}
ctx = OPENSSL_zalloc(sizeof(*ctx));
if (ctx != NULL)
base_init(provctx, &ctx->base_ctx,
- PROV_CIPHER_HW_aes_cbc_hmac_sha256(), kbits, blkbits,
+ ossl_prov_cipher_hw_aes_cbc_hmac_sha256(), kbits, blkbits,
ivbits, flags);
return ctx;
}
# endif /* OPENSSL_NO_MULTIBLOCK) */
} PROV_CIPHER_HW_AES_HMAC_SHA;
-const PROV_CIPHER_HW_AES_HMAC_SHA *PROV_CIPHER_HW_aes_cbc_hmac_sha1(void);
-const PROV_CIPHER_HW_AES_HMAC_SHA *PROV_CIPHER_HW_aes_cbc_hmac_sha256(void);
+const PROV_CIPHER_HW_AES_HMAC_SHA *ossl_prov_cipher_hw_aes_cbc_hmac_sha1(void);
+const PROV_CIPHER_HW_AES_HMAC_SHA *ossl_prov_cipher_hw_aes_cbc_hmac_sha256(void);
#ifdef AES_CBC_HMAC_SHA_CAPABLE
# include <openssl/aes.h>
return 0;
}
-const PROV_CIPHER_HW_AES_HMAC_SHA *PROV_CIPHER_HW_aes_cbc_hmac_sha1(void)
+const PROV_CIPHER_HW_AES_HMAC_SHA *ossl_prov_cipher_hw_aes_cbc_hmac_sha1(void)
{
return NULL;
}
# endif
};
-const PROV_CIPHER_HW_AES_HMAC_SHA *PROV_CIPHER_HW_aes_cbc_hmac_sha1(void)
+const PROV_CIPHER_HW_AES_HMAC_SHA *ossl_prov_cipher_hw_aes_cbc_hmac_sha1(void)
{
return &cipher_hw_aes_hmac_sha1;
}
return 0;
}
-const PROV_CIPHER_HW_AES_HMAC_SHA *PROV_CIPHER_HW_aes_cbc_hmac_sha256(void)
+const PROV_CIPHER_HW_AES_HMAC_SHA *ossl_prov_cipher_hw_aes_cbc_hmac_sha256(void)
{
return NULL;
}
# endif
};
-const PROV_CIPHER_HW_AES_HMAC_SHA *PROV_CIPHER_HW_aes_cbc_hmac_sha256(void)
+const PROV_CIPHER_HW_AES_HMAC_SHA *ossl_prov_cipher_hw_aes_cbc_hmac_sha256(void)
{
return &cipher_hw_aes_hmac_sha256;
}
ctx = OPENSSL_zalloc(sizeof(*ctx));
if (ctx != NULL)
- ccm_initctx(&ctx->base, keybits, PROV_AES_HW_ccm(keybits));
+ ccm_initctx(&ctx->base, keybits, ossl_prov_aes_hw_ccm(keybits));
return ctx;
}
} ccm;
} PROV_AES_CCM_CTX;
-const PROV_CCM_HW *PROV_AES_HW_ccm(size_t keylen);
+const PROV_CCM_HW *ossl_prov_aes_hw_ccm(size_t keylen);
#elif defined(SPARC_AES_CAPABLE)
# include "cipher_aes_ccm_hw_t4.inc"
#else
-const PROV_CCM_HW *PROV_AES_HW_ccm(size_t keybits)
+const PROV_CCM_HW *ossl_prov_aes_hw_ccm(size_t keybits)
{
return &aes_ccm;
}
ccm_generic_gettag
};
-const PROV_CCM_HW *PROV_AES_HW_ccm(size_t keybits)
+const PROV_CCM_HW *ossl_prov_aes_hw_ccm(size_t keybits)
{
return AESNI_CAPABLE ? &aesni_ccm : &aes_ccm;
}
s390x_aes_ccm_gettag
};
-const PROV_CCM_HW *PROV_AES_HW_ccm(size_t keybits)
+const PROV_CCM_HW *ossl_prov_aes_hw_ccm(size_t keybits)
{
if ((keybits == 128 && S390X_aes_128_ccm_CAPABLE)
|| (keybits == 192 && S390X_aes_192_ccm_CAPABLE)
ccm_generic_gettag
};
-const PROV_CCM_HW *PROV_AES_HW_ccm(size_t keybits)
+const PROV_CCM_HW *ossl_prov_aes_hw_ccm(size_t keybits)
{
return SPARC_AES_CAPABLE ? &t4_aes_ccm : &aes_ccm;
}
ctx = OPENSSL_zalloc(sizeof(*ctx));
if (ctx != NULL)
- gcm_initctx(provctx, &ctx->base, keybits, PROV_AES_HW_gcm(keybits),
+ gcm_initctx(provctx, &ctx->base, keybits, ossl_prov_aes_hw_gcm(keybits),
AES_GCM_IV_MIN_SIZE);
return ctx;
}
} plat;
} PROV_AES_GCM_CTX;
-const PROV_GCM_HW *PROV_AES_HW_gcm(size_t keybits);
+const PROV_GCM_HW *ossl_prov_aes_hw_gcm(size_t keybits);
#elif defined(AES_PMULL_CAPABLE) && defined(AES_GCM_ASM)
# include "cipher_aes_gcm_hw_armv8.inc"
#else
-const PROV_GCM_HW *PROV_AES_HW_gcm(size_t keybits)
+const PROV_GCM_HW *ossl_prov_aes_hw_gcm(size_t keybits)
{
return &aes_gcm;
}
gcm_one_shot
};
-const PROV_GCM_HW *PROV_AES_HW_gcm(size_t keybits)
+const PROV_GCM_HW *ossl_prov_aes_hw_gcm(size_t keybits)
{
return AESNI_CAPABLE ? &aesni_gcm : &aes_gcm;
}
gcm_one_shot
};
-const PROV_GCM_HW *PROV_AES_HW_gcm(size_t keybits)
+const PROV_GCM_HW *ossl_prov_aes_hw_gcm(size_t keybits)
{
return AES_PMULL_CAPABLE ? &armv8_aes_gcm : &aes_gcm;
}
s390x_aes_gcm_one_shot
};
-const PROV_GCM_HW *PROV_AES_HW_gcm(size_t keybits)
+const PROV_GCM_HW *ossl_prov_aes_hw_gcm(size_t keybits)
{
if ((keybits == 128 && S390X_aes_128_gcm_CAPABLE)
|| (keybits == 192 && S390X_aes_192_gcm_CAPABLE)
gcm_cipher_final,
gcm_one_shot
};
-const PROV_GCM_HW *PROV_AES_HW_gcm(size_t keybits)
+const PROV_GCM_HW *ossl_prov_aes_hw_gcm(size_t keybits)
{
return SPARC_AES_CAPABLE ? &t4_aes_gcm : &aes_gcm;
}
cipher_hw_aes_copyctx \
}; \
PROV_CIPHER_HW_declare(mode) \
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aes_##mode(size_t keybits) \
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aes_##mode(size_t keybits) \
{ \
PROV_CIPHER_HW_select(mode) \
return &aes_##mode; \
ctx = OPENSSL_zalloc(sizeof(*ctx));
if (ctx != NULL) {
cipher_generic_initkey(ctx, kbits, blkbits, ivbits, mode, flags,
- PROV_CIPHER_HW_aes_ocb(kbits), NULL);
+ ossl_prov_cipher_hw_aes_ocb(kbits), NULL);
ctx->taglen = OCB_DEFAULT_TAG_LEN;
}
return ctx;
unsigned char aad_buf[OCB_MAX_AAD_LEN]; /* Store partial AAD blocks */
} PROV_AES_OCB_CTX;
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aes_ocb(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aes_ocb(size_t keybits);
NULL
};
PROV_CIPHER_HW_declare()
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aes_ocb(size_t keybits)
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aes_ocb(size_t keybits)
{
PROV_CIPHER_HW_select()
return &aes_generic_ocb;
ctx->mode = mode;
ctx->flags = flags;
ctx->keylen = keybits / 8;
- ctx->hw = PROV_CIPHER_HW_aes_siv(keybits);
+ ctx->hw = ossl_prov_cipher_hw_aes_siv(keybits);
ctx->libctx = PROV_LIBRARY_CONTEXT_OF(provctx);
}
return ctx;
OPENSSL_CTX *libctx;
} PROV_AES_SIV_CTX;
-const PROV_CIPHER_HW_AES_SIV *PROV_CIPHER_HW_aes_siv(size_t keybits);
+const PROV_CIPHER_HW_AES_SIV *ossl_prov_cipher_hw_aes_siv(size_t keybits);
aes_siv_dupctx,
};
-const PROV_CIPHER_HW_AES_SIV *PROV_CIPHER_HW_aes_siv(size_t keybits)
+const PROV_CIPHER_HW_AES_SIV *ossl_prov_cipher_hw_aes_siv(size_t keybits)
{
return &aes_siv_hw;
}
if (ctx != NULL) {
cipher_generic_initkey(&ctx->base, kbits, blkbits, ivbits, mode, flags,
- PROV_CIPHER_HW_aes_xts(kbits), NULL);
+ ossl_prov_cipher_hw_aes_xts(kbits), NULL);
}
return ctx;
}
OSSL_xts_stream_fn stream;
} PROV_AES_XTS_CTX;
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aes_xts(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aes_xts(size_t keybits);
cipher_hw_aes_xts_copyctx
};
PROV_CIPHER_HW_declare_xts()
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aes_xts(size_t keybits)
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aes_xts(size_t keybits)
{
PROV_CIPHER_HW_select_xts()
return &aes_generic_xts;
} PROV_ARIA_CTX;
-# define PROV_CIPHER_HW_aria_ofb PROV_CIPHER_HW_aria_ofb128
-# define PROV_CIPHER_HW_aria_cfb PROV_CIPHER_HW_aria_cfb128
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aria_ecb(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aria_cbc(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aria_ofb128(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aria_cfb128(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aria_cfb1(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aria_cfb8(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aria_ctr(size_t keybits);
+#define ossl_prov_cipher_hw_aria_ofb ossl_prov_cipher_hw_aria_ofb128
+#define ossl_prov_cipher_hw_aria_cfb ossl_prov_cipher_hw_aria_cfb128
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aria_ecb(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aria_cbc(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aria_ofb128(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aria_cfb128(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aria_cfb1(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aria_cfb8(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aria_ctr(size_t keybits);
ctx = OPENSSL_zalloc(sizeof(*ctx));
if (ctx != NULL)
- ccm_initctx(&ctx->base, keybits, PROV_ARIA_HW_ccm(keybits));
+ ccm_initctx(&ctx->base, keybits, ossl_prov_aria_hw_ccm(keybits));
return ctx;
}
} ks; /* ARIA key schedule to use */
} PROV_ARIA_CCM_CTX;
-const PROV_CCM_HW *PROV_ARIA_HW_ccm(size_t keylen);
+const PROV_CCM_HW *ossl_prov_aria_hw_ccm(size_t keylen);
ccm_generic_auth_decrypt,
ccm_generic_gettag
};
-const PROV_CCM_HW *PROV_ARIA_HW_ccm(size_t keybits)
+const PROV_CCM_HW *ossl_prov_aria_hw_ccm(size_t keybits)
{
return &ccm_aria;
}
ctx = OPENSSL_zalloc(sizeof(*ctx));
if (ctx != NULL)
- gcm_initctx(provctx, &ctx->base, keybits, PROV_ARIA_HW_gcm(keybits),
- ARIA_GCM_IV_MIN_SIZE);
+ gcm_initctx(provctx, &ctx->base, keybits,
+ ossl_prov_aria_hw_gcm(keybits), ARIA_GCM_IV_MIN_SIZE);
return ctx;
}
} ks;
} PROV_ARIA_GCM_CTX;
-const PROV_GCM_HW *PROV_ARIA_HW_gcm(size_t keybits);
+const PROV_GCM_HW *ossl_prov_aria_hw_gcm(size_t keybits);
gcm_cipher_final,
gcm_one_shot
};
-const PROV_GCM_HW *PROV_ARIA_HW_gcm(size_t keybits)
+const PROV_GCM_HW *ossl_prov_aria_hw_gcm(size_t keybits)
{
return &aria_gcm;
}
cipher_hw_chunked_##mode, \
cipher_hw_aria_copyctx \
}; \
-const PROV_CIPHER_HW *PROV_CIPHER_HW_aria_##mode(size_t keybits) \
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_aria_##mode(size_t keybits) \
{ \
return &aria_##mode; \
}
} ks;
} PROV_BLOWFISH_CTX;
-const PROV_CIPHER_HW *PROV_CIPHER_HW_blowfish_cbc(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_blowfish_ecb(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_blowfish_ofb64(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_blowfish_cfb64(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_blowfish_cbc(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_blowfish_ecb(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_blowfish_ofb64(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_blowfish_cfb64(size_t keybits);
cipher_hw_blowfish_initkey, \
cipher_hw_blowfish_##mode##_cipher \
}; \
-const PROV_CIPHER_HW *PROV_CIPHER_HW_blowfish_##mode(size_t keybits) \
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_blowfish_##mode(size_t keybits) \
{ \
return &bf_##mode; \
}
} ks;
} PROV_CAMELLIA_CTX;
-#define PROV_CIPHER_HW_camellia_ofb PROV_CIPHER_HW_camellia_ofb128
-#define PROV_CIPHER_HW_camellia_cfb PROV_CIPHER_HW_camellia_cfb128
-const PROV_CIPHER_HW *PROV_CIPHER_HW_camellia_ecb(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_camellia_cbc(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_camellia_ofb128(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_camellia_cfb128(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_camellia_cfb1(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_camellia_cfb8(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_camellia_ctr(size_t keybits);
+#define ossl_prov_cipher_hw_camellia_ofb ossl_prov_cipher_hw_camellia_ofb128
+#define ossl_prov_cipher_hw_camellia_cfb ossl_prov_cipher_hw_camellia_cfb128
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_camellia_ecb(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_camellia_cbc(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_camellia_ofb128(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_camellia_cfb128(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_camellia_cfb1(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_camellia_cfb8(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_camellia_ctr(size_t keybits);
cipher_hw_camellia_copyctx \
}; \
PROV_CIPHER_HW_declare(mode) \
-const PROV_CIPHER_HW *PROV_CIPHER_HW_camellia_##mode(size_t keybits) \
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_camellia_##mode(size_t keybits) \
{ \
PROV_CIPHER_HW_select(mode) \
return &camellia_##mode; \
} ks;
} PROV_CAST_CTX;
-const PROV_CIPHER_HW *PROV_CIPHER_HW_cast5_cbc(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_cast5_ecb(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_cast5_ofb64(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_cast5_cfb64(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_cast5_cbc(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_cast5_ecb(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_cast5_ofb64(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_cast5_cfb64(size_t keybits);
cipher_hw_cast5_initkey, \
cipher_hw_cast5_##mode##_cipher \
}; \
-const PROV_CIPHER_HW *PROV_CIPHER_HW_cast5_##mode(size_t keybits) \
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_cast5_##mode(size_t keybits) \
{ \
return &cast5_##mode; \
}
CHACHA20_BLKLEN * 8,
CHACHA20_IVLEN * 8,
0, CHACHA20_FLAGS,
- PROV_CIPHER_HW_chacha20(CHACHA20_KEYLEN * 8),
+ ossl_prov_cipher_hw_chacha20(CHACHA20_KEYLEN * 8),
NULL);
}
} PROV_CIPHER_HW_CHACHA20;
-const PROV_CIPHER_HW *PROV_CIPHER_HW_chacha20(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_chacha20(size_t keybits);
OSSL_FUNC_cipher_encrypt_init_fn chacha20_einit;
OSSL_FUNC_cipher_decrypt_init_fn chacha20_dinit;
chacha20_initiv
};
-const PROV_CIPHER_HW *PROV_CIPHER_HW_chacha20(size_t keybits)
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_chacha20(size_t keybits)
{
return (PROV_CIPHER_HW *)&chacha20_hw;
}
CHACHA20_POLY1305_IVLEN * 8,
CHACHA20_POLY1305_MODE,
CHACHA20_POLY1305_FLAGS,
- PROV_CIPHER_HW_chacha20_poly1305(
+ ossl_prov_cipher_hw_chacha20_poly1305(
CHACHA20_POLY1305_KEYLEN * 8),
- NULL);
+ NULL);
ctx->nonce_len = CHACHA20_POLY1305_IVLEN;
ctx->tls_payload_length = NO_TLS_PAYLOAD_LENGTH;
chacha20_initctx(&ctx->chacha);
size_t flen);
} PROV_CIPHER_HW_CHACHA20_POLY1305;
-const PROV_CIPHER_HW *PROV_CIPHER_HW_chacha20_poly1305(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_chacha20_poly1305(size_t keybits);
chacha_poly1305_tls_iv_set_fixed
};
-const PROV_CIPHER_HW *PROV_CIPHER_HW_chacha20_poly1305(size_t keybits)
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_chacha20_poly1305(size_t keybits)
{
return (PROV_CIPHER_HW *)&chacha20poly1305_hw;
}
cipher_hw_desx_cbc,
cipher_hw_desx_copyctx
};
-const PROV_CIPHER_HW *PROV_CIPHER_HW_tdes_desx_cbc(void)
+
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_tdes_desx_cbc(void)
{
return &desx_cbc;
}
} ks;
} PROV_IDEA_CTX;
-const PROV_CIPHER_HW *PROV_CIPHER_HW_idea_cbc(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_idea_ecb(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_idea_ofb64(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_idea_cfb64(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_idea_cbc(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_idea_ecb(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_idea_ofb64(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_idea_cfb64(size_t keybits);
cipher_hw_idea_initkey, \
cipher_hw_idea_##mode##_cipher \
}; \
-const PROV_CIPHER_HW *PROV_CIPHER_HW_idea_##mode(size_t keybits) \
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_idea_##mode(size_t keybits) \
{ \
return &idea_##mode; \
}
if (ctx != NULL) { \
cipher_generic_initkey(ctx, kbits, blkbits, ivbits, \
EVP_CIPH_##UCMODE##_MODE, flags, \
- PROV_CIPHER_HW_##alg##_##lcmode(kbits), NULL); \
+ ossl_prov_cipher_hw_##alg##_##lcmode(kbits), \
+ NULL); \
ctx->key_bits = kbits; \
} \
return ctx; \
size_t key_bits;
} PROV_RC2_CTX;
-#define PROV_CIPHER_HW_rc2_ofb128 PROV_CIPHER_HW_rc2_ofb64
-#define PROV_CIPHER_HW_rc2_cfb128 PROV_CIPHER_HW_rc2_cfb64
+#define ossl_prov_cipher_hw_rc2_ofb128 ossl_prov_cipher_hw_rc2_ofb64
+#define ossl_prov_cipher_hw_rc2_cfb128 ossl_prov_cipher_hw_rc2_cfb64
-const PROV_CIPHER_HW *PROV_CIPHER_HW_rc2_cbc(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_rc2_ecb(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_rc2_ofb64(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_rc2_cfb64(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_rc2_cbc(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_rc2_ecb(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_rc2_ofb64(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_rc2_cfb64(size_t keybits);
cipher_hw_rc2_initkey, \
cipher_hw_rc2_##mode##_cipher \
}; \
-const PROV_CIPHER_HW *PROV_CIPHER_HW_rc2_##mode(size_t keybits) \
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_rc2_##mode(size_t keybits) \
{ \
return &rc2_##mode; \
}
ctx = OPENSSL_zalloc(sizeof(*ctx)); \
if (ctx != NULL) { \
cipher_generic_initkey(ctx, kbits, blkbits, ivbits, 0, flags, \
- PROV_CIPHER_HW_##alg(kbits), NULL); \
+ ossl_prov_cipher_hw_##alg(kbits), NULL); \
} \
return ctx; \
} \
} ks;
} PROV_RC4_CTX;
-const PROV_CIPHER_HW *PROV_CIPHER_HW_rc4(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_rc4(size_t keybits);
RC4_HMAC_MD5_BLOCK_BITS,
RC4_HMAC_MD5_IV_BITS,
RC4_HMAC_MD5_MODE, RC4_HMAC_MD5_FLAGS,
- PROV_CIPHER_HW_rc4_hmac_md5(RC4_HMAC_MD5_KEY_BITS),
+ ossl_prov_cipher_hw_rc4_hmac_md5(RC4_HMAC_MD5_KEY_BITS),
NULL);
return ctx;
}
} PROV_CIPHER_HW_RC4_HMAC_MD5;
-const PROV_CIPHER_HW *PROV_CIPHER_HW_rc4_hmac_md5(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_rc4_hmac_md5(size_t keybits);
cipher_hw_rc4_hmac_md5_tls_init,
cipher_hw_rc4_hmac_md5_init_mackey
};
-const PROV_CIPHER_HW *PROV_CIPHER_HW_rc4_hmac_md5(size_t keybits)
+
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_rc4_hmac_md5(size_t keybits)
{
return (PROV_CIPHER_HW *)&rc4_hmac_md5_hw;
}
cipher_hw_rc4_initkey,
cipher_hw_rc4_cipher
};
-const PROV_CIPHER_HW *PROV_CIPHER_HW_rc4(size_t keybits)
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_rc4(size_t keybits)
{
return &rc4_hw;
}
if (ctx != NULL) { \
cipher_generic_initkey(ctx, kbits, blkbits, ivbits, \
EVP_CIPH_##UCMODE##_MODE, flags, \
- PROV_CIPHER_HW_##alg##_##lcmode(kbits), NULL); \
+ ossl_prov_cipher_hw_##alg##_##lcmode(kbits), \
+ NULL); \
ctx->rounds = RC5_12_ROUNDS; \
} \
return ctx; \
unsigned int rounds; /* number of rounds */
} PROV_RC5_CTX;
-const PROV_CIPHER_HW *PROV_CIPHER_HW_rc5_cbc(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_rc5_ecb(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_rc5_ofb64(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_rc5_cfb64(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_rc5_cbc(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_rc5_ecb(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_rc5_ofb64(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_rc5_cfb64(size_t keybits);
cipher_hw_rc5_initkey, \
cipher_hw_rc5_##mode##_cipher \
}; \
-const PROV_CIPHER_HW *PROV_CIPHER_HW_rc5_##mode(size_t keybits) \
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_rc5_##mode(size_t keybits) \
{ \
return &rc5_##mode; \
}
} ks;
} PROV_SEED_CTX;
-const PROV_CIPHER_HW *PROV_CIPHER_HW_seed_cbc(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_seed_ecb(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_seed_ofb128(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_seed_cfb128(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_seed_cbc(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_seed_ecb(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_seed_ofb128(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_seed_cfb128(size_t keybits);
cipher_hw_seed_initkey, \
cipher_hw_seed_##mode##_cipher \
}; \
-const PROV_CIPHER_HW *PROV_CIPHER_HW_seed_##mode(size_t keybits) \
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_seed_##mode(size_t keybits) \
{ \
return &seed_##mode; \
}
} ks;
} PROV_SM4_CTX;
-const PROV_CIPHER_HW *PROV_CIPHER_HW_sm4_cbc(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_sm4_ecb(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_sm4_ctr(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_sm4_ofb128(size_t keybits);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_sm4_cfb128(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_sm4_cbc(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_sm4_ecb(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_sm4_ctr(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_sm4_ofb128(size_t keybits);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_sm4_cfb128(size_t keybits);
cipher_hw_chunked_##mode, \
cipher_hw_sm4_copyctx \
}; \
-const PROV_CIPHER_HW *PROV_CIPHER_HW_sm4_##mode(size_t keybits) \
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_sm4_##mode(size_t keybits) \
{ \
return &sm4_##mode; \
}
static void *tdes_##type##_##lcmode##_newctx(void *provctx) \
{ \
return tdes_newctx(provctx, EVP_CIPH_##UCMODE##_MODE, kbits, blkbits, \
- ivbits, flags, PROV_CIPHER_HW_tdes_##type##_##lcmode());\
+ ivbits, flags, \
+ ossl_prov_cipher_hw_tdes_##type##_##lcmode()); \
} \
static OSSL_FUNC_cipher_get_params_fn tdes_##type##_##lcmode##_get_params; \
static int tdes_##type##_##lcmode##_get_params(OSSL_PARAM params[]) \
cipher_hw_tdes_##mode, \
cipher_hw_tdes_copyctx \
}; \
-const PROV_CIPHER_HW *PROV_CIPHER_HW_tdes_##type##_##mode(void) \
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_tdes_##type##_##mode(void) \
{ \
return &type##_##mode; \
}
int cipher_hw_tdes_ecb(PROV_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in, size_t len);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_tdes_ede3_cbc(void);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_tdes_ede3_ecb(void);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_tdes_ede3_cbc(void);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_tdes_ede3_ecb(void);
#include "prov/ciphercommon.h"
#include "cipher_tdes.h"
-const PROV_CIPHER_HW *PROV_CIPHER_HW_tdes_ede3_ofb(void);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_tdes_ede3_cfb(void);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_tdes_ede3_cfb1(void);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_tdes_ede3_cfb8(void);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_tdes_ede3_ofb(void);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_tdes_ede3_cfb(void);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_tdes_ede3_cfb1(void);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_tdes_ede3_cfb8(void);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_tdes_ede2_cbc(void);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_tdes_ede2_ecb(void);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_tdes_ede2_ofb(void);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_tdes_ede2_cfb(void);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_tdes_ede2_cbc(void);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_tdes_ede2_ecb(void);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_tdes_ede2_ofb(void);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_tdes_ede2_cfb(void);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_tdes_desx_cbc(void);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_tdes_desx_cbc(void);
-const PROV_CIPHER_HW *PROV_CIPHER_HW_tdes_wrap_cbc(void);
+const PROV_CIPHER_HW *ossl_prov_cipher_hw_tdes_wrap_cbc(void);
static void *tdes_wrap_newctx(void *provctx) \
{ \
return tdes_newctx(provctx, EVP_CIPH_WRAP_MODE, kbits, blkbits, ivbits, \
- flags, PROV_CIPHER_HW_tdes_wrap_cbc()); \
+ flags, ossl_prov_cipher_hw_tdes_wrap_cbc()); \
} \
static OSSL_FUNC_cipher_get_params_fn tdes_wrap_get_params; \
static int tdes_wrap_get_params(OSSL_PARAM params[]) \
static int key2any_set_ctx_params(void *vctx, const OSSL_PARAM params[])
{
struct key2any_ctx_st *ctx = vctx;
- OPENSSL_CTX *libctx = PROV_CTX_get0_library_context(ctx->provctx);
+ OPENSSL_CTX *libctx = ossl_prov_ctx_get0_library_context(ctx->provctx);
const OSSL_PARAM *cipherp =
OSSL_PARAM_locate_const(params, OSSL_ENCODER_PARAM_CIPHER);
const OSSL_PARAM *propsp =
if (ctx != NULL) { \
cipher_generic_initkey(ctx, kbits, blkbits, ivbits, \
EVP_CIPH_##UCMODE##_MODE, flags, \
- PROV_CIPHER_HW_##alg##_##lcmode(kbits), \
+ ossl_prov_cipher_hw_##alg##_##lcmode(kbits), \
provctx); \
} \
return ctx; \
* Implements the get_entropy() callback
*
* If the DRBG has a parent, then the required amount of entropy input
- * is fetched using the parent's PROV_DRBG_generate().
+ * is fetched using the parent's ossl_prov_drbg_generate().
*
* Otherwise, the entropy is polled from the system entropy sources
* using prov_pool_acquire_entropy().
*
* Returns 1 on success, 0 on failure.
*/
-int PROV_DRBG_instantiate(PROV_DRBG *drbg, unsigned int strength,
- int prediction_resistance,
- const unsigned char *pers, size_t perslen)
+int ossl_prov_drbg_instantiate(PROV_DRBG *drbg, unsigned int strength,
+ int prediction_resistance,
+ const unsigned char *pers, size_t perslen)
{
unsigned char *nonce = NULL, *entropy = NULL;
size_t noncelen = 0, entropylen = 0;
*
* Returns 1 on success, 0 on failure.
*/
-int PROV_DRBG_uninstantiate(PROV_DRBG *drbg)
+int ossl_prov_drbg_uninstantiate(PROV_DRBG *drbg)
{
drbg->state = EVP_RAND_STATE_UNINITIALISED;
return 1;
*
* Returns 1 on success, 0 on failure.
*/
-int PROV_DRBG_reseed(PROV_DRBG *drbg, int prediction_resistance,
- const unsigned char *ent, size_t ent_len,
- const unsigned char *adin, size_t adinlen)
+int ossl_prov_drbg_reseed(PROV_DRBG *drbg, int prediction_resistance,
+ const unsigned char *ent, size_t ent_len,
+ const unsigned char *adin, size_t adinlen)
{
unsigned char *entropy = NULL;
size_t entropylen = 0;
* Returns 1 on success, 0 on failure.
*
*/
-int PROV_DRBG_generate(PROV_DRBG *drbg, unsigned char *out, size_t outlen,
- unsigned int strength, int prediction_resistance,
- const unsigned char *adin, size_t adinlen)
+int ossl_prov_drbg_generate(PROV_DRBG *drbg, unsigned char *out, size_t outlen,
+ unsigned int strength, int prediction_resistance,
+ const unsigned char *adin, size_t adinlen)
{
int fork_id;
int reseed_required = 0;
reseed_required = 1;
if (reseed_required || prediction_resistance) {
- if (!PROV_DRBG_reseed(drbg, prediction_resistance, NULL, 0,
- adin, adinlen)) {
+ if (!ossl_prov_drbg_reseed(drbg, prediction_resistance, NULL, 0,
+ adin, adinlen)) {
PROVerr(0, PROV_R_RESEED_ERROR);
return 0;
}
/* repair uninitialized state */
if (drbg->state == EVP_RAND_STATE_UNINITIALISED)
/* reinstantiate drbg */
- PROV_DRBG_instantiate(drbg, drbg->strength, 0, NULL, 0);
+ ossl_prov_drbg_instantiate(drbg, drbg->strength, 0, NULL, 0);
rand_pool_free(drbg->seed_pool);
drbg->seed_pool = NULL;
{
PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
- return PROV_DRBG_instantiate(drbg, strength, prediction_resistance,
- pstr, pstr_len);
+ return ossl_prov_drbg_instantiate(drbg, strength, prediction_resistance,
+ pstr, pstr_len);
}
static int drbg_ctr_reseed(PROV_DRBG *drbg,
{
PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
- return PROV_DRBG_reseed(drbg, prediction_resistance, ent, ent_len,
- adin, adin_len);
+ return ossl_prov_drbg_reseed(drbg, prediction_resistance, ent, ent_len,
+ adin, adin_len);
}
static void ctr96_inc(unsigned char *counter)
{
PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
- return PROV_DRBG_generate(drbg, out, outlen, strength,
- prediction_resistance, adin, adin_len);
+ return ossl_prov_drbg_generate(drbg, out, outlen, strength,
+ prediction_resistance, adin, adin_len);
}
static int drbg_ctr_uninstantiate(PROV_DRBG *drbg)
OPENSSL_cleanse(ctr->bltmp, sizeof(ctr->bltmp));
OPENSSL_cleanse(ctr->KX, sizeof(ctr->KX));
ctr->bltmp_pos = 0;
- return PROV_DRBG_uninstantiate(drbg);
+ return ossl_prov_drbg_uninstantiate(drbg);
}
static int drbg_ctr_uninstantiate_wrapper(void *vdrbg)
{
PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
- return PROV_DRBG_instantiate(drbg, strength, prediction_resistance,
- pstr, pstr_len);
+ return ossl_prov_drbg_instantiate(drbg, strength, prediction_resistance,
+ pstr, pstr_len);
}
/*
{
PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
- return PROV_DRBG_reseed(drbg, prediction_resistance, ent, ent_len,
- adin, adin_len);
+ return ossl_prov_drbg_reseed(drbg, prediction_resistance, ent, ent_len,
+ adin, adin_len);
}
/*
{
PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
- return PROV_DRBG_generate(drbg, out, outlen, strength,
- prediction_resistance, adin, adin_len);
+ return ossl_prov_drbg_generate(drbg, out, outlen, strength,
+ prediction_resistance, adin, adin_len);
}
static int drbg_hash_uninstantiate(PROV_DRBG *drbg)
OPENSSL_cleanse(hash->V, sizeof(hash->V));
OPENSSL_cleanse(hash->C, sizeof(hash->C));
OPENSSL_cleanse(hash->vtmp, sizeof(hash->vtmp));
- return PROV_DRBG_uninstantiate(drbg);
+ return ossl_prov_drbg_uninstantiate(drbg);
}
static int drbg_hash_uninstantiate_wrapper(void *vdrbg)
{
PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
- return PROV_DRBG_instantiate(drbg, strength, prediction_resistance,
- pstr, pstr_len);
+ return ossl_prov_drbg_instantiate(drbg, strength, prediction_resistance,
+ pstr, pstr_len);
}
/*
{
PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
- return PROV_DRBG_reseed(drbg, prediction_resistance, ent, ent_len,
- adin, adin_len);
+ return ossl_prov_drbg_reseed(drbg, prediction_resistance, ent, ent_len,
+ adin, adin_len);
}
/*
{
PROV_DRBG *drbg = (PROV_DRBG *)vdrbg;
- return PROV_DRBG_generate(drbg, out, outlen, strength,
- prediction_resistance, adin, adin_len);
+ return ossl_prov_drbg_generate(drbg, out, outlen, strength,
+ prediction_resistance, adin, adin_len);
}
static int drbg_hmac_uninstantiate(PROV_DRBG *drbg)
OPENSSL_cleanse(hmac->K, sizeof(hmac->K));
OPENSSL_cleanse(hmac->V, sizeof(hmac->V));
- return PROV_DRBG_uninstantiate(drbg);
+ return ossl_prov_drbg_uninstantiate(drbg);
}
static int drbg_hmac_uninstantiate_wrapper(void *vdrbg)
const unsigned char *adin, size_t adin_len));
void prov_rand_drbg_free(PROV_DRBG *drbg);
-int PROV_DRBG_instantiate(PROV_DRBG *drbg, unsigned int strength,
- int prediction_resistance,
- const unsigned char *pers, size_t perslen);
+int ossl_prov_drbg_instantiate(PROV_DRBG *drbg, unsigned int strength,
+ int prediction_resistance,
+ const unsigned char *pers, size_t perslen);
-int PROV_DRBG_uninstantiate(PROV_DRBG *drbg);
+int ossl_prov_drbg_uninstantiate(PROV_DRBG *drbg);
-int PROV_DRBG_reseed(PROV_DRBG *drbg, int prediction_resistance,
- const unsigned char *ent, size_t ent_len,
- const unsigned char *adin, size_t adinlen);
+int ossl_prov_drbg_reseed(PROV_DRBG *drbg, int prediction_resistance,
+ const unsigned char *ent, size_t ent_len,
+ const unsigned char *adin, size_t adinlen);
-int PROV_DRBG_generate(PROV_DRBG *drbg, unsigned char *out, size_t outlen,
- unsigned int strength, int prediction_resistance,
- const unsigned char *adin, size_t adinlen);
+int ossl_prov_drbg_generate(PROV_DRBG *drbg, unsigned char *out, size_t outlen,
+ unsigned int strength, int prediction_resistance,
+ const unsigned char *adin, size_t adinlen);
/* Verify that an array of numeric values is all zero */
#define PROV_DRBG_VERYIFY_ZEROIZATION(v) \
if (pstr != NULL && pstr_len >= drbg->max_perslen)
return 0;
- return PROV_DRBG_instantiate(drbg, strength, prediction_resistance,
- pstr, pstr_len);
+ return ossl_prov_drbg_instantiate(drbg, strength, prediction_resistance,
+ pstr, pstr_len);
}
static int test_rng_uninstantiate(PROV_DRBG *drbg)
PROV_TEST_RNG *t = (PROV_TEST_RNG *)drbg->data;
t->entropy_pos = 0;
- return PROV_DRBG_uninstantiate(drbg);
+ return ossl_prov_drbg_uninstantiate(drbg);
}
static int test_rng_uninstantiate_wrapper(void *vdrbg)
static int file_setup_decoders(struct file_ctx_st *ctx)
{
EVP_PKEY *dummy; /* for OSSL_DECODER_CTX_new_by_EVP_PKEY() */
- OPENSSL_CTX *libctx = PROV_CTX_get0_library_context(ctx->provctx);
+ OPENSSL_CTX *libctx = ossl_prov_ctx_get0_library_context(ctx->provctx);
OSSL_DECODER *to_obj = NULL; /* Last resort decoder */
OSSL_DECODER_INSTANCE *to_obj_inst = NULL;
OSSL_DECODER_CLEANUP *old_cleanup = NULL;
static void legacy_teardown(void *provctx)
{
OPENSSL_CTX_free(PROV_LIBRARY_CONTEXT_OF(provctx));
- PROV_CTX_free(provctx);
+ ossl_prov_ctx_free(provctx);
}
/* Functions we provide to the core */
if (c_get_libctx == NULL)
return 0;
- if ((*provctx = PROV_CTX_new()) == NULL
+ if ((*provctx = ossl_prov_ctx_new()) == NULL
|| (libctx = OPENSSL_CTX_new()) == NULL) {
OPENSSL_CTX_free(libctx);
legacy_teardown(*provctx);
*provctx = NULL;
return 0;
}
- PROV_CTX_set0_library_context(*provctx, libctx);
- PROV_CTX_set0_handle(*provctx, handle);
+ ossl_prov_ctx_set0_library_context(*provctx, libctx);
+ ossl_prov_ctx_set0_handle(*provctx, handle);
*out = legacy_dispatch_table;
projects / openssl.git / commitdiff