Continue standardising malloc style for libcrypto
Continuing from previous commit ensure our style is consistent for malloc return checks. Reviewed-by: Kurt Roeckx <kurt@openssl.org>master
parent
a71edf3ba2
commit
90945fa31a
|
@ -200,7 +200,7 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
|
|||
} else {
|
||||
free_out = 1;
|
||||
dest = ASN1_STRING_type_new(str_type);
|
||||
if (!dest) {
|
||||
if (dest == NULL) {
|
||||
ASN1err(ASN1_F_ASN1_MBSTRING_NCOPY, ERR_R_MALLOC_FAILURE);
|
||||
return -1;
|
||||
}
|
||||
|
|
|
@ -139,9 +139,9 @@ int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num)
|
|||
}
|
||||
if (!use_bn && l >= ((ULONG_MAX - 80) / 10L)) {
|
||||
use_bn = 1;
|
||||
if (!bl)
|
||||
if (bl == NULL)
|
||||
bl = BN_new();
|
||||
if (!bl || !BN_set_word(bl, l))
|
||||
if (bl == NULL || !BN_set_word(bl, l))
|
||||
goto err;
|
||||
}
|
||||
if (use_bn) {
|
||||
|
@ -173,7 +173,7 @@ int a2d_ASN1_OBJECT(unsigned char *out, int olen, const char *buf, int num)
|
|||
OPENSSL_free(tmp);
|
||||
tmpsize = blsize + 32;
|
||||
tmp = OPENSSL_malloc(tmpsize);
|
||||
if (!tmp)
|
||||
if (tmp == NULL)
|
||||
goto err;
|
||||
}
|
||||
while (blsize--)
|
||||
|
@ -225,7 +225,7 @@ int i2a_ASN1_OBJECT(BIO *bp, ASN1_OBJECT *a)
|
|||
i = i2t_ASN1_OBJECT(buf, sizeof buf, a);
|
||||
if (i > (int)(sizeof(buf) - 1)) {
|
||||
p = OPENSSL_malloc(i + 1);
|
||||
if (!p)
|
||||
if (p == NULL)
|
||||
return -1;
|
||||
i2t_ASN1_OBJECT(p, i + 1, a);
|
||||
}
|
||||
|
|
|
@ -305,7 +305,7 @@ static int do_dump(unsigned long lflags, char_io *io_ch, void *arg,
|
|||
t.value.ptr = (char *)str;
|
||||
der_len = i2d_ASN1_TYPE(&t, NULL);
|
||||
der_buf = OPENSSL_malloc(der_len);
|
||||
if (!der_buf)
|
||||
if (der_buf == NULL)
|
||||
return -1;
|
||||
p = der_buf;
|
||||
i2d_ASN1_TYPE(&t, &p);
|
||||
|
|
|
@ -235,16 +235,16 @@ static ASN1_STRING_TABLE *stable_get(int nid)
|
|||
{
|
||||
ASN1_STRING_TABLE *tmp, *rv;
|
||||
/* Always need a string table so allocate one if NULL */
|
||||
if (!stable) {
|
||||
if (stable == NULL) {
|
||||
stable = sk_ASN1_STRING_TABLE_new(sk_table_cmp);
|
||||
if (!stable)
|
||||
if (stable == NULL)
|
||||
return NULL;
|
||||
}
|
||||
tmp = ASN1_STRING_TABLE_get(nid);
|
||||
if (tmp && tmp->flags & STABLE_FLAGS_MALLOC)
|
||||
return tmp;
|
||||
rv = OPENSSL_malloc(sizeof(*rv));
|
||||
if (!rv)
|
||||
if (rv == NULL)
|
||||
return NULL;
|
||||
if (!sk_ASN1_STRING_TABLE_push(stable, rv)) {
|
||||
OPENSSL_free(rv);
|
||||
|
|
|
@ -224,7 +224,7 @@ int EVP_PKEY_asn1_add0(const EVP_PKEY_ASN1_METHOD *ameth)
|
|||
{
|
||||
if (app_methods == NULL) {
|
||||
app_methods = sk_EVP_PKEY_ASN1_METHOD_new(ameth_cmp);
|
||||
if (!app_methods)
|
||||
if (app_methods == NULL)
|
||||
return 0;
|
||||
}
|
||||
if (!sk_EVP_PKEY_ASN1_METHOD_push(app_methods, ameth))
|
||||
|
@ -237,7 +237,7 @@ int EVP_PKEY_asn1_add_alias(int to, int from)
|
|||
{
|
||||
EVP_PKEY_ASN1_METHOD *ameth;
|
||||
ameth = EVP_PKEY_asn1_new(from, ASN1_PKEY_ALIAS, NULL, NULL);
|
||||
if (!ameth)
|
||||
if (ameth == NULL)
|
||||
return 0;
|
||||
ameth->pkey_base_id = to;
|
||||
if (!EVP_PKEY_asn1_add0(ameth)) {
|
||||
|
@ -277,7 +277,7 @@ EVP_PKEY_ASN1_METHOD *EVP_PKEY_asn1_new(int id, int flags,
|
|||
{
|
||||
EVP_PKEY_ASN1_METHOD *ameth = OPENSSL_zalloc(sizeof(*ameth));
|
||||
|
||||
if (!ameth)
|
||||
if (ameth == NULL)
|
||||
return NULL;
|
||||
|
||||
ameth->pkey_id = id;
|
||||
|
|
|
@ -243,7 +243,7 @@ static ASN1_TYPE *generate_v3(char *str, X509V3_CTX *cnf, int depth,
|
|||
/* Allocate buffer for new encoding */
|
||||
|
||||
new_der = OPENSSL_malloc(len);
|
||||
if (!new_der)
|
||||
if (new_der == NULL)
|
||||
goto err;
|
||||
|
||||
/* Generate tagged encoding */
|
||||
|
|
|
@ -296,7 +296,7 @@ ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *str)
|
|||
if (!str)
|
||||
return NULL;
|
||||
ret = ASN1_STRING_new();
|
||||
if (!ret)
|
||||
if (ret == NULL)
|
||||
return NULL;
|
||||
if (!ASN1_STRING_copy(ret, str)) {
|
||||
ASN1_STRING_free(ret);
|
||||
|
|
|
@ -149,7 +149,7 @@ static int B64_write_ASN1(BIO *out, ASN1_VALUE *val, BIO *in, int flags,
|
|||
BIO *b64;
|
||||
int r;
|
||||
b64 = BIO_new(BIO_f_base64());
|
||||
if (!b64) {
|
||||
if (b64 == NULL) {
|
||||
ASN1err(ASN1_F_B64_WRITE_ASN1, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
|
@ -533,7 +533,7 @@ int SMIME_crlf_copy(BIO *in, BIO *out, int flags)
|
|||
* when streaming as we don't end up with one OCTET STRING per line.
|
||||
*/
|
||||
bf = BIO_new(BIO_f_buffer());
|
||||
if (!bf)
|
||||
if (bf == NULL)
|
||||
return 0;
|
||||
out = BIO_push(bf, out);
|
||||
if (flags & SMIME_BINARY) {
|
||||
|
@ -678,7 +678,7 @@ static STACK_OF(MIME_HEADER) *mime_parse_hdr(BIO *bio)
|
|||
int len, state, save_state = 0;
|
||||
|
||||
headers = sk_MIME_HEADER_new(mime_hdr_cmp);
|
||||
if (!headers)
|
||||
if (headers == NULL)
|
||||
return NULL;
|
||||
while ((len = BIO_gets(bio, linebuf, MAX_SMLEN)) > 0) {
|
||||
/* If whitespace at line start then continuation line */
|
||||
|
@ -850,7 +850,7 @@ static MIME_HEADER *mime_hdr_new(char *name, char *value)
|
|||
}
|
||||
}
|
||||
mhdr = OPENSSL_malloc(sizeof(*mhdr));
|
||||
if (!mhdr)
|
||||
if (mhdr == NULL)
|
||||
goto err;
|
||||
mhdr->name = tmpname;
|
||||
mhdr->value = tmpval;
|
||||
|
@ -889,7 +889,7 @@ static int mime_hdr_addparam(MIME_HEADER *mhdr, char *name, char *value)
|
|||
}
|
||||
/* Parameter values are case sensitive so leave as is */
|
||||
mparam = OPENSSL_malloc(sizeof(*mparam));
|
||||
if (!mparam)
|
||||
if (mparam == NULL)
|
||||
goto err;
|
||||
mparam->param_name = tmpname;
|
||||
mparam->param_value = tmpval;
|
||||
|
|
|
@ -147,7 +147,7 @@ static int asn1_bio_new(BIO *b)
|
|||
{
|
||||
BIO_ASN1_BUF_CTX *ctx;
|
||||
ctx = OPENSSL_malloc(sizeof(*ctx));
|
||||
if (!ctx)
|
||||
if (ctx == NULL)
|
||||
return 0;
|
||||
if (!asn1_bio_init(ctx, DEFAULT_ASN1_BUF_SIZE)) {
|
||||
OPENSSL_free(ctx);
|
||||
|
@ -162,7 +162,7 @@ static int asn1_bio_new(BIO *b)
|
|||
static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size)
|
||||
{
|
||||
ctx->buf = OPENSSL_malloc(size);
|
||||
if (!ctx->buf)
|
||||
if (ctx->buf == NULL)
|
||||
return 0;
|
||||
ctx->bufsize = size;
|
||||
ctx->bufpos = 0;
|
||||
|
|
|
@ -113,7 +113,7 @@ BIO *BIO_new_NDEF(BIO *out, ASN1_VALUE *val, const ASN1_ITEM *it)
|
|||
|
||||
out = BIO_push(asn_bio, out);
|
||||
|
||||
if (!ndef_aux || !asn_bio || !out)
|
||||
if (ndef_aux == NULL || asn_bio == NULL || !out)
|
||||
goto err;
|
||||
|
||||
BIO_asn1_set_prefix(asn_bio, ndef_prefix, ndef_prefix_free);
|
||||
|
@ -160,7 +160,7 @@ static int ndef_prefix(BIO *b, unsigned char **pbuf, int *plen, void *parg)
|
|||
|
||||
derlen = ASN1_item_ndef_i2d(ndef_aux->val, NULL, ndef_aux->it);
|
||||
p = OPENSSL_malloc(derlen);
|
||||
if (!p)
|
||||
if (p == NULL)
|
||||
return 0;
|
||||
|
||||
ndef_aux->derbuf = p;
|
||||
|
@ -229,7 +229,7 @@ static int ndef_suffix(BIO *b, unsigned char **pbuf, int *plen, void *parg)
|
|||
|
||||
derlen = ASN1_item_ndef_i2d(ndef_aux->val, NULL, ndef_aux->it);
|
||||
p = OPENSSL_malloc(derlen);
|
||||
if (!p)
|
||||
if (p == NULL)
|
||||
return 0;
|
||||
|
||||
ndef_aux->derbuf = p;
|
||||
|
|
|
@ -82,7 +82,7 @@ int PKCS5_pbe_set0_algor(X509_ALGOR *algor, int alg, int iter,
|
|||
unsigned char *sstr;
|
||||
|
||||
pbe = PBEPARAM_new();
|
||||
if (!pbe) {
|
||||
if (pbe == NULL) {
|
||||
ASN1err(ASN1_F_PKCS5_PBE_SET0_ALGOR, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
@ -128,7 +128,7 @@ X509_ALGOR *PKCS5_pbe_set(int alg, int iter,
|
|||
{
|
||||
X509_ALGOR *ret;
|
||||
ret = X509_ALGOR_new();
|
||||
if (!ret) {
|
||||
if (ret == NULL) {
|
||||
ASN1err(ASN1_F_PKCS5_PBE_SET, ERR_R_MALLOC_FAILURE);
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
@ -242,7 +242,7 @@ X509_ALGOR *PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen,
|
|||
/* prf can stay NULL if we are using hmacWithSHA1 */
|
||||
if (prf_nid > 0 && prf_nid != NID_hmacWithSHA1) {
|
||||
kdf->prf = X509_ALGOR_new();
|
||||
if (!kdf->prf)
|
||||
if (kdf->prf == NULL)
|
||||
goto merr;
|
||||
X509_ALGOR_set0(kdf->prf, OBJ_nid2obj(prf_nid), V_ASN1_NULL, NULL);
|
||||
}
|
||||
|
@ -250,7 +250,7 @@ X509_ALGOR *PKCS5_pbkdf2_set(int iter, unsigned char *salt, int saltlen,
|
|||
/* Finally setup the keyfunc structure */
|
||||
|
||||
keyfunc = X509_ALGOR_new();
|
||||
if (!keyfunc)
|
||||
if (keyfunc == NULL)
|
||||
goto merr;
|
||||
|
||||
keyfunc->algorithm = OBJ_nid2obj(NID_id_pbkdf2);
|
||||
|
|
|
@ -247,7 +247,7 @@ static X509_ALGOR *pkcs5_scrypt_set(const unsigned char *salt, size_t saltlen,
|
|||
/* Finally setup the keyfunc structure */
|
||||
|
||||
keyfunc = X509_ALGOR_new();
|
||||
if (!keyfunc)
|
||||
if (keyfunc == NULL)
|
||||
goto merr;
|
||||
|
||||
keyfunc->algorithm = OBJ_nid2obj(NID_id_scrypt);
|
||||
|
|
|
@ -99,7 +99,7 @@ int PKCS8_pkey_set0(PKCS8_PRIV_KEY_INFO *priv, ASN1_OBJECT *aobj,
|
|||
int pmtype;
|
||||
ASN1_OCTET_STRING *oct;
|
||||
oct = ASN1_OCTET_STRING_new();
|
||||
if (!oct)
|
||||
if (oct == NULL)
|
||||
return 0;
|
||||
oct->data = penc;
|
||||
ppenc = &oct->data;
|
||||
|
|
|
@ -893,7 +893,7 @@ static int asn1_ex_c2i(ASN1_VALUE **pval, const unsigned char *cont, int len,
|
|||
/* All based on ASN1_STRING and handled the same */
|
||||
if (!*pval) {
|
||||
stmp = ASN1_STRING_type_new(utype);
|
||||
if (!stmp) {
|
||||
if (stmp == NULL) {
|
||||
ASN1err(ASN1_F_ASN1_EX_C2I, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
|
|
@ -111,7 +111,7 @@ static int asn1_item_flags_i2d(ASN1_VALUE *val, unsigned char **out,
|
|||
if (len <= 0)
|
||||
return len;
|
||||
buf = OPENSSL_malloc(len);
|
||||
if (!buf)
|
||||
if (buf == NULL)
|
||||
return -1;
|
||||
p = buf;
|
||||
ASN1_item_ex_i2d(&val, &p, it, -1, flags);
|
||||
|
@ -423,10 +423,10 @@ static int asn1_set_seq_out(STACK_OF(ASN1_VALUE) *sk, unsigned char **out,
|
|||
else {
|
||||
derlst = OPENSSL_malloc(sk_ASN1_VALUE_num(sk)
|
||||
* sizeof(*derlst));
|
||||
if (!derlst)
|
||||
if (derlst == NULL)
|
||||
return 0;
|
||||
tmpdat = OPENSSL_malloc(skcontlen);
|
||||
if (!tmpdat) {
|
||||
if (tmpdat == NULL) {
|
||||
OPENSSL_free(derlst);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -147,7 +147,7 @@ int asn1_item_embed_new(ASN1_VALUE **pval, const ASN1_ITEM *it, int embed)
|
|||
memset(*pval, 0, it->size);
|
||||
} else {
|
||||
*pval = OPENSSL_zalloc(it->size);
|
||||
if (!*pval)
|
||||
if (*pval == NULL)
|
||||
goto memerr;
|
||||
}
|
||||
asn1_set_choice_selector(pval, -1, it);
|
||||
|
@ -173,7 +173,7 @@ int asn1_item_embed_new(ASN1_VALUE **pval, const ASN1_ITEM *it, int embed)
|
|||
memset(*pval, 0, it->size);
|
||||
} else {
|
||||
*pval = OPENSSL_zalloc(it->size);
|
||||
if (!*pval)
|
||||
if (*pval == NULL)
|
||||
goto memerr;
|
||||
}
|
||||
asn1_do_lock(pval, 0, it);
|
||||
|
@ -341,7 +341,7 @@ static int asn1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it,
|
|||
|
||||
case V_ASN1_ANY:
|
||||
typ = OPENSSL_malloc(sizeof(*typ));
|
||||
if (!typ)
|
||||
if (typ == NULL)
|
||||
return 0;
|
||||
typ->value.ptr = NULL;
|
||||
typ->type = -1;
|
||||
|
|
|
@ -172,7 +172,7 @@ int asn1_enc_save(ASN1_VALUE **pval, const unsigned char *in, int inlen,
|
|||
|
||||
OPENSSL_free(enc->enc);
|
||||
enc->enc = OPENSSL_malloc(inlen);
|
||||
if (!enc->enc)
|
||||
if (enc->enc == NULL)
|
||||
return 0;
|
||||
memcpy(enc->enc, in, inlen);
|
||||
enc->len = inlen;
|
||||
|
|
|
@ -111,7 +111,7 @@ ASN1_ITEM_end(CBIGNUM)
|
|||
static int bn_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
|
||||
{
|
||||
*pval = (ASN1_VALUE *)BN_new();
|
||||
if (*pval)
|
||||
if (*pval != NULL)
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
|
@ -120,7 +120,7 @@ static int bn_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
|
|||
static int bn_secure_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
|
||||
{
|
||||
*pval = (ASN1_VALUE *)BN_secure_new();
|
||||
if (*pval)
|
||||
if (*pval != NULL)
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
|
|
|
@ -67,13 +67,13 @@ X509_PKEY *X509_PKEY_new(void)
|
|||
X509_PKEY *ret = NULL;
|
||||
|
||||
ret = OPENSSL_zalloc(sizeof(*ret));
|
||||
if (!ret)
|
||||
if (ret == NULL)
|
||||
goto err;
|
||||
|
||||
ret->references = 1;
|
||||
ret->enc_algor = X509_ALGOR_new();
|
||||
ret->enc_pkey = ASN1_OCTET_STRING_new();
|
||||
if (!ret->enc_algor || !ret->enc_pkey)
|
||||
if (ret->enc_algor == NULL || ret->enc_pkey == NULL)
|
||||
goto err;
|
||||
|
||||
return ret;
|
||||
|
|
|
@ -246,7 +246,7 @@ int i2d_RSA_PUBKEY(RSA *a, unsigned char **pp)
|
|||
if (!a)
|
||||
return 0;
|
||||
pktmp = EVP_PKEY_new();
|
||||
if (!pktmp) {
|
||||
if (pktmp == NULL) {
|
||||
ASN1err(ASN1_F_I2D_RSA_PUBKEY, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
|
@ -286,7 +286,7 @@ int i2d_DSA_PUBKEY(DSA *a, unsigned char **pp)
|
|||
if (!a)
|
||||
return 0;
|
||||
pktmp = EVP_PKEY_new();
|
||||
if (!pktmp) {
|
||||
if (pktmp == NULL) {
|
||||
ASN1err(ASN1_F_I2D_DSA_PUBKEY, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -711,7 +711,7 @@ doapr_outch(char **sbuffer,
|
|||
*maxlen += 1024;
|
||||
if (*buffer == NULL) {
|
||||
*buffer = OPENSSL_malloc(*maxlen);
|
||||
if (!*buffer) {
|
||||
if (*buffer == NULL) {
|
||||
/* Panic! Can't really do anything sensible. Just return */
|
||||
return;
|
||||
}
|
||||
|
|
|
@ -997,7 +997,7 @@ BIO *BIO_new_dgram_sctp(int fd, int close_flag)
|
|||
*/
|
||||
sockopt_len = (socklen_t) (sizeof(sctp_assoc_t) + 256 * sizeof(uint8_t));
|
||||
authchunks = OPENSSL_zalloc(sockopt_len);
|
||||
if (!authchunks) {
|
||||
if (authchunks == NULL) {
|
||||
BIO_vfree(bio);
|
||||
return (NULL);
|
||||
}
|
||||
|
@ -1334,7 +1334,7 @@ static int dgram_sctp_read(BIO *b, char *out, int outl)
|
|||
optlen =
|
||||
(socklen_t) (sizeof(sctp_assoc_t) + 256 * sizeof(uint8_t));
|
||||
authchunks = OPENSSL_malloc(optlen);
|
||||
if (!authchunks) {
|
||||
if (authchunks == NULL) {
|
||||
BIOerr(BIO_F_DGRAM_SCTP_READ, ERR_R_MALLOC_FAILURE);
|
||||
return -1;
|
||||
}
|
||||
|
|
|
@ -204,7 +204,7 @@ BN_CTX *BN_CTX_secure_new(void)
|
|||
{
|
||||
BN_CTX *ret = BN_CTX_new();
|
||||
|
||||
if (ret)
|
||||
if (ret != NULL)
|
||||
ret->flags = BN_FLG_SECURE;
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -74,7 +74,7 @@ signed char *bn_compute_wNAF(const BIGNUM *scalar, int w, size_t *ret_len)
|
|||
|
||||
if (BN_is_zero(scalar)) {
|
||||
r = OPENSSL_malloc(1);
|
||||
if (!r) {
|
||||
if (r == NULL) {
|
||||
BNerr(BN_F_BN_COMPUTE_WNAF, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
|
|
@ -287,7 +287,7 @@ BIGNUM *BN_new(void)
|
|||
BIGNUM *BN_secure_new(void)
|
||||
{
|
||||
BIGNUM *ret = BN_new();
|
||||
if (ret)
|
||||
if (ret != NULL)
|
||||
ret->flags |= BN_FLG_SECURE;
|
||||
return (ret);
|
||||
}
|
||||
|
|
|
@ -517,7 +517,7 @@ BN_MONT_CTX *BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, int lock,
|
|||
* (the losers throw away the work they've done).
|
||||
*/
|
||||
ret = BN_MONT_CTX_new();
|
||||
if (!ret)
|
||||
if (ret == NULL)
|
||||
return NULL;
|
||||
if (!BN_MONT_CTX_set(ret, mod, ctx)) {
|
||||
BN_MONT_CTX_free(ret);
|
||||
|
|
|
@ -315,7 +315,7 @@ int BN_generate_dsa_nonce(BIGNUM *out, const BIGNUM *range,
|
|||
int ret = 0;
|
||||
|
||||
k_bytes = OPENSSL_malloc(num_k_bytes);
|
||||
if (!k_bytes)
|
||||
if (k_bytes == NULL)
|
||||
goto err;
|
||||
|
||||
/* We copy |priv| into a local buffer to avoid exposing its length. */
|
||||
|
|
|
@ -64,7 +64,7 @@
|
|||
static int pkey_cmac_init(EVP_PKEY_CTX *ctx)
|
||||
{
|
||||
ctx->data = CMAC_CTX_new();
|
||||
if (!ctx->data)
|
||||
if (ctx->data == NULL)
|
||||
return 0;
|
||||
ctx->keygen_info_count = 0;
|
||||
return 1;
|
||||
|
@ -88,7 +88,7 @@ static int pkey_cmac_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
|
|||
{
|
||||
CMAC_CTX *cmkey = CMAC_CTX_new();
|
||||
CMAC_CTX *cmctx = ctx->data;
|
||||
if (!cmkey)
|
||||
if (cmkey == NULL)
|
||||
return 0;
|
||||
if (!CMAC_CTX_copy(cmkey, cmctx)) {
|
||||
CMAC_CTX_free(cmkey);
|
||||
|
|
|
@ -92,7 +92,7 @@ CMAC_CTX *CMAC_CTX_new(void)
|
|||
CMAC_CTX *ctx;
|
||||
|
||||
ctx = OPENSSL_malloc(sizeof(*ctx));
|
||||
if (!ctx)
|
||||
if (ctx == NULL)
|
||||
return NULL;
|
||||
EVP_CIPHER_CTX_init(&ctx->cctx);
|
||||
ctx->nlast_block = -1;
|
||||
|
|
|
@ -82,12 +82,12 @@ CMS_ContentInfo *cms_CompressedData_create(int comp_nid)
|
|||
return NULL;
|
||||
}
|
||||
cms = CMS_ContentInfo_new();
|
||||
if (!cms)
|
||||
if (cms == NULL)
|
||||
return NULL;
|
||||
|
||||
cd = M_ASN1_new_of(CMS_CompressedData);
|
||||
|
||||
if (!cd)
|
||||
if (cd == NULL)
|
||||
goto err;
|
||||
|
||||
cms->contentType = OBJ_nid2obj(NID_id_smime_ct_compressedData);
|
||||
|
|
|
@ -67,12 +67,12 @@ CMS_ContentInfo *cms_DigestedData_create(const EVP_MD *md)
|
|||
CMS_ContentInfo *cms;
|
||||
CMS_DigestedData *dd;
|
||||
cms = CMS_ContentInfo_new();
|
||||
if (!cms)
|
||||
if (cms == NULL)
|
||||
return NULL;
|
||||
|
||||
dd = M_ASN1_new_of(CMS_DigestedData);
|
||||
|
||||
if (!dd)
|
||||
if (dd == NULL)
|
||||
goto err;
|
||||
|
||||
cms->contentType = OBJ_nid2obj(NID_pkcs7_digest);
|
||||
|
|
|
@ -82,7 +82,7 @@ BIO *cms_EncryptedContent_init_bio(CMS_EncryptedContentInfo *ec)
|
|||
enc = ec->cipher ? 1 : 0;
|
||||
|
||||
b = BIO_new(BIO_f_cipher());
|
||||
if (!b) {
|
||||
if (b == NULL) {
|
||||
CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, ERR_R_MALLOC_FAILURE);
|
||||
return NULL;
|
||||
}
|
||||
|
@ -130,7 +130,7 @@ BIO *cms_EncryptedContent_init_bio(CMS_EncryptedContentInfo *ec)
|
|||
/* Generate random session key */
|
||||
if (!enc || !ec->key) {
|
||||
tkey = OPENSSL_malloc(tkeylen);
|
||||
if (!tkey) {
|
||||
if (tkey == NULL) {
|
||||
CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
@ -179,7 +179,7 @@ BIO *cms_EncryptedContent_init_bio(CMS_EncryptedContentInfo *ec)
|
|||
|
||||
if (piv) {
|
||||
calg->parameter = ASN1_TYPE_new();
|
||||
if (!calg->parameter) {
|
||||
if (calg->parameter == NULL) {
|
||||
CMSerr(CMS_F_CMS_ENCRYPTEDCONTENT_INIT_BIO, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
@ -210,7 +210,7 @@ int cms_EncryptedContent_init(CMS_EncryptedContentInfo *ec,
|
|||
ec->cipher = cipher;
|
||||
if (key) {
|
||||
ec->key = OPENSSL_malloc(keylen);
|
||||
if (!ec->key)
|
||||
if (ec->key == NULL)
|
||||
return 0;
|
||||
memcpy(ec->key, key, keylen);
|
||||
}
|
||||
|
|
|
@ -153,10 +153,10 @@ CMS_ContentInfo *CMS_EnvelopedData_create(const EVP_CIPHER *cipher)
|
|||
CMS_ContentInfo *cms;
|
||||
CMS_EnvelopedData *env;
|
||||
cms = CMS_ContentInfo_new();
|
||||
if (!cms)
|
||||
if (cms == NULL)
|
||||
goto merr;
|
||||
env = cms_enveloped_data_init(cms);
|
||||
if (!env)
|
||||
if (env == NULL)
|
||||
goto merr;
|
||||
if (!cms_EncryptedContent_init(env->encryptedContentInfo,
|
||||
cipher, NULL, 0))
|
||||
|
@ -208,7 +208,7 @@ static int cms_RecipientInfo_ktri_init(CMS_RecipientInfo *ri, X509 *recip,
|
|||
|
||||
if (flags & CMS_KEY_PARAM) {
|
||||
ktri->pctx = EVP_PKEY_CTX_new(ktri->pkey, NULL);
|
||||
if (!ktri->pctx)
|
||||
if (ktri->pctx == NULL)
|
||||
return 0;
|
||||
if (EVP_PKEY_encrypt_init(ktri->pctx) <= 0)
|
||||
return 0;
|
||||
|
@ -362,7 +362,7 @@ static int cms_RecipientInfo_ktri_encrypt(CMS_ContentInfo *cms,
|
|||
goto err;
|
||||
} else {
|
||||
pctx = EVP_PKEY_CTX_new(ktri->pkey, NULL);
|
||||
if (!pctx)
|
||||
if (pctx == NULL)
|
||||
return 0;
|
||||
|
||||
if (EVP_PKEY_encrypt_init(pctx) <= 0)
|
||||
|
@ -420,7 +420,7 @@ static int cms_RecipientInfo_ktri_decrypt(CMS_ContentInfo *cms,
|
|||
}
|
||||
|
||||
ktri->pctx = EVP_PKEY_CTX_new(pkey, NULL);
|
||||
if (!ktri->pctx)
|
||||
if (ktri->pctx == NULL)
|
||||
return 0;
|
||||
|
||||
if (EVP_PKEY_decrypt_init(ktri->pctx) <= 0)
|
||||
|
@ -685,7 +685,7 @@ static int cms_RecipientInfo_kekri_encrypt(CMS_ContentInfo *cms,
|
|||
|
||||
wkey = OPENSSL_malloc(ec->keylen + 8);
|
||||
|
||||
if (!wkey) {
|
||||
if (wkey == NULL) {
|
||||
CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_ENCRYPT, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
@ -755,7 +755,7 @@ static int cms_RecipientInfo_kekri_decrypt(CMS_ContentInfo *cms,
|
|||
|
||||
ukey = OPENSSL_malloc(kekri->encryptedKey->length - 8);
|
||||
|
||||
if (!ukey) {
|
||||
if (ukey == NULL) {
|
||||
CMSerr(CMS_F_CMS_RECIPIENTINFO_KEKRI_DECRYPT, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
|
|
@ -97,7 +97,7 @@ CMS_ReceiptRequest *CMS_ReceiptRequest_create0(unsigned char *id, int idlen,
|
|||
CMS_ReceiptRequest *rr = NULL;
|
||||
|
||||
rr = CMS_ReceiptRequest_new();
|
||||
if (!rr)
|
||||
if (rr == NULL)
|
||||
goto merr;
|
||||
if (id)
|
||||
ASN1_STRING_set0(rr->signedContentIdentifier, id, idlen);
|
||||
|
|
|
@ -63,11 +63,11 @@ int CMS_stream(unsigned char ***boundary, CMS_ContentInfo *cms)
|
|||
{
|
||||
ASN1_OCTET_STRING **pos;
|
||||
pos = CMS_get0_content(cms);
|
||||
if (!pos)
|
||||
if (pos == NULL)
|
||||
return 0;
|
||||
if (!*pos)
|
||||
if (*pos == NULL)
|
||||
*pos = ASN1_OCTET_STRING_new();
|
||||
if (*pos) {
|
||||
if (*pos != NULL) {
|
||||
(*pos)->flags |= ASN1_STRING_FLAG_NDEF;
|
||||
(*pos)->flags &= ~ASN1_STRING_FLAG_CONT;
|
||||
*boundary = &(*pos)->data;
|
||||
|
|
|
@ -252,7 +252,7 @@ static int cms_kek_cipher(unsigned char **pout, size_t *poutlen,
|
|||
if (!EVP_CipherUpdate(&kari->ctx, NULL, &outlen, in, inlen))
|
||||
goto err;
|
||||
out = OPENSSL_malloc(outlen);
|
||||
if (!out)
|
||||
if (out == NULL)
|
||||
goto err;
|
||||
if (!EVP_CipherUpdate(&kari->ctx, out, &outlen, in, inlen))
|
||||
goto err;
|
||||
|
|
|
@ -76,7 +76,7 @@ CMS_ContentInfo *cms_Data_create(void)
|
|||
{
|
||||
CMS_ContentInfo *cms;
|
||||
cms = CMS_ContentInfo_new();
|
||||
if (cms) {
|
||||
if (cms != NULL) {
|
||||
cms->contentType = OBJ_nid2obj(NID_pkcs7_data);
|
||||
/* Never detached */
|
||||
CMS_set_detached(cms, 0);
|
||||
|
@ -316,9 +316,9 @@ int CMS_set_detached(CMS_ContentInfo *cms, int detached)
|
|||
*pos = NULL;
|
||||
return 1;
|
||||
}
|
||||
if (!*pos)
|
||||
if (*pos == NULL)
|
||||
*pos = ASN1_OCTET_STRING_new();
|
||||
if (*pos) {
|
||||
if (*pos != NULL) {
|
||||
/*
|
||||
* NB: special flag to show content is created and not read in.
|
||||
*/
|
||||
|
@ -344,7 +344,7 @@ BIO *cms_DigestAlgorithm_init_bio(X509_ALGOR *digestAlgorithm)
|
|||
goto err;
|
||||
}
|
||||
mdbio = BIO_new(BIO_f_md());
|
||||
if (!mdbio || !BIO_set_md(mdbio, digest)) {
|
||||
if (mdbio == NULL || !BIO_set_md(mdbio, digest)) {
|
||||
CMSerr(CMS_F_CMS_DIGESTALGORITHM_INIT_BIO, CMS_R_MD_BIO_INIT_ERROR);
|
||||
goto err;
|
||||
}
|
||||
|
|
|
@ -121,6 +121,9 @@ CMS_RecipientInfo *CMS_add0_recipient_password(CMS_ContentInfo *cms,
|
|||
|
||||
/* Setup algorithm identifier for cipher */
|
||||
encalg = X509_ALGOR_new();
|
||||
if (encalg == NULL) {
|
||||
goto merr;
|
||||
}
|
||||
EVP_CIPHER_CTX_init(&ctx);
|
||||
|
||||
if (EVP_EncryptInit_ex(&ctx, kekciph, NULL, NULL, NULL) <= 0) {
|
||||
|
@ -155,11 +158,11 @@ CMS_RecipientInfo *CMS_add0_recipient_password(CMS_ContentInfo *cms,
|
|||
|
||||
/* Initialize recipient info */
|
||||
ri = M_ASN1_new_of(CMS_RecipientInfo);
|
||||
if (!ri)
|
||||
if (ri == NULL)
|
||||
goto merr;
|
||||
|
||||
ri->d.pwri = M_ASN1_new_of(CMS_PasswordRecipientInfo);
|
||||
if (!ri->d.pwri)
|
||||
if (ri->d.pwri == NULL)
|
||||
goto merr;
|
||||
ri->type = CMS_RECIPINFO_PASS;
|
||||
|
||||
|
@ -167,11 +170,11 @@ CMS_RecipientInfo *CMS_add0_recipient_password(CMS_ContentInfo *cms,
|
|||
/* Since this is overwritten, free up empty structure already there */
|
||||
X509_ALGOR_free(pwri->keyEncryptionAlgorithm);
|
||||
pwri->keyEncryptionAlgorithm = X509_ALGOR_new();
|
||||
if (!pwri->keyEncryptionAlgorithm)
|
||||
if (pwri->keyEncryptionAlgorithm == NULL)
|
||||
goto merr;
|
||||
pwri->keyEncryptionAlgorithm->algorithm = OBJ_nid2obj(wrap_nid);
|
||||
pwri->keyEncryptionAlgorithm->parameter = ASN1_TYPE_new();
|
||||
if (!pwri->keyEncryptionAlgorithm->parameter)
|
||||
if (pwri->keyEncryptionAlgorithm->parameter == NULL)
|
||||
goto merr;
|
||||
|
||||
if (!ASN1_item_pack(encalg, ASN1_ITEM_rptr(X509_ALGOR),
|
||||
|
@ -230,7 +233,7 @@ static int kek_unwrap_key(unsigned char *out, size_t *outlen,
|
|||
return 0;
|
||||
}
|
||||
tmp = OPENSSL_malloc(inlen);
|
||||
if (!tmp)
|
||||
if (tmp == NULL)
|
||||
return 0;
|
||||
/* setup IV by decrypting last two blocks */
|
||||
if (!EVP_DecryptUpdate(ctx, tmp + inlen - 2 * blocklen, &outl,
|
||||
|
@ -388,7 +391,7 @@ int cms_RecipientInfo_pwri_crypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri,
|
|||
|
||||
key = OPENSSL_malloc(keylen);
|
||||
|
||||
if (!key)
|
||||
if (key == NULL)
|
||||
goto err;
|
||||
|
||||
if (!kek_wrap_key(key, &keylen, ec->key, ec->keylen, &kekctx))
|
||||
|
@ -398,7 +401,7 @@ int cms_RecipientInfo_pwri_crypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri,
|
|||
} else {
|
||||
key = OPENSSL_malloc(pwri->encryptedKey->length);
|
||||
|
||||
if (!key) {
|
||||
if (key == NULL) {
|
||||
CMSerr(CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
|
|
@ -332,7 +332,7 @@ CMS_SignerInfo *CMS_add1_signer(CMS_ContentInfo *cms,
|
|||
|
||||
if (i == sk_X509_ALGOR_num(sd->digestAlgorithms)) {
|
||||
alg = X509_ALGOR_new();
|
||||
if (!alg)
|
||||
if (alg == NULL)
|
||||
goto merr;
|
||||
X509_ALGOR_set_md(alg, md);
|
||||
if (!sk_X509_ALGOR_push(sd->digestAlgorithms, alg)) {
|
||||
|
@ -381,7 +381,7 @@ CMS_SignerInfo *CMS_add1_signer(CMS_ContentInfo *cms,
|
|||
if (flags & CMS_KEY_PARAM) {
|
||||
if (flags & CMS_NOATTR) {
|
||||
si->pctx = EVP_PKEY_CTX_new(si->pkey, NULL);
|
||||
if (!si->pctx)
|
||||
if (si->pctx == NULL)
|
||||
goto err;
|
||||
if (EVP_PKEY_sign_init(si->pctx) <= 0)
|
||||
goto err;
|
||||
|
@ -617,7 +617,7 @@ static int cms_SignerInfo_content_sign(CMS_ContentInfo *cms,
|
|||
goto err;
|
||||
siglen = EVP_PKEY_size(si->pkey);
|
||||
sig = OPENSSL_malloc(siglen);
|
||||
if (!sig) {
|
||||
if (sig == NULL) {
|
||||
CMSerr(CMS_F_CMS_SIGNERINFO_CONTENT_SIGN, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
@ -630,7 +630,7 @@ static int cms_SignerInfo_content_sign(CMS_ContentInfo *cms,
|
|||
unsigned char *sig;
|
||||
unsigned int siglen;
|
||||
sig = OPENSSL_malloc(EVP_PKEY_size(si->pkey));
|
||||
if (!sig) {
|
||||
if (sig == NULL) {
|
||||
CMSerr(CMS_F_CMS_SIGNERINFO_CONTENT_SIGN, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
@ -708,7 +708,7 @@ int CMS_SignerInfo_sign(CMS_SignerInfo *si)
|
|||
goto err;
|
||||
OPENSSL_free(abuf);
|
||||
abuf = OPENSSL_malloc(siglen);
|
||||
if (!abuf)
|
||||
if (abuf == NULL)
|
||||
goto err;
|
||||
if (EVP_DigestSignFinal(mctx, abuf, &siglen) <= 0)
|
||||
goto err;
|
||||
|
@ -851,6 +851,8 @@ int CMS_SignerInfo_verify_content(CMS_SignerInfo *si, BIO *chain)
|
|||
} else {
|
||||
const EVP_MD *md = EVP_MD_CTX_md(&mctx);
|
||||
pkctx = EVP_PKEY_CTX_new(si->pkey, NULL);
|
||||
if (pkctx == NULL)
|
||||
goto err;
|
||||
if (EVP_PKEY_verify_init(pkctx) <= 0)
|
||||
goto err;
|
||||
if (EVP_PKEY_CTX_set_signature_md(pkctx, md) <= 0)
|
||||
|
@ -894,20 +896,20 @@ int CMS_add_simple_smimecap(STACK_OF(X509_ALGOR) **algs,
|
|||
ASN1_INTEGER *key = NULL;
|
||||
if (keysize > 0) {
|
||||
key = ASN1_INTEGER_new();
|
||||
if (!key || !ASN1_INTEGER_set(key, keysize))
|
||||
if (key == NULL || !ASN1_INTEGER_set(key, keysize))
|
||||
return 0;
|
||||
}
|
||||
alg = X509_ALGOR_new();
|
||||
if (!alg) {
|
||||
if (alg == NULL) {
|
||||
ASN1_INTEGER_free(key);
|
||||
return 0;
|
||||
}
|
||||
|
||||
X509_ALGOR_set0(alg, OBJ_nid2obj(algnid),
|
||||
key ? V_ASN1_INTEGER : V_ASN1_UNDEF, key);
|
||||
if (!*algs)
|
||||
if (*algs == NULL)
|
||||
*algs = sk_X509_ALGOR_new_null();
|
||||
if (!*algs || !sk_X509_ALGOR_push(*algs, alg)) {
|
||||
if (*algs == NULL || !sk_X509_ALGOR_push(*algs, alg)) {
|
||||
X509_ALGOR_free(alg);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -82,7 +82,7 @@ static int cms_copy_content(BIO *out, BIO *in, unsigned int flags)
|
|||
|
||||
tmpout = cms_get_text_bio(out, flags);
|
||||
|
||||
if (!tmpout) {
|
||||
if (tmpout == NULL) {
|
||||
CMSerr(CMS_F_CMS_COPY_CONTENT, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
@ -253,7 +253,7 @@ CMS_ContentInfo *CMS_EncryptedData_encrypt(BIO *in, const EVP_CIPHER *cipher,
|
|||
return NULL;
|
||||
}
|
||||
cms = CMS_ContentInfo_new();
|
||||
if (!cms)
|
||||
if (cms == NULL)
|
||||
return NULL;
|
||||
if (!CMS_EncryptedData_set1_key(cms, cipher, key, keylen))
|
||||
return NULL;
|
||||
|
@ -482,7 +482,7 @@ CMS_ContentInfo *CMS_sign(X509 *signcert, EVP_PKEY *pkey,
|
|||
int i;
|
||||
|
||||
cms = CMS_ContentInfo_new();
|
||||
if (!cms || !CMS_SignedData_init(cms))
|
||||
if (cms == NULL || !CMS_SignedData_init(cms))
|
||||
goto merr;
|
||||
if (flags & CMS_ASCIICRLF
|
||||
&& !CMS_set1_eContentType(cms,
|
||||
|
|
|
@ -364,7 +364,7 @@ static int bio_zlib_new(BIO *bi)
|
|||
}
|
||||
# endif
|
||||
ctx = OPENSSL_zalloc(sizeof(*ctx));
|
||||
if (!ctx) {
|
||||
if (ctx == NULL) {
|
||||
COMPerr(COMP_F_BIO_ZLIB_NEW, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
|
@ -416,7 +416,7 @@ static int bio_zlib_read(BIO *b, char *out, int outl)
|
|||
BIO_clear_retry_flags(b);
|
||||
if (!ctx->ibuf) {
|
||||
ctx->ibuf = OPENSSL_malloc(ctx->ibufsize);
|
||||
if (!ctx->ibuf) {
|
||||
if (ctx->ibuf == NULL) {
|
||||
COMPerr(COMP_F_BIO_ZLIB_READ, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
|
@ -475,7 +475,7 @@ static int bio_zlib_write(BIO *b, const char *in, int inl)
|
|||
if (!ctx->obuf) {
|
||||
ctx->obuf = OPENSSL_malloc(ctx->obufsize);
|
||||
/* Need error here */
|
||||
if (!ctx->obuf) {
|
||||
if (ctx->obuf == NULL) {
|
||||
COMPerr(COMP_F_BIO_ZLIB_WRITE, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -129,7 +129,7 @@ static CONF *def_create(CONF_METHOD *meth)
|
|||
CONF *ret;
|
||||
|
||||
ret = OPENSSL_malloc(sizeof(*ret));
|
||||
if (ret)
|
||||
if (ret != NULL)
|
||||
if (meth->init(ret) == 0) {
|
||||
OPENSSL_free(ret);
|
||||
ret = NULL;
|
||||
|
|
|
@ -166,7 +166,7 @@ int CONF_modules_load_file(const char *filename, const char *appname,
|
|||
CONF *conf = NULL;
|
||||
int ret = 0;
|
||||
conf = NCONF_new(NULL);
|
||||
if (!conf)
|
||||
if (conf == NULL)
|
||||
goto err;
|
||||
|
||||
if (filename == NULL) {
|
||||
|
@ -336,7 +336,7 @@ static int module_init(CONF_MODULE *pmod, char *name, char *value,
|
|||
|
||||
/* Otherwise add initialized module to list */
|
||||
imod = OPENSSL_malloc(sizeof(*imod));
|
||||
if (!imod)
|
||||
if (imod == NULL)
|
||||
goto err;
|
||||
|
||||
imod->pmod = pmod;
|
||||
|
@ -535,7 +535,7 @@ char *CONF_get1_default_config_file(void)
|
|||
|
||||
file = OPENSSL_malloc(len + 1);
|
||||
|
||||
if (!file)
|
||||
if (file == NULL)
|
||||
return NULL;
|
||||
BUF_strlcpy(file, X509_get_default_cert_area(), len + 1);
|
||||
#ifndef OPENSSL_SYS_VMS
|
||||
|
|
|
@ -156,7 +156,7 @@ static int dh_pub_encode(X509_PUBKEY *pk, const EVP_PKEY *pkey)
|
|||
dh = pkey->pkey.dh;
|
||||
|
||||
str = ASN1_STRING_new();
|
||||
if (!str) {
|
||||
if (str == NULL) {
|
||||
DHerr(DH_F_DH_PUB_ENCODE, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
@ -258,7 +258,7 @@ static int dh_priv_encode(PKCS8_PRIV_KEY_INFO *p8, const EVP_PKEY *pkey)
|
|||
|
||||
params = ASN1_STRING_new();
|
||||
|
||||
if (!params) {
|
||||
if (params == NULL) {
|
||||
DHerr(DH_F_DH_PRIV_ENCODE, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
@ -496,7 +496,7 @@ DH *DHparams_dup(DH *dh)
|
|||
{
|
||||
DH *ret;
|
||||
ret = DH_new();
|
||||
if (!ret)
|
||||
if (ret == NULL)
|
||||
return NULL;
|
||||
if (!int_dh_param_copy(ret, dh, -1)) {
|
||||
DH_free(ret);
|
||||
|
@ -691,7 +691,7 @@ static int dh_cms_set_peerkey(EVP_PKEY_CTX *pctx,
|
|||
}
|
||||
|
||||
pkpeer = EVP_PKEY_new();
|
||||
if (!pkpeer)
|
||||
if (pkpeer == NULL)
|
||||
goto err;
|
||||
EVP_PKEY_assign(pkpeer, pk->ameth->pkey_id, dhpeer);
|
||||
dhpeer = NULL;
|
||||
|
@ -891,11 +891,11 @@ static int dh_cms_encrypt(CMS_RecipientInfo *ri)
|
|||
/* Package wrap algorithm in an AlgorithmIdentifier */
|
||||
|
||||
wrap_alg = X509_ALGOR_new();
|
||||
if (!wrap_alg)
|
||||
if (wrap_alg == NULL)
|
||||
goto err;
|
||||
wrap_alg->algorithm = OBJ_nid2obj(wrap_nid);
|
||||
wrap_alg->parameter = ASN1_TYPE_new();
|
||||
if (!wrap_alg->parameter)
|
||||
if (wrap_alg->parameter == NULL)
|
||||
goto err;
|
||||
if (EVP_CIPHER_param_to_asn1(ctx, wrap_alg->parameter) <= 0)
|
||||
goto err;
|
||||
|
@ -927,7 +927,7 @@ static int dh_cms_encrypt(CMS_RecipientInfo *ri)
|
|||
if (!penc || !penclen)
|
||||
goto err;
|
||||
wrap_str = ASN1_STRING_new();
|
||||
if (!wrap_str)
|
||||
if (wrap_str == NULL)
|
||||
goto err;
|
||||
ASN1_STRING_set0(wrap_str, penc, penclen);
|
||||
penc = NULL;
|
||||
|
|
|
@ -70,7 +70,7 @@ static int dh_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
|
|||
{
|
||||
if (operation == ASN1_OP_NEW_PRE) {
|
||||
*pval = (ASN1_VALUE *)DH_new();
|
||||
if (*pval)
|
||||
if (*pval != NULL)
|
||||
return 2;
|
||||
return 0;
|
||||
} else if (operation == ASN1_OP_FREE_PRE) {
|
||||
|
@ -133,10 +133,10 @@ DH *d2i_DHxparams(DH **a, const unsigned char **pp, long length)
|
|||
int_dhx942_dh *dhx = NULL;
|
||||
DH *dh = NULL;
|
||||
dh = DH_new();
|
||||
if (!dh)
|
||||
if (dh == NULL)
|
||||
return NULL;
|
||||
dhx = d2i_int_dhx(NULL, pp, length);
|
||||
if (!dhx) {
|
||||