#include "internal/nelem.h"
#include "internal/sizes.h"
#include "internal/cryptlib.h"
-#include "prov/providercommonerr.h"
+#include "prov/providercommon.h"
#include "prov/implementations.h"
#include "prov/providercommonerr.h"
#include "prov/provider_ctx.h"
static void *dsa_newctx(void *provctx, const char *propq)
{
- PROV_DSA_CTX *pdsactx = OPENSSL_zalloc(sizeof(PROV_DSA_CTX));
+ PROV_DSA_CTX *pdsactx;
+
+ if (!ossl_prov_is_running())
+ return NULL;
+ pdsactx = OPENSSL_zalloc(sizeof(PROV_DSA_CTX));
if (pdsactx == NULL)
return NULL;
{
PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
- if (pdsactx == NULL || vdsa == NULL || !DSA_up_ref(vdsa))
+ if (!ossl_prov_is_running()
+ || pdsactx == NULL
+ || vdsa == NULL
+ || !DSA_up_ref(vdsa))
return 0;
DSA_free(pdsactx->dsa);
pdsactx->dsa = vdsa;
size_t dsasize = DSA_size(pdsactx->dsa);
size_t mdsize = dsa_get_md_size(pdsactx);
+ if (!ossl_prov_is_running())
+ return 0;
+
if (sig == NULL) {
*siglen = dsasize;
return 1;
PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
size_t mdsize = dsa_get_md_size(pdsactx);
- if (mdsize != 0 && tbslen != mdsize)
+ if (!ossl_prov_is_running() || (mdsize != 0 && tbslen != mdsize))
return 0;
return DSA_verify(0, tbs, tbslen, sig, siglen, pdsactx->dsa);
{
PROV_DSA_CTX *pdsactx = (PROV_DSA_CTX *)vpdsactx;
+ if (!ossl_prov_is_running())
+ return 0;
+
pdsactx->flag_allow_md = 0;
if (!dsa_signature_init(vpdsactx, vdsa))
return 0;
unsigned char digest[EVP_MAX_MD_SIZE];
unsigned int dlen = 0;
- if (pdsactx == NULL || pdsactx->mdctx == NULL)
+ if (!ossl_prov_is_running() || pdsactx == NULL || pdsactx->mdctx == NULL)
return 0;
/*
unsigned char digest[EVP_MAX_MD_SIZE];
unsigned int dlen = 0;
- if (pdsactx == NULL || pdsactx->mdctx == NULL)
+ if (!ossl_prov_is_running() || pdsactx == NULL || pdsactx->mdctx == NULL)
return 0;
/*
PROV_DSA_CTX *srcctx = (PROV_DSA_CTX *)vpdsactx;
PROV_DSA_CTX *dstctx;
+ if (!ossl_prov_is_running())
+ return NULL;
+
dstctx = OPENSSL_zalloc(sizeof(*srcctx));
if (dstctx == NULL)
return NULL;
#include "internal/nelem.h"
#include "internal/sizes.h"
#include "internal/cryptlib.h"
+#include "prov/providercommon.h"
#include "prov/providercommonerr.h"
#include "prov/implementations.h"
#include "prov/provider_ctx.h"
static void *ecdsa_newctx(void *provctx, const char *propq)
{
- PROV_ECDSA_CTX *ctx = OPENSSL_zalloc(sizeof(PROV_ECDSA_CTX));
+ PROV_ECDSA_CTX *ctx;
+ if (!ossl_prov_is_running())
+ return NULL;
+
+ ctx = OPENSSL_zalloc(sizeof(PROV_ECDSA_CTX));
if (ctx == NULL)
return NULL;
{
PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
- if (ctx == NULL || ec == NULL || !EC_KEY_up_ref(ec))
+ if (!ossl_prov_is_running()
+ || ctx == NULL
+ || ec == NULL
+ || !EC_KEY_up_ref(ec))
return 0;
EC_KEY_free(ctx->ec);
ctx->ec = ec;
unsigned int sltmp;
size_t ecsize = ECDSA_size(ctx->ec);
+ if (!ossl_prov_is_running())
+ return 0;
+
if (sig == NULL) {
*siglen = ecsize;
return 1;
{
PROV_ECDSA_CTX *ctx = (PROV_ECDSA_CTX *)vctx;
- if (ctx->mdsize != 0 && tbslen != ctx->mdsize)
+ if (!ossl_prov_is_running() || (ctx->mdsize != 0 && tbslen != ctx->mdsize))
return 0;
return ECDSA_verify(0, tbs, tbslen, sig, siglen, ctx->ec);
int md_nid = NID_undef;
WPACKET pkt;
+ if (!ossl_prov_is_running())
+ return 0;
+
free_md(ctx);
if (!ecdsa_signature_init(vctx, ec))
unsigned char digest[EVP_MAX_MD_SIZE];
unsigned int dlen = 0;
- if (ctx == NULL || ctx->mdctx == NULL)
+ if (!ossl_prov_is_running() || ctx == NULL || ctx->mdctx == NULL)
return 0;
/*
unsigned char digest[EVP_MAX_MD_SIZE];
unsigned int dlen = 0;
- if (ctx == NULL || ctx->mdctx == NULL)
+ if (!ossl_prov_is_running() || ctx == NULL || ctx->mdctx == NULL)
return 0;
/*
PROV_ECDSA_CTX *srcctx = (PROV_ECDSA_CTX *)vctx;
PROV_ECDSA_CTX *dstctx;
+ if (!ossl_prov_is_running())
+ return NULL;
+
dstctx = OPENSSL_zalloc(sizeof(*srcctx));
if (dstctx == NULL)
return NULL;
#include <openssl/err.h>
#include "internal/nelem.h"
#include "internal/sizes.h"
-#include "prov/providercommonerr.h"
+#include "prov/providercommon.h"
#include "prov/implementations.h"
#include "prov/providercommonerr.h"
#include "prov/provider_ctx.h"
static void *eddsa_newctx(void *provctx, const char *propq_unused)
{
- PROV_EDDSA_CTX *peddsactx = OPENSSL_zalloc(sizeof(PROV_EDDSA_CTX));
+ PROV_EDDSA_CTX *peddsactx;
+
+ if (!ossl_prov_is_running())
+ return NULL;
+ peddsactx = OPENSSL_zalloc(sizeof(PROV_EDDSA_CTX));
if (peddsactx == NULL) {
PROVerr(0, ERR_R_MALLOC_FAILURE);
return NULL;
PROV_EDDSA_CTX *peddsactx = (PROV_EDDSA_CTX *)vpeddsactx;
ECX_KEY *edkey = (ECX_KEY *)vedkey;
+ if (!ossl_prov_is_running())
+ return 0;
+
if (mdname != NULL && mdname[0] != '\0') {
PROVerr(0, PROV_R_INVALID_DIGEST);
return 0;
PROV_EDDSA_CTX *peddsactx = (PROV_EDDSA_CTX *)vpeddsactx;
const ECX_KEY *edkey = peddsactx->key;
+ if (!ossl_prov_is_running())
+ return 0;
+
if (sigret == NULL) {
*siglen = ED25519_SIGSIZE;
return 1;
PROV_EDDSA_CTX *peddsactx = (PROV_EDDSA_CTX *)vpeddsactx;
const ECX_KEY *edkey = peddsactx->key;
+ if (!ossl_prov_is_running())
+ return 0;
+
if (sigret == NULL) {
*siglen = ED448_SIGSIZE;
return 1;
PROV_EDDSA_CTX *peddsactx = (PROV_EDDSA_CTX *)vpeddsactx;
const ECX_KEY *edkey = peddsactx->key;
- if (siglen != ED25519_SIGSIZE)
+ if (!ossl_prov_is_running() || siglen != ED25519_SIGSIZE)
return 0;
return ED25519_verify(tbs, tbslen, sig, edkey->pubkey, peddsactx->libctx,
PROV_EDDSA_CTX *peddsactx = (PROV_EDDSA_CTX *)vpeddsactx;
const ECX_KEY *edkey = peddsactx->key;
- if (siglen != ED448_SIGSIZE)
+ if (!ossl_prov_is_running() || siglen != ED448_SIGSIZE)
return 0;
return ED448_verify(peddsactx->libctx, tbs, tbslen, sig, edkey->pubkey,
PROV_EDDSA_CTX *srcctx = (PROV_EDDSA_CTX *)vpeddsactx;
PROV_EDDSA_CTX *dstctx;
+ if (!ossl_prov_is_running())
+ return NULL;
+
dstctx = OPENSSL_zalloc(sizeof(*srcctx));
if (dstctx == NULL)
return NULL;
#include "prov/implementations.h"
#include "prov/provider_ctx.h"
#include "prov/macsignature.h"
+#include "prov/providercommon.h"
static OSSL_FUNC_signature_newctx_fn mac_hmac_newctx;
static OSSL_FUNC_signature_newctx_fn mac_siphash_newctx;
static void *mac_newctx(void *provctx, const char *propq, const char *macname)
{
- PROV_MAC_CTX *pmacctx = OPENSSL_zalloc(sizeof(PROV_MAC_CTX));
+ PROV_MAC_CTX *pmacctx;
EVP_MAC *mac = NULL;
+ if (!ossl_prov_is_running())
+ return NULL;
+
+ pmacctx = OPENSSL_zalloc(sizeof(PROV_MAC_CTX));
if (pmacctx == NULL)
return NULL;
PROV_MAC_CTX *pmacctx = (PROV_MAC_CTX *)vpmacctx;
const char *ciphername = NULL, *engine = NULL;
- if (pmacctx == NULL || vkey == NULL || !mac_key_up_ref(vkey))
+ if (!ossl_prov_is_running()
+ || pmacctx == NULL
+ || vkey == NULL
+ || !mac_key_up_ref(vkey))
return 0;
mac_key_free(pmacctx->key);
{
PROV_MAC_CTX *pmacctx = (PROV_MAC_CTX *)vpmacctx;
- if (pmacctx == NULL || pmacctx->macctx == NULL)
+ if (!ossl_prov_is_running() || pmacctx == NULL || pmacctx->macctx == NULL)
return 0;
return EVP_MAC_final(pmacctx->macctx, mac, maclen, macsize);
PROV_MAC_CTX *srcctx = (PROV_MAC_CTX *)vpmacctx;
PROV_MAC_CTX *dstctx;
+ if (!ossl_prov_is_running())
+ return NULL;
+
dstctx = OPENSSL_zalloc(sizeof(*srcctx));
if (dstctx == NULL)
return NULL;
#include "internal/nelem.h"
#include "internal/sizes.h"
#include "crypto/rsa.h"
+#include "prov/providercommon.h"
#include "prov/providercommonerr.h"
#include "prov/implementations.h"
#include "prov/provider_ctx.h"
PROV_RSA_CTX *prsactx = NULL;
char *propq_copy = NULL;
+ if (!ossl_prov_is_running())
+ return NULL;
+
if ((prsactx = OPENSSL_zalloc(sizeof(PROV_RSA_CTX))) == NULL
|| (propq != NULL
&& (propq_copy = OPENSSL_strdup(propq)) == NULL)) {
{
PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
+ if (!ossl_prov_is_running())
+ return 0;
+
if (prsactx == NULL || vrsa == NULL || !RSA_up_ref(vrsa))
return 0;
static int rsa_sign_init(void *vprsactx, void *vrsa)
{
+ if (!ossl_prov_is_running())
+ return 0;
return rsa_signature_init(vprsactx, vrsa, EVP_PKEY_OP_SIGN);
}
size_t rsasize = RSA_size(prsactx->rsa);
size_t mdsize = rsa_get_md_size(prsactx);
+ if (!ossl_prov_is_running())
+ return 0;
+
if (sig == NULL) {
*siglen = rsasize;
return 1;
static int rsa_verify_recover_init(void *vprsactx, void *vrsa)
{
+ if (!ossl_prov_is_running())
+ return 0;
return rsa_signature_init(vprsactx, vrsa, EVP_PKEY_OP_VERIFYRECOVER);
}
PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
int ret;
+ if (!ossl_prov_is_running())
+ return 0;
+
if (rout == NULL) {
*routlen = RSA_size(prsactx->rsa);
return 1;
static int rsa_verify_init(void *vprsactx, void *vrsa)
{
+ if (!ossl_prov_is_running())
+ return 0;
return rsa_signature_init(vprsactx, vrsa, EVP_PKEY_OP_VERIFY);
}
PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
size_t rslen;
+ if (!ossl_prov_is_running())
+ return 0;
if (prsactx->md != NULL) {
switch (prsactx->pad_mode) {
case RSA_PKCS1_PADDING:
{
PROV_RSA_CTX *prsactx = (PROV_RSA_CTX *)vprsactx;
+ if (!ossl_prov_is_running())
+ return 0;
+
if (prsactx != NULL)
prsactx->flag_allow_md = 0;
if (!rsa_signature_init(vprsactx, vrsa, operation)
static int rsa_digest_sign_init(void *vprsactx, const char *mdname,
void *vrsa)
{
+ if (!ossl_prov_is_running())
+ return 0;
return rsa_digest_signverify_init(vprsactx, mdname, vrsa,
EVP_PKEY_OP_SIGN);
}
unsigned char digest[EVP_MAX_MD_SIZE];
unsigned int dlen = 0;
- if (prsactx == NULL)
+ if (!ossl_prov_is_running() || prsactx == NULL)
return 0;
prsactx->flag_allow_md = 1;
if (prsactx->mdctx == NULL)
static int rsa_digest_verify_init(void *vprsactx, const char *mdname,
void *vrsa)
{
+ if (!ossl_prov_is_running())
+ return 0;
return rsa_digest_signverify_init(vprsactx, mdname, vrsa,
EVP_PKEY_OP_VERIFY);
}
unsigned char digest[EVP_MAX_MD_SIZE];
unsigned int dlen = 0;
+ if (!ossl_prov_is_running())
+ return 0;
+
if (prsactx == NULL)
return 0;
prsactx->flag_allow_md = 1;
PROV_RSA_CTX *srcctx = (PROV_RSA_CTX *)vprsactx;
PROV_RSA_CTX *dstctx;
+ if (!ossl_prov_is_running())
+ return NULL;
+
dstctx = OPENSSL_zalloc(sizeof(*srcctx));
if (dstctx == NULL) {
ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);