ASN1_BIT_STRING *ret = NULL;
const unsigned char *p;
unsigned char *s;
- int i;
+ int i = 0;
if (len < 1) {
i = ASN1_R_STRING_TOO_SHORT;
if (len-- > 1) { /* using one because of the bits left byte */
s = OPENSSL_malloc((int)len);
if (s == NULL) {
- i = ERR_R_MALLOC_FAILURE;
goto err;
}
memcpy(s, p, (int)len);
*pp = p;
return ret;
err:
- ERR_raise(ERR_LIB_ASN1, i);
+ if (i != 0)
+ ERR_raise(ERR_LIB_ASN1, i);
if ((a == NULL) || (*a != ret))
ASN1_BIT_STRING_free(ret);
return NULL;
if (!value)
return 1; /* Don't need to set */
c = OPENSSL_clear_realloc(a->data, a->length, w + 1);
- if (c == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (c == NULL)
return 0;
- }
if (w + 1 - a->length > 0)
memset(c + a->length, 0, w + 1 - a->length);
a->data = c;
b = BUF_MEM_new();
if (b == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_BUF_LIB);
return -1;
}
want -= diff;
if (len + want < len || !BUF_MEM_grow_clean(b, len + want)) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_BUF_LIB);
goto err;
}
i = BIO_read(in, &(b->data[len]), want);
size_t chunk = want > chunk_max ? chunk_max : want;
if (!BUF_MEM_grow_clean(b, len + chunk)) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_BUF_LIB);
goto err;
}
want -= chunk;
ERR_raise(ERR_LIB_ASN1, ERR_R_INTERNAL_ERROR);
return 0;
}
- if ((str = OPENSSL_malloc(inl)) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if ((str = OPENSSL_malloc(inl)) == NULL)
return 0;
- }
p = str;
i2d(data, &p);
return NULL;
b = OPENSSL_malloc(i + 10);
- if (b == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (b == NULL)
return NULL;
- }
p = b;
i = i2d(x, &p);
p2 = b;
i = ASN1_item_i2d(x, &b, it);
if (b == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
return NULL;
}
p = b;
return 0;
b = OPENSSL_malloc(n);
- if (b == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (b == NULL)
return 0;
- }
p = (unsigned char *)b;
i2d(x, &p);
n = ASN1_item_i2d(x, &b, it);
if (b == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
return 0;
}
} else
ret = *a;
- if (ASN1_STRING_set(ret, NULL, r) == 0)
+ if (ASN1_STRING_set(ret, NULL, r) == 0) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
goto err;
+ }
c2i_ibuf(ret->data, &neg, *pp, len);
(*a) = ret;
return ret;
err:
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
if (a == NULL || *a != ret)
ASN1_INTEGER_free(ret);
return NULL;
unsigned char *s;
long len = 0;
int inf, tag, xclass;
- int i;
+ int i = 0;
if ((a == NULL) || ((*a) == NULL)) {
if ((ret = ASN1_INTEGER_new()) == NULL)
* a missing NULL parameter.
*/
s = OPENSSL_malloc((int)len + 1);
- if (s == NULL) {
- i = ERR_R_MALLOC_FAILURE;
+ if (s == NULL)
goto err;
- }
ret->type = V_ASN1_INTEGER;
if (len) {
if ((*p == 0) && (len != 1)) {
*pp = p;
return ret;
err:
- ERR_raise(ERR_LIB_ASN1, i);
+ if (i != 0)
+ ERR_raise(ERR_LIB_ASN1, i);
if ((a == NULL) || (*a != ret))
ASN1_INTEGER_free(ret);
return NULL;
len = 1;
if (ASN1_STRING_set(ret, NULL, len) == 0) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
goto err;
}
free_out = 1;
dest = ASN1_STRING_type_new(str_type);
if (dest == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
return -1;
}
*out = dest;
/* If both the same type just copy across */
if (inform == outform) {
if (!ASN1_STRING_set(dest, in, len)) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
return -1;
}
return str_type;
if ((p = OPENSSL_malloc(outlen + 1)) == NULL) {
if (free_out)
ASN1_STRING_free(dest);
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
return -1;
}
dest->length = outlen;
return objsize;
if (*pp == NULL) {
- if ((p = allocated = OPENSSL_malloc(objsize)) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if ((p = allocated = OPENSSL_malloc(objsize)) == NULL)
return 0;
- }
} else {
p = *pp;
}
OPENSSL_free(tmp);
tmpsize = blsize + 32;
tmp = OPENSSL_malloc(tmpsize);
- if (tmp == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (tmp == NULL)
goto err;
- }
}
while (blsize--) {
BN_ULONG t = BN_div_word(bl, 0x80L);
ERR_raise(ERR_LIB_ASN1, ASN1_R_LENGTH_TOO_LONG);
return -1;
}
- if ((p = OPENSSL_malloc(i + 1)) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if ((p = OPENSSL_malloc(i + 1)) == NULL)
return -1;
- }
i2t_ASN1_OBJECT(p, i + 1, a);
}
if (i <= 0) {
ret->length = 0;
OPENSSL_free(data);
data = OPENSSL_malloc(length);
- if (data == NULL) {
- i = ERR_R_MALLOC_FAILURE;
+ if (data == NULL)
goto err;
- }
ret->flags |= ASN1_OBJECT_FLAG_DYNAMIC_DATA;
}
memcpy(data, p, length);
ASN1_OBJECT *ret;
ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->flags = ASN1_OBJECT_FLAG_DYNAMIC;
return ret;
}
X509_ALGOR *a;
if (ctx == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
goto err;
}
for (i = 0; i < 2; i++) {
buf_out = OPENSSL_malloc(outll);
if (buf_in == NULL || buf_out == NULL) {
outl = 0;
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
goto err;
}
p = buf_in;
EVP_MD_CTX *ctx = evp_md_ctx_new_ex(pkey, id, libctx, propq);
if (ctx == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
return 0;
}
/* We can use the non _ex variant here since the pkey is already setup */
buf_out = OPENSSL_malloc(outll);
if (buf_in == NULL || buf_out == NULL) {
outl = 0;
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
goto err;
}
der_len = i2d_ASN1_TYPE(&t, NULL);
if (der_len <= 0)
return -1;
- if ((der_buf = OPENSSL_malloc(der_len)) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if ((der_buf = OPENSSL_malloc(der_len)) == NULL)
return -1;
- }
p = der_buf;
i2d_ASN1_TYPE(&t, &p);
outlen = do_hex_dump(io_ch, arg, der_buf, der_len);
tmp = ASN1_STRING_TABLE_get(nid);
if (tmp != NULL && tmp->flags & STABLE_FLAGS_MALLOC)
return tmp;
- if ((rv = OPENSSL_zalloc(sizeof(*rv))) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if ((rv = OPENSSL_zalloc(sizeof(*rv))) == NULL)
return NULL;
- }
if (!sk_ASN1_STRING_TABLE_push(stable, rv)) {
OPENSSL_free(rv);
return NULL;
tmp = stable_get(nid);
if (tmp == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
return 0;
}
if (minsize >= 0)
* new t.data would be freed after ASN1_STRING_copy is done.
*/
t.data = OPENSSL_zalloc(t.length + 1);
- if (t.data == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (t.data == NULL)
goto out;
- }
memcpy(t.data, str + 2, t.length);
t.type = V_ASN1_UTCTIME;
}
int ret = -1, i, inl;
if (ctx == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
goto err;
}
i = OBJ_obj2nid(a->algorithm);
goto err;
}
buf_in = OPENSSL_malloc((unsigned int)inl);
- if (buf_in == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (buf_in == NULL)
goto err;
- }
p = buf_in;
i2d(data, &p);
goto err;
}
if (buf_in == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
goto err;
}
inll = inl;
{
EVP_PKEY_ASN1_METHOD *ameth = OPENSSL_zalloc(sizeof(*ameth));
- if (ameth == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (ameth == NULL)
return NULL;
- }
ameth->pkey_id = id;
ameth->pkey_base_id = id;
err:
EVP_PKEY_asn1_free(ameth);
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
return NULL;
}
int no_unused = 1;
if ((atmp = ASN1_TYPE_new()) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
return NULL;
}
goto bad_form;
}
if ((atmp->value.asn1_string = ASN1_STRING_new()) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
goto bad_str;
}
if (!ASN1_STRING_set(atmp->value.asn1_string, str, -1)) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
goto bad_str;
}
atmp->value.asn1_string->type = utype;
if (ASN1_mbstring_copy(&atmp->value.asn1_string, (unsigned char *)str,
-1, format, ASN1_tag2bit(utype)) <= 0) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
goto bad_str;
}
case V_ASN1_BIT_STRING:
case V_ASN1_OCTET_STRING:
if ((atmp->value.asn1_string = ASN1_STRING_new()) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
goto bad_form;
}
return 0;
}
if (!ASN1_BIT_STRING_set_bit(bitstr, bitnum, 1)) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
return 0;
}
return 1;
str->data = OPENSSL_realloc(c, len + 1);
#endif
if (str->data == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
str->data = c;
return 0;
}
ASN1_STRING *ret;
ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->type = type;
return ret;
}
BIO *bio, *tbio;
bio = BIO_new_NDEF(out, val, it);
if (!bio) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_BUF_LIB);
return 0;
}
if (!SMIME_crlf_copy(in, bio, flags)) {
int r;
b64 = BIO_new(BIO_f_base64());
if (b64 == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_BIO_LIB);
return 0;
}
/*
ASN1_VALUE *val;
if ((b64 = BIO_new(BIO_f_base64())) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_BIO_LIB);
return 0;
}
bio = BIO_push(b64, bio);
*/
bf = BIO_new(BIO_f_buffer());
if (bf == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_BIO_LIB);
return 0;
}
out = BIO_push(bf, out);
p--;
}
p++;
- if ((lntmp = OPENSSL_malloc((p - ln) + 1)) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if ((lntmp = OPENSSL_malloc((p - ln) + 1)) == NULL)
return 0;
- }
memcpy(lntmp, ln, p - ln);
lntmp[p - ln] = '\0';
ln = lntmp;
rv = ASN1_STRING_TABLE_add(nid, tbl_min, tbl_max,
tbl_mask, tbl_flags);
if (!rv)
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
}
sk_CONF_VALUE_pop_free(lst, X509V3_conf_free);
return rv;
if (oct == NULL || *oct == NULL) {
if ((octmp = ASN1_STRING_new()) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
return NULL;
}
} else {
goto err;
}
if (octmp->data == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
goto err;
}
{
BIO_ASN1_BUF_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
- if (ctx == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL)
return 0;
- }
if (!asn1_bio_init(ctx, DEFAULT_ASN1_BUF_SIZE)) {
OPENSSL_free(ctx);
return 0;
static int asn1_bio_init(BIO_ASN1_BUF_CTX *ctx, int size)
{
- if (size <= 0 || (ctx->buf = OPENSSL_malloc(size)) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (size <= 0) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_PASSED_INVALID_ARGUMENT);
return 0;
}
+ if ((ctx->buf = OPENSSL_malloc(size)) == NULL)
+ return 0;
ctx->bufsize = size;
ctx->asn1_class = V_ASN1_UNIVERSAL;
ctx->asn1_tag = V_ASN1_OCTET_STRING;
derlen = ASN1_item_ndef_i2d(ndef_aux->val, NULL, ndef_aux->it);
if (derlen < 0)
return 0;
- if ((p = OPENSSL_malloc(derlen)) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if ((p = OPENSSL_malloc(derlen)) == NULL)
return 0;
- }
ndef_aux->derbuf = p;
*pbuf = p;
derlen = ASN1_item_ndef_i2d(ndef_aux->val, NULL, ndef_aux->it);
if (derlen < 0)
return 0;
- if ((p = OPENSSL_malloc(derlen)) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if ((p = OPENSSL_malloc(derlen)) == NULL)
return 0;
- }
ndef_aux->derbuf = p;
*pbuf = p;
if (num + i > slen) {
sp = OPENSSL_clear_realloc(s, slen, num + i * 2);
if (sp == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
OPENSSL_free(s);
return 0;
}
if (num + i > slen) {
sp = OPENSSL_realloc(s, (unsigned int)num + i * 2);
if (sp == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
OPENSSL_free(s);
return 0;
}
pbe = PBEPARAM_new();
if (pbe == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ /* ERR_R_ASN1_LIB, because PBEPARAM_new() is defined in crypto/asn1 */
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
goto err;
}
if (iter <= 0)
iter = PKCS5_DEFAULT_ITER;
if (!ASN1_INTEGER_set(pbe->iter, iter)) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
goto err;
}
if (!saltlen)
goto err;
sstr = OPENSSL_malloc(saltlen);
- if (sstr == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (sstr == NULL)
goto err;
- }
if (salt)
memcpy(sstr, salt, saltlen);
else if (RAND_bytes_ex(ctx, sstr, saltlen, 0) <= 0)
sstr = NULL;
if (!ASN1_item_pack(pbe, ASN1_ITEM_rptr(PBEPARAM), &pbe_str)) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
goto err;
}
X509_ALGOR *ret;
ret = X509_ALGOR_new();
if (ret == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_X509_LIB);
return NULL;
}
goto err;
}
- if ((pbe2 = PBE2PARAM_new()) == NULL)
- goto merr;
+ if ((pbe2 = PBE2PARAM_new()) == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
/* Setup the AlgorithmIdentifier for the encryption scheme */
scheme = pbe2->encryption;
scheme->algorithm = OBJ_nid2obj(alg_nid);
- if ((scheme->parameter = ASN1_TYPE_new()) == NULL)
- goto merr;
+ if ((scheme->parameter = ASN1_TYPE_new()) == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
/* Create random IV */
ivlen = EVP_CIPHER_get_iv_length(cipher);
}
ctx = EVP_CIPHER_CTX_new();
- if (ctx == NULL)
- goto merr;
+ if (ctx == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
+ goto err;
+ }
/* Dummy cipherinit to just setup the IV, and PRF */
if (!EVP_CipherInit_ex(ctx, cipher, NULL, NULL, iv, 0))
pbe2->keyfunc = PKCS5_pbkdf2_set_ex(iter, salt, saltlen, prf_nid, keylen,
libctx);
- if (pbe2->keyfunc == NULL)
- goto merr;
+ if (pbe2->keyfunc == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
/* Now set up top level AlgorithmIdentifier */
- if ((ret = X509_ALGOR_new()) == NULL)
- goto merr;
+ if ((ret = X509_ALGOR_new()) == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_X509_LIB);
+ goto err;
+ }
ret->algorithm = OBJ_nid2obj(NID_pbes2);
/* Encode PBE2PARAM into parameter */
if (!ASN1_TYPE_pack_sequence(ASN1_ITEM_rptr(PBE2PARAM), pbe2,
- &ret->parameter))
- goto merr;
+ &ret->parameter)) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
PBE2PARAM_free(pbe2);
pbe2 = NULL;
return ret;
- merr:
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
-
err:
EVP_CIPHER_CTX_free(ctx);
PBE2PARAM_free(pbe2);
PBKDF2PARAM *kdf = NULL;
ASN1_OCTET_STRING *osalt = NULL;
- if ((kdf = PBKDF2PARAM_new()) == NULL)
- goto merr;
- if ((osalt = ASN1_OCTET_STRING_new()) == NULL)
- goto merr;
+ if ((kdf = PBKDF2PARAM_new()) == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
+ if ((osalt = ASN1_OCTET_STRING_new()) == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
kdf->salt->value.octet_string = osalt;
kdf->salt->type = V_ASN1_OCTET_STRING;
- if (saltlen < 0)
- goto merr;
+ if (saltlen < 0) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_PASSED_INVALID_ARGUMENT);
+ goto err;
+ }
if (saltlen == 0)
saltlen = PKCS5_SALT_LEN;
if ((osalt->data = OPENSSL_malloc(saltlen)) == NULL)
- goto merr;
+ goto err;
+
osalt->length = saltlen;
- if (salt)
+ if (salt) {
memcpy(osalt->data, salt, saltlen);
- else if (RAND_bytes_ex(libctx, osalt->data, saltlen, 0) <= 0)
- goto merr;
+ } else if (RAND_bytes_ex(libctx, osalt->data, saltlen, 0) <= 0) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_RAND_LIB);
+ goto err;
+ }
if (iter <= 0)
iter = PKCS5_DEFAULT_ITER;
- if (!ASN1_INTEGER_set(kdf->iter, iter))
- goto merr;
+ if (!ASN1_INTEGER_set(kdf->iter, iter)) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
/* If have a key len set it up */
if (keylen > 0) {
- if ((kdf->keylength = ASN1_INTEGER_new()) == NULL)
- goto merr;
- if (!ASN1_INTEGER_set(kdf->keylength, keylen))
- goto merr;
+ if ((kdf->keylength = ASN1_INTEGER_new()) == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
+ if (!ASN1_INTEGER_set(kdf->keylength, keylen)) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
}
/* prf can stay NULL if we are using hmacWithSHA1 */
if (prf_nid > 0 && prf_nid != NID_hmacWithSHA1) {
kdf->prf = ossl_X509_ALGOR_from_nid(prf_nid, V_ASN1_NULL, NULL);
- if (kdf->prf == NULL)
- goto merr;
+ if (kdf->prf == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_X509_LIB);
+ goto err;
+ }
}
/* Finally setup the keyfunc structure */
keyfunc = X509_ALGOR_new();
- if (keyfunc == NULL)
- goto merr;
+ if (keyfunc == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_X509_LIB);
+ goto err;
+ }
keyfunc->algorithm = OBJ_nid2obj(NID_id_pbkdf2);
/* Encode PBKDF2PARAM into parameter of pbe2 */
if (!ASN1_TYPE_pack_sequence(ASN1_ITEM_rptr(PBKDF2PARAM), kdf,
- &keyfunc->parameter))
- goto merr;
+ &keyfunc->parameter)) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
PBKDF2PARAM_free(kdf);
return keyfunc;
- merr:
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ err:
PBKDF2PARAM_free(kdf);
X509_ALGOR_free(keyfunc);
return NULL;
}
pbe2 = PBE2PARAM_new();
- if (pbe2 == NULL)
- goto merr;
+ if (pbe2 == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
/* Setup the AlgorithmIdentifier for the encryption scheme */
scheme = pbe2->encryption;
scheme->algorithm = OBJ_nid2obj(alg_nid);
scheme->parameter = ASN1_TYPE_new();
- if (scheme->parameter == NULL)
- goto merr;
+ if (scheme->parameter == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
/* Create random IV */
if (EVP_CIPHER_get_iv_length(cipher)) {
}
ctx = EVP_CIPHER_CTX_new();
- if (ctx == NULL)
- goto merr;
+ if (ctx == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
+ goto err;
+ }
/* Dummy cipherinit to just setup the IV */
if (EVP_CipherInit_ex(ctx, cipher, NULL, NULL, iv, 0) == 0)
pbe2->keyfunc = pkcs5_scrypt_set(salt, saltlen, keylen, N, r, p);
- if (pbe2->keyfunc == NULL)
- goto merr;
+ if (pbe2->keyfunc == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
/* Now set up top level AlgorithmIdentifier */
ret = X509_ALGOR_new();
- if (ret == NULL)
- goto merr;
+ if (ret == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
ret->algorithm = OBJ_nid2obj(NID_pbes2);
/* Encode PBE2PARAM into parameter */
if (ASN1_TYPE_pack_sequence(ASN1_ITEM_rptr(PBE2PARAM), pbe2,
- &ret->parameter) == NULL)
- goto merr;
+ &ret->parameter) == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
PBE2PARAM_free(pbe2);
pbe2 = NULL;
return ret;
- merr:
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
-
err:
PBE2PARAM_free(pbe2);
X509_ALGOR_free(ret);
X509_ALGOR *keyfunc = NULL;
SCRYPT_PARAMS *sparam = SCRYPT_PARAMS_new();
- if (sparam == NULL)
- goto merr;
+ if (sparam == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
if (!saltlen)
saltlen = PKCS5_SALT_LEN;
/* This will either copy salt or grow the buffer */
- if (ASN1_STRING_set(sparam->salt, salt, saltlen) == 0)
- goto merr;
+ if (ASN1_STRING_set(sparam->salt, salt, saltlen) == 0) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
if (salt == NULL && RAND_bytes(sparam->salt->data, saltlen) <= 0)
goto err;
- if (ASN1_INTEGER_set_uint64(sparam->costParameter, N) == 0)
- goto merr;
+ if (ASN1_INTEGER_set_uint64(sparam->costParameter, N) == 0) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
- if (ASN1_INTEGER_set_uint64(sparam->blockSize, r) == 0)
- goto merr;
+ if (ASN1_INTEGER_set_uint64(sparam->blockSize, r) == 0) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
- if (ASN1_INTEGER_set_uint64(sparam->parallelizationParameter, p) == 0)
- goto merr;
+ if (ASN1_INTEGER_set_uint64(sparam->parallelizationParameter, p) == 0) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
/* If have a key len set it up */
if (keylen > 0) {
sparam->keyLength = ASN1_INTEGER_new();
- if (sparam->keyLength == NULL)
- goto merr;
- if (ASN1_INTEGER_set_int64(sparam->keyLength, keylen) == 0)
- goto merr;
+ if (sparam->keyLength == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
+ if (ASN1_INTEGER_set_int64(sparam->keyLength, keylen) == 0) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
}
/* Finally setup the keyfunc structure */
keyfunc = X509_ALGOR_new();
- if (keyfunc == NULL)
- goto merr;
+ if (keyfunc == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
keyfunc->algorithm = OBJ_nid2obj(NID_id_scrypt);
/* Encode SCRYPT_PARAMS into parameter of pbe2 */
if (ASN1_TYPE_pack_sequence(ASN1_ITEM_rptr(SCRYPT_PARAMS), sparam,
- &keyfunc->parameter) == NULL)
- goto merr;
+ &keyfunc->parameter) == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ goto err;
+ }
SCRYPT_PARAMS_free(sparam);
return keyfunc;
- merr:
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
err:
SCRYPT_PARAMS_free(sparam);
X509_ALGOR_free(keyfunc);
}
if (*val == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_CRYPTO_LIB);
goto err;
}
}
len -= p - q;
if (!sk_ASN1_VALUE_push((STACK_OF(ASN1_VALUE) *)*val, skfield)) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_CRYPTO_LIB);
ASN1_item_free(skfield, ASN1_ITEM_ptr(tt->item));
goto err;
}
len = buf.length;
/* Append a final null to string */
if (!BUF_MEM_grow_clean(&buf, len + 1)) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_BUF_LIB);
goto err;
}
buf.data[len] = 0;
if (*pval == NULL) {
stmp = ASN1_STRING_type_new(utype);
if (stmp == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
goto err;
}
*pval = (ASN1_VALUE *)stmp;
*free_cont = 0;
} else {
if (!ASN1_STRING_set(stmp, cont, len)) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
ASN1_STRING_free(stmp);
*pval = NULL;
goto err;
if (buf) {
len = buf->length;
if (!BUF_MEM_grow_clean(buf, len + plen)) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_BUF_LIB);
return 0;
}
memcpy(buf->data + len, *p, plen);
len = ASN1_item_ex_i2d(&val, NULL, it, -1, flags);
if (len <= 0)
return len;
- if ((buf = OPENSSL_malloc(len)) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if ((buf = OPENSSL_malloc(len)) == NULL)
return -1;
- }
p = buf;
ASN1_item_ex_i2d(&val, &p, it, -1, flags);
*out = buf;
else {
derlst = OPENSSL_malloc(sk_const_ASN1_VALUE_num(sk)
* sizeof(*derlst));
- if (derlst == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (derlst == NULL)
return 0;
- }
tmpdat = OPENSSL_malloc(skcontlen);
- if (tmpdat == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (tmpdat == NULL)
goto err;
- }
}
}
/* If not sorting just output each item */
if (ef != NULL) {
if (ef->asn1_ex_new_ex != NULL) {
if (!ef->asn1_ex_new_ex(pval, it, libctx, propq))
- goto memerr;
+ goto asn1err;
} else if (ef->asn1_ex_new != NULL) {
if (!ef->asn1_ex_new(pval, it))
- goto memerr;
+ goto asn1err;
}
}
break;
case ASN1_ITYPE_PRIMITIVE:
if (it->templates) {
if (!asn1_template_new(pval, it->templates, libctx, propq))
- goto memerr;
+ goto asn1err;
} else if (!asn1_primitive_new(pval, it, embed))
- goto memerr;
+ goto asn1err;
break;
case ASN1_ITYPE_MSTRING:
if (!asn1_primitive_new(pval, it, embed))
- goto memerr;
+ goto asn1err;
break;
case ASN1_ITYPE_CHOICE:
} else {
*pval = OPENSSL_zalloc(it->size);
if (*pval == NULL)
- goto memerr;
+ return 0;
}
ossl_asn1_set_choice_selector(pval, -1, it);
if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL))
} else {
*pval = OPENSSL_zalloc(it->size);
if (*pval == NULL)
- goto memerr;
+ return 0;
}
/* 0 : init. lock */
if (ossl_asn1_do_lock(pval, 0, it) < 0) {
OPENSSL_free(*pval);
*pval = NULL;
}
- goto memerr;
+ goto asn1err;
}
ossl_asn1_enc_init(pval, it);
for (i = 0, tt = it->templates; i < it->tcount; tt++, i++) {
pseqval = ossl_asn1_get_field_ptr(pval, tt);
if (!asn1_template_new(pseqval, tt, libctx, propq))
- goto memerr2;
+ goto asn1err2;
}
if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL))
goto auxerr2;
}
return 1;
- memerr2:
+ asn1err2:
ossl_asn1_item_embed_free(pval, it, embed);
- memerr:
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ asn1err:
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
return 0;
auxerr2:
STACK_OF(ASN1_VALUE) *skval;
skval = sk_ASN1_VALUE_new_null();
if (!skval) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_CRYPTO_LIB);
ret = 0;
goto done;
}
return 1;
case V_ASN1_ANY:
- if ((typ = OPENSSL_malloc(sizeof(*typ))) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if ((typ = OPENSSL_malloc(sizeof(*typ))) == NULL)
return 0;
- }
typ->value.ptr = NULL;
typ->type = -1;
*pval = (ASN1_VALUE *)typ;
ASN1_PCTX *ret;
ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
return ret;
}
{
ASN1_SCTX *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->scan_cb = scan_cb;
return ret;
}
*lck = ret = 1;
*lock = CRYPTO_THREAD_lock_new();
if (*lock == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_CRYPTO_LIB);
return -1;
}
break;
OPENSSL_free(enc->enc);
if (inlen <= 0)
return 0;
- if ((enc->enc = OPENSSL_malloc(inlen)) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if ((enc->enc = OPENSSL_malloc(inlen)) == NULL)
return 0;
- }
memcpy(enc->enc, in, inlen);
enc->len = inlen;
enc->modified = 0;
X509_INFO *ret;
ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
return ret;
}
static int uint64_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
- if ((*pval = (ASN1_VALUE *)OPENSSL_zalloc(sizeof(uint64_t))) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if ((*pval = (ASN1_VALUE *)OPENSSL_zalloc(sizeof(uint64_t))) == NULL)
return 0;
- }
return 1;
}
static int uint32_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
{
- if ((*pval = (ASN1_VALUE *)OPENSSL_zalloc(sizeof(uint32_t))) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if ((*pval = (ASN1_VALUE *)OPENSSL_zalloc(sizeof(uint32_t))) == NULL)
return 0;
- }
return 1;
}
ret = OPENSSL_zalloc(sizeof(*ret));
if (ret == NULL)
- goto err;
+ return NULL;
ret->enc_algor = X509_ALGOR_new();
ret->enc_pkey = ASN1_OCTET_STRING_new();
- if (ret->enc_algor == NULL || ret->enc_pkey == NULL)
- goto err;
+ if (ret->enc_algor == NULL || ret->enc_pkey == NULL) {
+ X509_PKEY_free(ret);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_ASN1_LIB);
+ return NULL;
+ }
return ret;
-err:
- X509_PKEY_free(ret);
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
- return NULL;
}
void X509_PKEY_free(X509_PKEY *x)
makecontext(&fibre->fibre, async_start_func, 0);
return 1;
}
- ERR_raise(ERR_LIB_ASYNC, ERR_R_MALLOC_FAILURE);
} else {
fibre->fibre.uc_stack.ss_sp = NULL;
}
return NULL;
nctx = OPENSSL_malloc(sizeof(*nctx));
- if (nctx == NULL) {
- ERR_raise(ERR_LIB_ASYNC, ERR_R_MALLOC_FAILURE);
+ if (nctx == NULL)
goto err;
- }
async_fibre_init_dispatcher(&nctx->dispatcher);
nctx->currjob = NULL;
ASYNC_JOB *job = NULL;
job = OPENSSL_zalloc(sizeof(*job));
- if (job == NULL) {
- ERR_raise(ERR_LIB_ASYNC, ERR_R_MALLOC_FAILURE);
+ if (job == NULL)
return NULL;
- }
job->status = ASYNC_JOB_RUNNING;
if (args != NULL) {
ctx->currjob->funcargs = OPENSSL_malloc(size);
if (ctx->currjob->funcargs == NULL) {
- ERR_raise(ERR_LIB_ASYNC, ERR_R_MALLOC_FAILURE);
async_release_job(ctx->currjob);
ctx->currjob = NULL;
return ASYNC_ERR;
return 0;
pool = OPENSSL_zalloc(sizeof(*pool));
- if (pool == NULL) {
- ERR_raise(ERR_LIB_ASYNC, ERR_R_MALLOC_FAILURE);
+ if (pool == NULL)
return 0;
- }
pool->jobs = sk_ASYNC_JOB_new_reserve(NULL, init_size);
if (pool->jobs == NULL) {
- ERR_raise(ERR_LIB_ASYNC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASYNC, ERR_R_CRYPTO_LIB);
OPENSSL_free(pool);
return 0;
}
{
struct fd_lookup_st *fdlookup;
- if ((fdlookup = OPENSSL_zalloc(sizeof(*fdlookup))) == NULL) {
- ERR_raise(ERR_LIB_ASYNC, ERR_R_MALLOC_FAILURE);
+ if ((fdlookup = OPENSSL_zalloc(sizeof(*fdlookup))) == NULL)
return 0;
- }
fdlookup->key = key;
fdlookup->fd = fd;
return 0;
p1 = OPENSSL_malloc((size_t)num);
if (p1 == NULL)
- goto malloc_error;
+ return 0;
OPENSSL_free(ctx->ibuf);
ctx->ibuf = p1;
}
return 0;
p1 = OPENSSL_malloc((size_t)num);
if (p1 == NULL)
- goto malloc_error;
+ return 0;
}
if ((obs > DEFAULT_BUFFER_SIZE) && (obs != ctx->obuf_size)) {
p2 = OPENSSL_malloc((size_t)num);
if (p2 == NULL) {
if (p1 != ctx->ibuf)
OPENSSL_free(p1);
- goto malloc_error;
+ return 0;
}
}
if (ctx->ibuf != p1) {
break;
}
return ret;
- malloc_error:
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
- return 0;
}
static long buffer_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
{
BIO_LINEBUFFER_CTX *ctx;
- if ((ctx = OPENSSL_malloc(sizeof(*ctx))) == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if ((ctx = OPENSSL_malloc(sizeof(*ctx))) == NULL)
return 0;
- }
ctx->obuf = OPENSSL_malloc(DEFAULT_LINEBUFFER_SIZE);
if (ctx->obuf == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
OPENSSL_free(ctx);
return 0;
}
if ((obs > DEFAULT_LINEBUFFER_SIZE) && (obs != ctx->obuf_size)) {
p = OPENSSL_malloc((size_t)obs);
if (p == NULL)
- goto malloc_error;
+ return 0;
}
if (ctx->obuf != p) {
if (ctx->obuf_len > obs) {
break;
}
return ret;
- malloc_error:
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
- return 0;
}
static long linebuffer_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
{
NBIO_TEST *nt;
- if ((nt = OPENSSL_zalloc(sizeof(*nt))) == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if ((nt = OPENSSL_zalloc(sizeof(*nt))) == NULL)
return 0;
- }
nt->lrn = -1;
nt->lwn = -1;
bi->ptr = (char *)nt;
{
BIO_ADDR *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->sa.sa_family = AF_UNSPEC;
return ret;
OPENSSL_free(*service);
*service = NULL;
}
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
return 0;
}
} else {
*host = OPENSSL_strndup(h, hl);
if (*host == NULL)
- goto memerr;
+ return 0;
}
}
if (p != NULL && service != NULL) {
} else {
*service = OPENSSL_strndup(p, pl);
if (*service == NULL)
- goto memerr;
+ return 0;
}
}
spec_err:
ERR_raise(ERR_LIB_BIO, BIO_R_MALFORMED_HOST_OR_SERVICE);
return 0;
- memerr:
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
- return 0;
}
/* addrinfo_wrap is used to build our own addrinfo "chain".
unsigned short port,
BIO_ADDRINFO **bai)
{
- if ((*bai = OPENSSL_zalloc(sizeof(**bai))) == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if ((*bai = OPENSSL_zalloc(sizeof(**bai))) == NULL)
return 0;
- }
(*bai)->bai_family = family;
(*bai)->bai_socktype = socktype;
if (addrinfo_wrap(family, socktype, host, strlen(host), 0, res))
return 1;
else
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_BIO, ERR_R_BIO_LIB);
return 0;
}
#endif
# endif
# ifdef EAI_MEMORY
case EAI_MEMORY:
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ ERR_raise_data(ERR_LIB_BIO, ERR_R_SYS_LIB,
+ gai_strerror(old_ret ? old_ret : gai_ret));
break;
# endif
case 0:
#endif
if (!RUN_ONCE(&bio_lookup_init, do_bio_lookup_init)) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ /* Should this be raised inside do_bio_lookup_init()? */
+ ERR_raise(ERR_LIB_BIO, ERR_R_CRYPTO_LIB);
ret = 0;
goto err;
}
if (!addrinfo_wrap(he->h_addrtype, socktype,
*addrlistp, he->h_length,
se->s_port, &tmp_bai))
- goto addrinfo_malloc_err;
+ goto addrinfo_wrap_err;
tmp_bai->bai_next = *res;
*res = tmp_bai;
continue;
- addrinfo_malloc_err:
+ addrinfo_wrap_err:
BIO_ADDRINFO_free(*res);
*res = NULL;
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_BIO, ERR_R_BIO_LIB);
ret = 0;
goto err;
}
{
BIO *bio = OPENSSL_zalloc(sizeof(*bio));
- if (bio == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if (bio == NULL)
return NULL;
- }
bio->libctx = libctx;
bio->method = method;
bio->lock = CRYPTO_THREAD_lock_new();
if (bio->lock == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_BIO, ERR_R_CRYPTO_LIB);
CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
goto err;
}
int newval;
if (!RUN_ONCE(&bio_type_init, do_bio_type_init)) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ /* Perhaps the error should be raised in do_bio_type_init()? */
+ ERR_raise(ERR_LIB_BIO, ERR_R_CRYPTO_LIB);
return -1;
}
if (!CRYPTO_UP_REF(&bio_count, &newval, bio_type_lock))
if (biom == NULL
|| (biom->name = OPENSSL_strdup(name)) == NULL) {
OPENSSL_free(biom);
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
return NULL;
}
biom->type = type;
*maxlen += BUFFER_INC;
if (*buffer == NULL) {
- if ((*buffer = OPENSSL_malloc(*maxlen)) == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if ((*buffer = OPENSSL_malloc(*maxlen)) == NULL)
return 0;
- }
if (*currlen > 0) {
if (!ossl_assert(*sbuffer != NULL))
return 0;
char *tmpbuf;
tmpbuf = OPENSSL_realloc(*buffer, *maxlen);
- if (tmpbuf == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if (tmpbuf == NULL)
return 0;
- }
*buffer = tmpbuf;
}
}
if (ip_port != NULL) {
char *host = BIO_ADDR_hostname_string(&res, 1);
char *port = BIO_ADDR_service_string(&res, 1);
- if (host != NULL && port != NULL)
+ if (host != NULL && port != NULL) {
*ip_port = OPENSSL_zalloc(strlen(host) + strlen(port) + 2);
- else
+ } else {
*ip_port = NULL;
+ ERR_raise(ERR_LIB_BIO, ERR_R_BIO_LIB);
+ }
if (*ip_port == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
BIO_closesocket(ret);
ret = (int)INVALID_SOCKET;
} else {
{
BIO_ACCEPT *ret;
- if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
return NULL;
- }
ret->accept_family = BIO_FAMILY_IPANY;
ret->accept_sock = (int)INVALID_SOCKET;
return ret;
if (b1->buf == NULL) {
b1->buf = OPENSSL_malloc(b1->size);
- if (b1->buf == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if (b1->buf == NULL)
return 0;
- }
b1->len = 0;
b1->offset = 0;
}
if (b2->buf == NULL) {
b2->buf = OPENSSL_malloc(b2->size);
- if (b2->buf == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if (b2->buf == NULL)
return 0;
- }
b2->len = 0;
b2->offset = 0;
}
{
BIO_CONNECT *ret;
- if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
return NULL;
- }
ret->state = BIO_CONN_S_BEFORE;
ret->connect_family = BIO_FAMILY_IPANY;
return ret;
bi->init = 0;
bi->num = 0;
- if ((data = OPENSSL_zalloc(sizeof(*data))) == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if ((data = OPENSSL_zalloc(sizeof(*data))) == NULL)
return 0;
- }
# ifdef SCTP_PR_SCTP_NONE
data->prinfo.pr_policy = SCTP_PR_SCTP_NONE;
# endif
optlen =
(socklen_t) (sizeof(sctp_assoc_t) + 256 * sizeof(uint8_t));
authchunks = OPENSSL_malloc(optlen);
- if (authchunks == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if (authchunks == NULL)
return -1;
- }
memset(authchunks, 0, optlen);
ii = getsockopt(b->num, IPPROTO_SCTP, SCTP_PEER_AUTH_CHUNKS,
authchunks, &optlen);
if (b1->rbuf.len != b1->req_buf_len)
if (ring_buf_init(&b1->rbuf, b1->req_buf_len) == 0) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_BIO, ERR_R_BIO_LIB);
return 0;
}
if (b2->rbuf.len != b2->req_buf_len)
if (ring_buf_init(&b2->rbuf, b2->req_buf_len) == 0) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_BIO, ERR_R_BIO_LIB);
ring_buf_destroy(&b1->rbuf);
return 0;
}
if (inl < 0)
return 0;
- if ((buf = OPENSSL_malloc(inl + 1)) == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if ((buf = OPENSSL_malloc(inl + 1)) == NULL)
return 0;
- }
memcpy(buf, in, inl);
buf[inl] = '\0';
if (bbm->use_dgrams) {
struct buf_mem_dgram_st *dgram = OPENSSL_malloc(sizeof(*dgram));
- if (dgram == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if (dgram == NULL)
goto end;
- }
dgram->dgram = bbm->buf->data + blen;
dgram->dgramlen = inl;
bn_check_top(mod);
- if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
return NULL;
- }
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_BN, ERR_R_CRYPTO_LIB);
OPENSSL_free(ret);
return NULL;
}
if (BN_is_zero(a))
return OPENSSL_strdup("0");
buf = OPENSSL_malloc(a->top * BN_BYTES * 2 + 2);
- if (buf == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if (buf == NULL)
goto err;
- }
p = buf;
if (a->neg)
*p++ = '-';
bn_data_num = num / BN_DEC_NUM + 1;
bn_data = OPENSSL_malloc(bn_data_num * sizeof(BN_ULONG));
buf = OPENSSL_malloc(tbytes);
- if (buf == NULL || bn_data == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if (buf == NULL || bn_data == NULL)
goto err;
- }
if ((t = BN_dup(a)) == NULL)
goto err;
{
BN_CTX *ret;
- if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
return NULL;
- }
/* Initialise the structure */
BN_POOL_init(&ret->pool);
BN_STACK_init(&ret->stack);
st->size ? (st->size * 3 / 2) : BN_CTX_START_FRAMES;
unsigned int *newitems;
- if ((newitems = OPENSSL_malloc(sizeof(*newitems) * newsize)) == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if ((newitems = OPENSSL_malloc(sizeof(*newitems) * newsize)) == NULL)
return 0;
- }
if (st->depth)
memcpy(newitems, st->indexes, sizeof(*newitems) * st->depth);
OPENSSL_free(st->indexes);
if (p->used == p->size) {
BN_POOL_ITEM *item;
- if ((item = OPENSSL_malloc(sizeof(*item))) == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if ((item = OPENSSL_malloc(sizeof(*item))) == NULL)
return NULL;
- }
for (loop = 0, bn = item->vals; loop++ < BN_CTX_POOL_SIZE; bn++) {
bn_init(bn);
if ((flag & BN_FLG_SECURE) != 0)
if (ctx == NULL) {
ctx = new_ctx = BN_CTX_new_ex(NULL);
if (ctx == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_BN, ERR_R_BN_LIB);
return NULL;
}
}
bn_check_top(p);
arr = OPENSSL_malloc(sizeof(*arr) * max);
- if (arr == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if (arr == NULL)
return 0;
- }
ret = BN_GF2m_poly2arr(p, arr, max);
if (!ret || ret > max) {
ERR_raise(ERR_LIB_BN, BN_R_INVALID_LENGTH);
bn_check_top(p);
arr = OPENSSL_malloc(sizeof(*arr) * max);
- if (arr == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if (arr == NULL)
return 0;
- }
ret = BN_GF2m_poly2arr(p, arr, max);
if (!ret || ret > max) {
ERR_raise(ERR_LIB_BN, BN_R_INVALID_LENGTH);
bn_check_top(p);
arr = OPENSSL_malloc(sizeof(*arr) * max);
- if (arr == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if (arr == NULL)
return 0;
- }
ret = BN_GF2m_poly2arr(p, arr, max);
if (!ret || ret > max) {
ERR_raise(ERR_LIB_BN, BN_R_INVALID_LENGTH);
bn_check_top(p);
arr = OPENSSL_malloc(sizeof(*arr) * max);
- if (arr == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if (arr == NULL)
return 0;
- }
ret = BN_GF2m_poly2arr(p, arr, max);
if (!ret || ret > max) {
ERR_raise(ERR_LIB_BN, BN_R_INVALID_LENGTH);
bn_check_top(p);
arr = OPENSSL_malloc(sizeof(*arr) * max);
- if (arr == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if (arr == NULL)
goto err;
- }
ret = BN_GF2m_poly2arr(p, arr, max);
if (!ret || ret > max) {
ERR_raise(ERR_LIB_BN, BN_R_INVALID_LENGTH);
if (BN_is_zero(scalar)) {
r = OPENSSL_malloc(1);
- if (r == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if (r == NULL)
goto err;
- }
r[0] = 0;
*ret_len = 1;
return r;
* (*ret_len will be set to the actual length, i.e. at most
* BN_num_bits(scalar) + 1)
*/
- if (r == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if (r == NULL)
goto err;
- }
window_val = scalar->d[0] & mask;
j = 0;
while ((window_val != 0) || (j + w + 1 < len)) { /* if j+w+1 >= len,
int bn_set_words(BIGNUM *a, const BN_ULONG *words, int num_words)
{
if (bn_wexpand(a, num_words) == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_BN, ERR_R_BN_LIB);
return 0;
}
{
BIGNUM *ret;
- if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
return NULL;
- }
ret->flags = BN_FLG_MALLOCED;
bn_check_top(ret);
return ret;
a = OPENSSL_secure_zalloc(words * sizeof(*a));
else
a = OPENSSL_zalloc(words * sizeof(*a));
- if (a == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if (a == NULL)
return NULL;
- }
assert(b->top <= words);
if (b->top > 0)
{
BN_GENCB *ret;
- if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL)
return NULL;
- }
return ret;
}
if (mtop > sizeof(storage) / sizeof(storage[0])) {
tp = OPENSSL_malloc(mtop * sizeof(BN_ULONG));
- if (tp == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if (tp == NULL)
return 0;
- }
}
ap = a->d != NULL ? a->d : tp;
{
BN_MONT_CTX *ret;
- if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL)
return NULL;
- }
BN_MONT_CTX_init(ret);
ret->flags = BN_FLG_MALLOCED;
}
mods = OPENSSL_zalloc(sizeof(*mods) * NUMPRIMES);
- if (mods == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if (mods == NULL)
return 0;
- }
BN_CTX_start(ctx);
t = BN_CTX_get(ctx);
mask = 0xff << (bit + 1);
buf = OPENSSL_malloc(bytes);
- if (buf == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if (buf == NULL)
goto err;
- }
/* make a random number and set the top and bottom bits */
b = flag == NORMAL ? RAND_bytes_ex(libctx, buf, bytes, strength)
{
BN_RECP_CTX *ret;
- if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
- ERR_raise(ERR_LIB_BN, ERR_R_MALLOC_FAILURE);
+ if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
return NULL;
- }
bn_init(&(ret->N));
bn_init(&(ret->Nr));
BUF_MEM *ret;
ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_BUF, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
return ret;
}
}
/* This limit is sufficient to ensure (len+3)/3*4 < 2**31 */
if (len > LIMIT_BEFORE_EXPANSION) {
- ERR_raise(ERR_LIB_BUF, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_BUF, ERR_R_PASSED_INVALID_ARGUMENT);
return 0;
}
n = (len + 3) / 3 * 4;
else
ret = OPENSSL_realloc(str->data, n);
if (ret == NULL) {
- ERR_raise(ERR_LIB_BUF, ERR_R_MALLOC_FAILURE);
len = 0;
} else {
str->data = ret;
}
/* This limit is sufficient to ensure (len+3)/3*4 < 2**31 */
if (len > LIMIT_BEFORE_EXPANSION) {
- ERR_raise(ERR_LIB_BUF, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_BUF, ERR_R_PASSED_INVALID_ARGUMENT);
return 0;
}
n = (len + 3) / 3 * 4;
else
ret = OPENSSL_clear_realloc(str->data, str->max, n);
if (ret == NULL) {
- ERR_raise(ERR_LIB_BUF, ERR_R_MALLOC_FAILURE);
len = 0;
} else {
str->data = ret;
{
CMAC_CTX *ctx;
- if ((ctx = OPENSSL_malloc(sizeof(*ctx))) == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if ((ctx = OPENSSL_malloc(sizeof(*ctx))) == NULL)
return NULL;
- }
ctx->cctx = EVP_CIPHER_CTX_new();
if (ctx->cctx == NULL) {
OPENSSL_free(ctx);
ctx->libctx = libctx;
if (propq != NULL && (ctx->propq = OPENSSL_strdup(propq)) == NULL)
- goto oom;
+ goto err;
ctx->log_verbosity = OSSL_CMP_LOG_INFO;
ctx->keep_alive = 1;
ctx->msg_timeout = -1;
- if ((ctx->untrusted = sk_X509_new_null()) == NULL)
- goto oom;
+ if ((ctx->untrusted = sk_X509_new_null()) == NULL) {
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
ctx->pbm_slen = 16;
if (!cmp_ctx_set_md(ctx, &ctx->pbm_owf, NID_sha256))
/* all other elements are initialized to 0 or NULL, respectively */
return ctx;
- oom:
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
err:
OSSL_CMP_CTX_free(ctx);
return NULL;
msg = OSSL_CMP_MSG_new(libctx, propq);
if (msg == NULL) {
- ERR_raise(ERR_LIB_CMP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMP, ERR_R_CMP_LIB);
return NULL;
}
CMS_DigestedData *dd;
if (mctx == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB);
goto err;
}
b = BIO_new(BIO_f_cipher());
if (b == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_BIO_LIB);
return NULL;
}
/* Generate random session key */
if (!enc || !ec->key) {
tkey = OPENSSL_malloc(tkeylen);
- if (tkey == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ if (tkey == NULL)
goto err;
- }
if (EVP_CIPHER_CTX_rand_key(ctx, tkey) <= 0)
goto err;
}
if (enc) {
calg->parameter = ASN1_TYPE_new();
if (calg->parameter == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
goto err;
}
if ((EVP_CIPHER_get_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER)) {
{
ec->cipher = cipher;
if (key) {
- if ((ec->key = OPENSSL_malloc(keylen)) == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ if ((ec->key = OPENSSL_malloc(keylen)) == NULL)
return 0;
- }
memcpy(ec->key, key, keylen);
}
ec->keylen = keylen;
if (ciph) {
cms->d.encryptedData = M_ASN1_new_of(CMS_EncryptedData);
if (!cms->d.encryptedData) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
return 0;
}
cms->contentType = OBJ_nid2obj(NID_pkcs7_encrypted);
if (cms->d.other == NULL) {
cms->d.envelopedData = M_ASN1_new_of(CMS_EnvelopedData);
if (cms->d.envelopedData == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
return NULL;
}
cms->d.envelopedData->version = 0;
if (cms->d.other == NULL) {
cms->d.authEnvelopedData = M_ASN1_new_of(CMS_AuthEnvelopedData);
if (cms->d.authEnvelopedData == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
return NULL;
}
/* Defined in RFC 5083 - Section 2.1. "AuthEnvelopedData Type" */
cms = CMS_ContentInfo_new_ex(libctx, propq);
if (cms == NULL)
- goto merr;
+ goto err;
env = cms_enveloped_data_init(cms);
if (env == NULL)
- goto merr;
+ goto err;
if (!ossl_cms_EncryptedContent_init(env->encryptedContentInfo, cipher, NULL,
0, ossl_cms_get0_cmsctx(cms)))
- goto merr;
+ goto err;
return cms;
- merr:
+ err:
CMS_ContentInfo_free(cms);
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
return NULL;
}
return cms;
merr:
CMS_ContentInfo_free(cms);
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
return NULL;
}
/* Initialize recipient info */
ri = M_ASN1_new_of(CMS_RecipientInfo);
- if (ri == NULL)
- goto merr;
+ if (ri == NULL) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
+ goto err;
+ }
pk = X509_get0_pubkey(recip);
if (pk == NULL) {
}
- if (!sk_CMS_RecipientInfo_push(ris, ri))
- goto merr;
+ if (!sk_CMS_RecipientInfo_push(ris, ri)) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
return ri;
- merr:
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
err:
M_ASN1_free_of(ri, CMS_RecipientInfo);
return NULL;
goto err;
ek = OPENSSL_malloc(eklen);
-
- if (ek == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ if (ek == NULL)
goto err;
- }
if (EVP_PKEY_encrypt(pctx, ek, &eklen, ec->key, ec->keylen) <= 0)
goto err;
goto err;
ek = OPENSSL_malloc(eklen);
- if (ek == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ if (ek == NULL)
goto err;
- }
if (EVP_PKEY_decrypt(ktri->pctx, ek, &eklen,
ktri->encryptedKey->data,
/* Initialize recipient info */
ri = M_ASN1_new_of(CMS_RecipientInfo);
- if (!ri)
- goto merr;
+ if (!ri) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
+ goto err;
+ }
ri->d.kekri = M_ASN1_new_of(CMS_KEKRecipientInfo);
- if (!ri->d.kekri)
- goto merr;
+ if (!ri->d.kekri) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
+ goto err;
+ }
ri->type = CMS_RECIPINFO_KEK;
kekri = ri->d.kekri;
if (otherTypeId) {
kekri->kekid->other = M_ASN1_new_of(CMS_OtherKeyAttribute);
- if (kekri->kekid->other == NULL)
- goto merr;
+ if (kekri->kekid->other == NULL) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
+ goto err;
+ }
}
- if (!sk_CMS_RecipientInfo_push(ris, ri))
- goto merr;
+ if (!sk_CMS_RecipientInfo_push(ris, ri)) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
/* After this point no calls can fail */
return ri;
- merr:
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
err:
M_ASN1_free_of(ri, CMS_RecipientInfo);
return NULL;
/* 8 byte prefix for AES wrap ciphers */
wkey = OPENSSL_malloc(ec->keylen + 8);
- if (wkey == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ if (wkey == NULL)
goto err;
- }
ctx = EVP_CIPHER_CTX_new();
if (ctx == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB);
goto err;
}
}
ukey = OPENSSL_malloc(kekri->encryptedKey->length - 8);
- if (ukey == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ if (ukey == NULL)
goto err;
- }
ctx = EVP_CIPHER_CTX_new();
if (ctx == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB);
goto err;
}
env->unprotectedAttrs = sk_X509_ATTRIBUTE_new_null();
if (env->unprotectedAttrs == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_CRYPTO_LIB);
return 0;
}
CMS_ReceiptRequest *rr;
rr = CMS_ReceiptRequest_new();
- if (rr == NULL)
- goto merr;
+ if (rr == NULL) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
+ goto err;
+ }
if (id)
ASN1_STRING_set0(rr->signedContentIdentifier, id, idlen);
else {
- if (!ASN1_STRING_set(rr->signedContentIdentifier, NULL, 32))
- goto merr;
+ if (!ASN1_STRING_set(rr->signedContentIdentifier, NULL, 32)) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
+ goto err;
+ }
if (RAND_bytes_ex(libctx, rr->signedContentIdentifier->data, 32,
0) <= 0)
goto err;
return rr;
- merr:
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
-
err:
CMS_ReceiptRequest_free(rr);
return NULL;
int rrderlen, r = 0;
rrderlen = i2d_CMS_ReceiptRequest(rr, &rrder);
- if (rrderlen < 0)
- goto merr;
+ if (rrderlen < 0) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
+ goto err;
+ }
if (!CMS_signed_add1_attr_by_NID(si, NID_id_smime_aa_receiptRequest,
- V_ASN1_SEQUENCE, rrder, rrderlen))
- goto merr;
+ V_ASN1_SEQUENCE, rrder, rrderlen)) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
+ goto err;
+ }
r = 1;
- merr:
- if (!r)
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
-
+ err:
OPENSSL_free(rrder);
return r;
}
if (!CMS_signed_add1_attr_by_NID(dest, NID_id_smime_aa_msgSigDigest,
V_ASN1_OCTET_STRING, dig, diglen)) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
return 0;
}
return 1;
int CMS_stream(unsigned char ***boundary, CMS_ContentInfo *cms)
{
ASN1_OCTET_STRING **pos;
+
pos = CMS_get0_content(cms);
if (pos == NULL)
return 0;
*boundary = &(*pos)->data;
return 1;
}
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
return 0;
}
if (ci->ctx.propq == NULL) {
CMS_ContentInfo_free(ci);
ci = NULL;
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
}
}
}
(*pos)->flags |= ASN1_STRING_FLAG_CONT;
return 1;
}
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
return 0;
}
{
CMS_IssuerAndSerialNumber *ias;
ias = M_ASN1_new_of(CMS_IssuerAndSerialNumber);
- if (!ias)
+ if (!ias) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
goto err;
- if (!X509_NAME_set(&ias->issuer, X509_get_issuer_name(cert)))
+ }
+ if (!X509_NAME_set(&ias->issuer, X509_get_issuer_name(cert))) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_X509_LIB);
goto err;
- if (!ASN1_STRING_copy(ias->serialNumber, X509_get0_serialNumber(cert)))
+ }
+ if (!ASN1_STRING_copy(ias->serialNumber, X509_get0_serialNumber(cert))) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
goto err;
+ }
M_ASN1_free_of(*pias, CMS_IssuerAndSerialNumber);
*pias = ias;
return 1;
err:
M_ASN1_free_of(ias, CMS_IssuerAndSerialNumber);
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
return 0;
}
}
keyid = ASN1_STRING_dup(cert_keyid);
if (!keyid) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
return 0;
}
ASN1_OCTET_STRING_free(*pkeyid);
/* Setup algorithm identifier for cipher */
encalg = X509_ALGOR_new();
if (encalg == NULL) {
- goto merr;
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
+ goto err;
}
ctx = EVP_CIPHER_CTX_new();
if (ctx == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB);
goto err;
}
}
encalg->parameter = ASN1_TYPE_new();
if (!encalg->parameter) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
goto err;
}
if (EVP_CIPHER_param_to_asn1(ctx, encalg->parameter) <= 0) {
/* Initialize recipient info */
ri = M_ASN1_new_of(CMS_RecipientInfo);
- if (ri == NULL)
- goto merr;
+ if (ri == NULL) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
+ goto err;
+ }
ri->d.pwri = M_ASN1_new_of(CMS_PasswordRecipientInfo);
- if (ri->d.pwri == NULL)
- goto merr;
+ if (ri->d.pwri == NULL) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
+ goto err;
+ }
ri->type = CMS_RECIPINFO_PASS;
pwri = ri->d.pwri;
/* Since this is overwritten, free up empty structure already there */
X509_ALGOR_free(pwri->keyEncryptionAlgorithm);
pwri->keyEncryptionAlgorithm = X509_ALGOR_new();
- if (pwri->keyEncryptionAlgorithm == NULL)
- goto merr;
+ if (pwri->keyEncryptionAlgorithm == NULL) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
+ goto err;
+ }
pwri->keyEncryptionAlgorithm->algorithm = OBJ_nid2obj(wrap_nid);
pwri->keyEncryptionAlgorithm->parameter = ASN1_TYPE_new();
- if (pwri->keyEncryptionAlgorithm->parameter == NULL)
- goto merr;
+ if (pwri->keyEncryptionAlgorithm->parameter == NULL) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
+ goto err;
+ }
if (!ASN1_item_pack(encalg, ASN1_ITEM_rptr(X509_ALGOR),
&pwri->keyEncryptionAlgorithm->parameter->
- value.sequence))
- goto merr;
+ value.sequence)) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
+ goto err;
+ }
pwri->keyEncryptionAlgorithm->parameter->type = V_ASN1_SEQUENCE;
X509_ALGOR_free(encalg);
CMS_RecipientInfo_set0_password(ri, pass, passlen);
pwri->version = 0;
- if (!sk_CMS_RecipientInfo_push(ris, ri))
- goto merr;
+ if (!sk_CMS_RecipientInfo_push(ris, ri)) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
return ri;
- merr:
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
err:
EVP_CIPHER_CTX_free(ctx);
if (ri)
/* Invalid size */
return 0;
}
- if ((tmp = OPENSSL_malloc(inlen)) == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ if ((tmp = OPENSSL_malloc(inlen)) == NULL)
return 0;
- }
/* setup IV by decrypting last two blocks */
if (!EVP_DecryptUpdate(ctx, tmp + inlen - 2 * blocklen, &outl,
in + inlen - 2 * blocklen, blocklen * 2)
kekctx = EVP_CIPHER_CTX_new();
if (kekctx == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB);
goto err;
}
/* Fixup cipher based on AlgorithmIdentifier to set IV etc */
pwri->encryptedKey->length = keylen;
} else {
key = OPENSSL_malloc(pwri->encryptedKey->length);
-
- if (key == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ if (key == NULL)
goto err;
- }
if (!kek_unwrap_key(key, &keylen,
pwri->encryptedKey->data,
pwri->encryptedKey->length, kekctx)) {
if (cms->d.other == NULL) {
cms->d.signedData = M_ASN1_new_of(CMS_SignedData);
if (!cms->d.signedData) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
return NULL;
}
cms->d.signedData->version = 1;
if (!sd)
goto err;
si = M_ASN1_new_of(CMS_SignerInfo);
- if (!si)
- goto merr;
+ if (!si) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
+ goto err;
+ }
/* Call for side-effect of computing hash and caching extensions */
X509_check_purpose(signer, -1, -1);
si->pctx = NULL;
if (si->mctx == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB);
goto err;
}
}
if (i == sk_X509_ALGOR_num(sd->digestAlgorithms)) {
- if ((alg = X509_ALGOR_new()) == NULL)
- goto merr;
+ if ((alg = X509_ALGOR_new()) == NULL) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_ASN1_LIB);
+ goto err;
+ }
X509_ALGOR_set_md(alg, md);
if (!sk_X509_ALGOR_push(sd->digestAlgorithms, alg)) {
X509_ALGOR_free(alg);
- goto merr;
+ ERR_raise(ERR_LIB_CMS, ERR_R_CRYPTO_LIB);
+ goto err;
}
}
*/
if (!si->signedAttrs) {
si->signedAttrs = sk_X509_ATTRIBUTE_new_null();
- if (!si->signedAttrs)
- goto merr;
+ if (!si->signedAttrs) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
}
if (!(flags & CMS_NOSMIMECAP)) {
if (i)
i = CMS_add_smimecap(si, smcap);
sk_X509_ALGOR_pop_free(smcap, X509_ALGOR_free);
- if (!i)
- goto merr;
+ if (!i) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
+ goto err;
+ }
}
if (flags & CMS_CADES) {
ESS_SIGNING_CERT *sc = NULL;
if (!(flags & CMS_NOCERTS)) {
/* NB ignore -1 return for duplicate cert */
- if (!CMS_add1_cert(cms, signer))
- goto merr;
+ if (!CMS_add1_cert(cms, signer)) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
+ goto err;
+ }
}
if (flags & CMS_KEY_PARAM) {
}
}
- if (!sd->signerInfos)
+ if (sd->signerInfos == NULL)
sd->signerInfos = sk_CMS_SignerInfo_new_null();
- if (!sd->signerInfos || !sk_CMS_SignerInfo_push(sd->signerInfos, si))
- goto merr;
+ if (sd->signerInfos == NULL || !sk_CMS_SignerInfo_push(sd->signerInfos, si)) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
return si;
- merr:
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
err:
M_ASN1_free_of(si, CMS_SignerInfo);
return NULL;
else
tt = X509_gmtime_adj(NULL, 0);
- if (tt == NULL)
- goto merr;
+ if (tt == NULL) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_X509_LIB);
+ goto err;
+ }
if (CMS_signed_add1_attr_by_NID(si, NID_pkcs9_signingTime,
- tt->type, tt, -1) <= 0)
- goto merr;
+ tt->type, tt, -1) <= 0) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
+ goto err;
+ }
r = 1;
- merr:
+ err:
if (t == NULL)
ASN1_TIME_free(tt);
- if (!r)
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
-
return r;
}
const CMS_CTX *ctx = ossl_cms_get0_cmsctx(cms);
if (mctx == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
return 0;
}
}
siglen = EVP_PKEY_get_size(si->pkey);
sig = OPENSSL_malloc(siglen);
- if (sig == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ if (sig == NULL)
goto err;
- }
if (EVP_PKEY_sign(pctx, sig, &siglen, md, mdlen) <= 0) {
OPENSSL_free(sig);
goto err;
goto err;
}
sig = OPENSSL_malloc(EVP_PKEY_get_size(si->pkey));
- if (sig == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ if (sig == NULL)
goto err;
- }
if (!EVP_SignFinal_ex(mctx, sig, &siglen, si->pkey,
ossl_cms_ctx_get0_libctx(ctx),
ossl_cms_ctx_get0_propq(ctx))) {
(void)ERR_pop_to_mark();
if (si->mctx == NULL && (si->mctx = EVP_MD_CTX_new()) == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB);
goto err;
}
mctx = si->mctx;
unsigned int mlen;
if (mctx == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_EVP_LIB);
goto err;
}
/* If we have any signed attributes look for messageDigest value */
tmpout = cms_get_text_bio(out, flags);
if (tmpout == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
goto err;
}
ctx = X509_STORE_CTX_new_ex(ossl_cms_ctx_get0_libctx(cms_ctx),
ossl_cms_ctx_get0_propq(cms_ctx));
if (ctx == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_X509_LIB);
goto err;
}
CMS_SignerInfo_get0_algs(si, NULL, &signer, NULL, NULL);
if (cadesVerify) {
/* Certificate trust chain is required to check CAdES signature */
si_chains = OPENSSL_zalloc(scount * sizeof(si_chains[0]));
- if (si_chains == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ if (si_chains == NULL)
goto err;
- }
}
cms_certs = CMS_get1_certs(cms);
if (!(flags & CMS_NOCRL))
len = BIO_get_mem_data(dcont, &ptr);
tmpin = (len == 0) ? dcont : BIO_new_mem_buf(ptr, len);
if (tmpin == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_BIO_LIB);
goto err2;
}
} else {
*/
tmpout = cms_get_text_bio(out, flags);
if (tmpout == NULL) {
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
goto err;
}
cmsbio = CMS_dataInit(cms, tmpout);
int i;
cms = CMS_ContentInfo_new_ex(libctx, propq);
- if (cms == NULL || !CMS_SignedData_init(cms))
- goto merr;
+ if (cms == NULL || !CMS_SignedData_init(cms)) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
+ goto err;
+ }
if (flags & CMS_ASCIICRLF
&& !CMS_set1_eContentType(cms,
- OBJ_nid2obj(NID_id_ct_asciiTextWithCRLF)))
+ OBJ_nid2obj(NID_id_ct_asciiTextWithCRLF))) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
goto err;
+ }
if (pkey != NULL && !CMS_add1_signer(cms, signcert, pkey, NULL, flags)) {
ERR_raise(ERR_LIB_CMS, CMS_R_ADD_SIGNER_ERROR);
for (i = 0; i < sk_X509_num(certs); i++) {
X509 *x = sk_X509_value(certs, i);
- if (!CMS_add1_cert(cms, x))
- goto merr;
+ if (!CMS_add1_cert(cms, x)) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
+ goto err;
+ }
}
if (!(flags & CMS_DETACHED))
else
goto err;
- merr:
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
-
err:
CMS_ContentInfo_free(cms);
return NULL;
cms = (EVP_CIPHER_get_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER)
? CMS_AuthEnvelopedData_create_ex(cipher, libctx, propq)
: CMS_EnvelopedData_create_ex(cipher, libctx, propq);
- if (cms == NULL)
- goto merr;
+ if (cms == NULL) {
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
+ goto err;
+ }
for (i = 0; i < sk_X509_num(certs); i++) {
recip = sk_X509_value(certs, i);
if (!CMS_add1_recipient_cert(cms, recip, flags)) {
|| CMS_final(cms, data, NULL, flags))
return cms;
else
- goto err;
+ ERR_raise(ERR_LIB_CMS, ERR_R_CMS_LIB);
- merr:
- ERR_raise(ERR_LIB_CMS, ERR_R_MALLOC_FAILURE);
err:
CMS_ContentInfo_free(cms);
return NULL;
}
# endif
ctx = OPENSSL_zalloc(sizeof(*ctx));
- if (ctx == NULL) {
- ERR_raise(ERR_LIB_COMP, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL)
return 0;
- }
ctx->ibufsize = ZLIB_DEFAULT_BUFSIZE;
ctx->obufsize = ZLIB_DEFAULT_BUFSIZE;
ctx->zin.zalloc = Z_NULL;
BIO_clear_retry_flags(b);
if (!ctx->ibuf) {
ctx->ibuf = OPENSSL_malloc(ctx->ibufsize);
- if (ctx->ibuf == NULL) {
- ERR_raise(ERR_LIB_COMP, ERR_R_MALLOC_FAILURE);
+ if (ctx->ibuf == NULL)
return 0;
- }
if ((ret = inflateInit(zin)) != Z_OK) {
ERR_raise_data(ERR_LIB_COMP, COMP_R_ZLIB_INFLATE_ERROR,
"zlib error: %s", zError(ret));
if (!ctx->obuf) {
ctx->obuf = OPENSSL_malloc(ctx->obufsize);
/* Need error here */
- if (ctx->obuf == NULL) {
- ERR_raise(ERR_LIB_COMP, ERR_R_MALLOC_FAILURE);
+ if (ctx->obuf == NULL)
return 0;
- }
ctx->optr = ctx->obuf;
ctx->ocount = 0;
if ((ret = deflateInit(zout, ctx->comp_level)) != Z_OK) {
{
COMP_CTX *ret;
- if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
- ERR_raise(ERR_LIB_COMP, ERR_R_MALLOC_FAILURE);
+ if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
return NULL;
- }
ret->meth = meth;
if ((ret->meth->init != NULL) && !ret->meth->init(ret)) {
OPENSSL_free(ret);
}
section = OPENSSL_strdup("default");
- if (section == NULL) {
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ if (section == NULL)
goto err;
- }
if (_CONF_new_data(conf) == 0) {
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CONF, ERR_R_CONF_LIB);
goto err;
}
goto err;
} else if (strcmp(p, "includedir") == 0) {
OPENSSL_free(conf->includedir);
- if ((conf->includedir = OPENSSL_strdup(pval)) == NULL) {
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ if ((conf->includedir = OPENSSL_strdup(pval)) == NULL)
goto err;
- }
}
/*
include_path = OPENSSL_malloc(newlen);
if (include_path == NULL) {
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
OPENSSL_free(include);
goto err;
}
/* push the currently processing BIO onto stack */
if (biosk == NULL) {
if ((biosk = sk_BIO_new_null()) == NULL) {
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CONF, ERR_R_CRYPTO_LIB);
BIO_free(next);
goto err;
}
}
if (!sk_BIO_push(biosk, in)) {
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CONF, ERR_R_CRYPTO_LIB);
BIO_free(next);
goto err;
}
start = eat_ws(conf, p);
trim_ws(conf, start);
- if ((v = OPENSSL_malloc(sizeof(*v))) == NULL) {
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ if ((v = OPENSSL_malloc(sizeof(*v))) == NULL)
goto err;
- }
v->name = OPENSSL_strdup(pname);
v->value = NULL;
- if (v->name == NULL) {
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ if (v->name == NULL)
goto err;
- }
if (!str_copy(conf, psection, &(v->value), start))
goto err;
} else
tv = sv;
if (_CONF_add_string(conf, tv, v) == 0) {
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CONF, ERR_R_CONF_LIB);
goto err;
}
v = NULL;
goto err;
}
if (!BUF_MEM_grow_clean(buf, newsize)) {
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CONF, ERR_R_BUF_LIB);
goto err;
}
while (*p)
newlen = pathlen + namelen + 2;
newpath = OPENSSL_zalloc(newlen);
- if (newpath == NULL) {
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ if (newpath == NULL)
break;
- }
#ifdef OPENSSL_SYS_VMS
/*
* If the given path isn't clear VMS syntax,
ret = meth->create(meth);
if (ret == NULL) {
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CONF, ERR_R_CONF_LIB);
return NULL;
}
ret->libctx = libctx;
{
module_list_lock = CRYPTO_THREAD_lock_new();
if (module_list_lock == NULL) {
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CONF, ERR_R_CRYPTO_LIB);
return 0;
}
supported_modules = sk_CONF_MODULE_new_null();
if (supported_modules == NULL)
goto err;
- if ((tmod = OPENSSL_zalloc(sizeof(*tmod))) == NULL) {
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ if ((tmod = OPENSSL_zalloc(sizeof(*tmod))) == NULL)
goto err;
- }
tmod->dso = dso;
tmod->name = OPENSSL_strdup(name);
initialized_modules = sk_CONF_IMODULE_new_null();
if (initialized_modules == NULL) {
CRYPTO_THREAD_unlock(module_list_lock);
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CONF, ERR_R_CRYPTO_LIB);
goto err;
}
}
if (!sk_CONF_IMODULE_push(initialized_modules, imod)) {
CRYPTO_THREAD_unlock(module_list_lock);
- ERR_raise(ERR_LIB_CONF, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CONF, ERR_R_CRYPTO_LIB);
goto err;
}
first_name_len = first_name_end - algo->algorithm_names;
ret = OPENSSL_strndup(algo->algorithm_names, first_name_len);
- if (ret == NULL)
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
return ret;
}
outlen = (inlen / 4) * 3;
outbuf = OPENSSL_malloc(outlen);
- if (outbuf == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if (outbuf == NULL)
goto err;
- }
outlen = EVP_DecodeBlock(outbuf, (unsigned char *)in, inlen);
if (outlen < 0) {
int declen;
if (sct == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CT, ERR_R_CT_LIB);
return NULL;
}
{
CTLOG_STORE_LOAD_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
- if (ctx == NULL)
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
-
return ctx;
}
{
CTLOG_STORE *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->libctx = libctx;
if (propq != NULL) {
ret->propq = OPENSSL_strdup(propq);
- if (ret->propq == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if (ret->propq == NULL)
goto err;
- }
}
ret->logs = sk_CTLOG_new_null();
if (ret->logs == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CT, ERR_R_CRYPTO_LIB);
goto err;
}
tmp = OPENSSL_strndup(log_name, log_name_len);
if (tmp == NULL)
- goto mem_err;
+ return -1;
ret = ctlog_new_from_conf(load_ctx->log_store, &ct_log, load_ctx->conf, tmp);
OPENSSL_free(tmp);
}
if (!sk_CTLOG_push(load_ctx->log_store->logs, ct_log)) {
- goto mem_err;
+ CTLOG_free(ct_log);
+ ERR_raise(ERR_LIB_CT, ERR_R_CRYPTO_LIB);
+ return -1;
}
return 1;
-
-mem_err:
- CTLOG_free(ct_log);
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
- return -1;
}
int CTLOG_STORE_load_file(CTLOG_STORE *store, const char *file)
{
CTLOG *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->libctx = libctx;
if (propq != NULL) {
ret->propq = OPENSSL_strdup(propq);
- if (ret->propq == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if (ret->propq == NULL)
goto err;
- }
}
ret->name = OPENSSL_strdup(name);
- if (ret->name == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if (ret->name == NULL)
goto err;
- }
if (ct_v1_log_id_from_pkey(ret, public_key) != 1)
goto err;
*out += len;
} else {
pstart = p = OPENSSL_malloc(len);
- if (p == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if (p == NULL)
goto err;
- }
*out = p;
}
*out += len;
} else {
pstart = p = OPENSSL_malloc(len);
- if (p == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if (p == NULL)
goto err;
- }
*out = p;
}
ERR_raise(ERR_LIB_CT, CT_R_SCT_LIST_INVALID);
return -1;
}
- if ((*pp = OPENSSL_malloc(len)) == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if ((*pp = OPENSSL_malloc(len)) == NULL)
return -1;
- }
is_pp_new = 1;
}
p = *pp + 2;
CT_POLICY_EVAL_CTX *ctx = OPENSSL_zalloc(sizeof(CT_POLICY_EVAL_CTX));
OSSL_TIME now;
- if (ctx == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL)
return NULL;
- }
ctx->libctx = libctx;
if (propq != NULL) {
ctx->propq = OPENSSL_strdup(propq);
if (ctx->propq == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
OPENSSL_free(ctx);
return NULL;
}
{
SCT *sct = OPENSSL_zalloc(sizeof(*sct));
- if (sct == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if (sct == NULL)
return NULL;
- }
sct->entry_type = CT_LOG_ENTRY_TYPE_NOT_SET;
sct->version = SCT_VERSION_NOT_SET;
if (log_id != NULL && log_id_len > 0) {
sct->log_id = OPENSSL_memdup(log_id, log_id_len);
- if (sct->log_id == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if (sct->log_id == NULL)
return 0;
- }
sct->log_id_len = log_id_len;
}
return 1;
if (ext != NULL && ext_len > 0) {
sct->ext = OPENSSL_memdup(ext, ext_len);
- if (sct->ext == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if (sct->ext == NULL)
return 0;
- }
sct->ext_len = ext_len;
}
return 1;
if (sig != NULL && sig_len > 0) {
sct->sig = OPENSSL_memdup(sig, sig_len);
- if (sct->sig == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if (sct->sig == NULL)
return 0;
- }
sct->sig_len = sig_len;
}
return 1;
{
SCT_CTX *sctx = OPENSSL_zalloc(sizeof(*sctx));
- if (sctx == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
+ if (sctx == NULL)
return NULL;
- }
sctx->libctx = libctx;
if (propq != NULL) {
sctx->propq = OPENSSL_strdup(propq);
if (sctx->propq == NULL) {
- ERR_raise(ERR_LIB_CT, ERR_R_MALLOC_FAILURE);
OPENSSL_free(sctx);
return NULL;
}
str = ASN1_STRING_new();
if (str == NULL) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DH, ERR_R_ASN1_LIB);
goto err;
}
str->length = i2d_dhp(pkey, dh, &str->data);
if (str->length <= 0) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DH, ERR_R_ASN1_LIB);
goto err;
}
ptype = V_ASN1_SEQUENCE;
ASN1_INTEGER_free(pub_key);
if (penclen <= 0) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DH, ERR_R_ASN1_LIB);
goto err;
}
params = ASN1_STRING_new();
if (params == NULL) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DH, ERR_R_ASN1_LIB);
goto err;
}
params->length = i2d_dhp(pkey, pkey->pkey.dh, ¶ms->data);
if (params->length <= 0) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DH, ERR_R_ASN1_LIB);
goto err;
}
params->type = V_ASN1_SEQUENCE;
DH *dh = ossl_dh_new_ex(pctx->libctx);
if (dh == NULL) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DH, ERR_R_DH_LIB);
return 0;
}
DH_clear_flags(dh, DH_FLAG_TYPE_MASK);
/*
* Generated by util/mkerr.pl DO NOT EDIT
- * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
"invalid parameter nid"},
{ERR_PACK(ERR_LIB_DH, 0, DH_R_INVALID_PUBKEY), "invalid public key"},
{ERR_PACK(ERR_LIB_DH, 0, DH_R_INVALID_SECRET), "invalid secret"},
+ {ERR_PACK(ERR_LIB_DH, 0, DH_R_INVALID_SIZE), "invalid size"},
{ERR_PACK(ERR_LIB_DH, 0, DH_R_KDF_PARAMETER_ERROR), "kdf parameter error"},
{ERR_PACK(ERR_LIB_DH, 0, DH_R_KEYS_NOT_SET), "keys not set"},
{ERR_PACK(ERR_LIB_DH, 0, DH_R_MISSING_PUBKEY), "missing pubkey"},
if (!alloc) {
if (size >= (size_t)p_size)
pbuf = *pbuf_out;
+ if (pbuf == NULL)
+ ERR_raise(ERR_LIB_DH, DH_R_INVALID_SIZE);
} else {
pbuf = OPENSSL_malloc(p_size);
}
- if (pbuf == NULL) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ /* Errors raised above */
+ if (pbuf == NULL)
return 0;
- }
/*
* As per Section 4.2.8.1 of RFC 8446 left pad public
* key with zeros to the size of p
{
DH *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->references = 1;
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DH, ERR_R_CRYPTO_LIB);
OPENSSL_free(ret);
return NULL;
}
OPENSSL_free(dhm);
}
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
return NULL;
}
OPENSSL_free(ret);
}
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
return NULL;
}
{
char *tmpname = OPENSSL_strdup(name);
- if (tmpname == NULL) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ if (tmpname == NULL)
return 0;
- }
OPENSSL_free(dhm->name);
dhm->name = tmpname;
{
DH_PKEY_CTX *dctx;
- if ((dctx = OPENSSL_zalloc(sizeof(*dctx))) == NULL) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ if ((dctx = OPENSSL_zalloc(sizeof(*dctx))) == NULL)
return 0;
- }
dctx->prime_len = 2048;
dctx->subprime_len = -1;
dctx->generator = 2;
ret = 0;
if ((Zlen = DH_size(dh)) <= 0)
return 0;
- if ((Z = OPENSSL_malloc(Zlen)) == NULL) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ if ((Z = OPENSSL_malloc(Zlen)) == NULL)
return 0;
- }
if (DH_compute_key_padded(Z, dhpubbn, dh) <= 0)
goto err;
if (!DH_KDF_X9_42(key, *keylen, Z, Zlen, dctx->kdf_oid,
} else if ((ptype == V_ASN1_NULL) || (ptype == V_ASN1_UNDEF)) {
if ((dsa = DSA_new()) == NULL) {
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSA, ERR_R_DSA_LIB);
goto err;
}
} else {
&& dsa->params.g != NULL) {
str = ASN1_STRING_new();
if (str == NULL) {
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSA, ERR_R_ASN1_LIB);
goto err;
}
str->length = i2d_DSAparams(dsa, &str->data);
if (str->length <= 0) {
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSA, ERR_R_ASN1_LIB);
goto err;
}
ptype = V_ASN1_SEQUENCE;
pubint = BN_to_ASN1_INTEGER(dsa->pub_key, NULL);
if (pubint == NULL) {
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSA, ERR_R_ASN1_LIB);
goto err;
}
ASN1_INTEGER_free(pubint);
if (penclen <= 0) {
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSA, ERR_R_ASN1_LIB);
goto err;
}
params = ASN1_STRING_new();
if (params == NULL) {
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSA, ERR_R_ASN1_LIB);
goto err;
}
params->length = i2d_DSAparams(pkey->pkey.dsa, ¶ms->data);
if (params->length <= 0) {
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSA, ERR_R_ASN1_LIB);
goto err;
}
params->type = V_ASN1_SEQUENCE;
DSA *dsa = ossl_dsa_new(pctx->libctx);
if (dsa == NULL) {
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSA, ERR_R_DSA_LIB);
return 0;
}
}
/* Calculate public key */
if ((dsa_pubkey = BN_new()) == NULL) {
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSA, ERR_R_BN_LIB);
goto dsaerr;
}
if ((ctx = BN_CTX_new()) == NULL) {
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSA, ERR_R_BN_LIB);
goto dsaerr;
}
{
DSA *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->references = 1;
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSA, ERR_R_CRYPTO_LIB);
OPENSSL_free(ret);
return NULL;
}
OPENSSL_free(dsam);
}
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
return NULL;
}
OPENSSL_free(ret);
}
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
return NULL;
}
{
char *tmpname = OPENSSL_strdup(name);
- if (tmpname == NULL) {
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
+ if (tmpname == NULL)
return 0;
- }
OPENSSL_free(dsam->name);
dsam->name = tmpname;
DSA_SIG *DSA_SIG_new(void)
{
DSA_SIG *sig = OPENSSL_zalloc(sizeof(*sig));
- if (sig == NULL)
- ERR_raise(ERR_LIB_DSA, ERR_R_MALLOC_FAILURE);
+
return sig;
}
*/
if (!filespec2 || filespec1[0] == '/') {
merged = OPENSSL_strdup(filespec1);
- if (merged == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (merged == NULL)
return NULL;
- }
}
/*
* If the first file specification is missing, the second one rules.
*/
else if (!filespec1) {
merged = OPENSSL_strdup(filespec2);
- if (merged == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (merged == NULL)
return NULL;
- }
} else
/*
* This part isn't as trivial as it looks. It assumes that the
len--;
}
merged = OPENSSL_malloc(len + 2);
- if (merged == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (merged == NULL)
return NULL;
- }
strcpy(merged, filespec2);
merged[spec2len] = '/';
strcpy(&merged[spec2len + 1], filespec1);
*/
if (!filespec2 || (filespec1 != NULL && filespec1[0] == '/')) {
merged = OPENSSL_strdup(filespec1);
- if (merged == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (merged == NULL)
return NULL;
- }
}
/*
* If the first file specification is missing, the second one rules.
*/
else if (!filespec1) {
merged = OPENSSL_strdup(filespec2);
- if (merged == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (merged == NULL)
return NULL;
- }
} else {
/*
* This part isn't as trivial as it looks. It assumes that the
len--;
}
merged = OPENSSL_malloc(len + 2);
- if (merged == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (merged == NULL)
return NULL;
- }
strcpy(merged, filespec2);
merged[spec2len] = '/';
strcpy(&merged[spec2len + 1], filespec1);
DSO *ret;
ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->meth_data = sk_void_new_null();
if (ret->meth_data == NULL) {
/* sk_new doesn't generate any errors so we do */
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSO, ERR_R_CRYPTO_LIB);
OPENSSL_free(ret);
return NULL;
}
ret->references = 1;
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSO, ERR_R_CRYPTO_LIB);
sk_void_free(ret->meth_data);
OPENSSL_free(ret);
return NULL;
if (dso == NULL) {
ret = DSO_new_method(meth);
if (ret == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSO, ERR_R_DSO_LIB);
goto err;
}
allocated = 1;
}
/* We'll duplicate filename */
copied = OPENSSL_strdup(filename);
- if (copied == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (copied == NULL)
return 0;
- }
OPENSSL_free(dso->filename);
dso->filename = copied;
return 1;
}
if (result == NULL) {
result = OPENSSL_strdup(filename);
- if (result == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (result == NULL)
return NULL;
- }
}
return result;
}
# pragma pointer_size save
# pragma pointer_size 32
void *_malloc32(__size_t);
+static void *dso_malloc(__size_t num, const char *file, int line)
+{
+ void *ret = _malloc32(num);
+ if (ret == NULL && (file != NULL || line != 0)) {
+ ERR_new();
+ ERR_set_debug(file, line, NULL);
+ ERR_set_error(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE, NULL);
+ }
+ return ret;
+}
+# define DSO_MALLOC(num) dso_malloc((num), OPENSSL_FILE, OPENSSL_LINE)
# pragma pointer_size restore
-# endif /* __INITIAL_POINTER_SIZE == 64 */
+# else /* __INITIAL_POINTER_SIZE == 64 */
+# define DSO_MALLOC OPENSSL_malloc
+# endif /* __INITIAL_POINTER_SIZE == 64 [else] */
# endif /* __INITIAL_POINTER_SIZE && defined
* _ANSI_C_SOURCE */
char *filename = DSO_convert_filename(dso, NULL);
/* Ensure 32-bit pointer for "p", and appropriate malloc() function. */
-# if __INITIAL_POINTER_SIZE == 64
-# define DSO_MALLOC _malloc32
-# pragma pointer_size save
-# pragma pointer_size 32
-# else /* __INITIAL_POINTER_SIZE == 64 */
-# define DSO_MALLOC OPENSSL_malloc
-# endif /* __INITIAL_POINTER_SIZE == 64 [else] */
+# if __INITIAL_POINTER_SIZE && defined _ANSI_C_SOURCE
+# if __INITIAL_POINTER_SIZE == 64
+# pragma pointer_size save
+# pragma pointer_size 32
+# endif /* __INITIAL_POINTER_SIZE == 64 */
DSO_VMS_INTERNAL *p = NULL;
-# if __INITIAL_POINTER_SIZE == 64
-# pragma pointer_size restore
-# endif /* __INITIAL_POINTER_SIZE == 64 */
+# if __INITIAL_POINTER_SIZE == 64
+# pragma pointer_size restore
+# endif /* __INITIAL_POINTER_SIZE == 64 */
+# endif /* __INITIAL_POINTER_SIZE && defined
+ * _ANSI_C_SOURCE */
const char *sp1, *sp2; /* Search result */
const char *ext = NULL; /* possible extension to add */
}
p = DSO_MALLOC(sizeof(*p));
- if (p == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (p == NULL)
goto err;
- }
strncpy(p->filename, sp1, sp2 - sp1);
p->filename[sp2 - sp1] = '\0';
merged = OPENSSL_malloc(nam.NAMX_ESL + 1);
if (merged == NULL)
- goto malloc_err;
+ return NULL;
strncpy(merged, nam.NAMX_ESA, nam.NAMX_ESL);
merged[nam.NAMX_ESL] = '\0';
return merged;
- malloc_err:
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
}
static char *vms_name_converter(DSO *dso, const char *filename)
goto err;
}
p = OPENSSL_malloc(sizeof(*p));
- if (p == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (p == NULL)
goto err;
- }
*p = h;
if (!sk_void_push(dso->meth_data, p)) {
ERR_raise(ERR_LIB_DSO, DSO_R_STACK_ERROR);
}
result = OPENSSL_zalloc(sizeof(*result));
- if (result == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (result == NULL)
return NULL;
- }
position = IN_DEVICE;
}
result = OPENSSL_malloc(len + 1);
- if (result == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (result == NULL)
return NULL;
- }
if (file_split->node) {
strcpy(&result[offset], "\\\\");
}
if (!filespec2) {
merged = OPENSSL_strdup(filespec1);
- if (merged == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (merged == NULL)
return NULL;
- }
} else if (!filespec1) {
merged = OPENSSL_strdup(filespec2);
- if (merged == NULL) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ if (merged == NULL)
return NULL;
- }
} else {
filespec1_split = win32_splitter(dso, filespec1, 0);
if (!filespec1_split) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSO, ERR_R_DSO_LIB);
return NULL;
}
filespec2_split = win32_splitter(dso, filespec2, 1);
if (!filespec2_split) {
- ERR_raise(ERR_LIB_DSO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DSO, ERR_R_DSO_LIB);
OPENSSL_free(filespec1_split);
return NULL;
}
if (ctx == NULL) {
ctx = new_ctx = BN_CTX_new();
if (ctx == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
}
t1 = BN_CTX_get(ctx);
t2 = BN_CTX_get(ctx);
if (t2 == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
*/
if ((t = EC_POINT_new(group)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
return 0;
}
EC_KEY *ec = EC_KEY_new_ex(pctx->libctx, pctx->propquery);
if (ec == NULL) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
return 0;
}
if (nid == NID_X9_62_prime_field) {
if ((tmp = BN_new()) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
/* the parameters are specified by the prime number p */
char_two = field->p.char_two;
if (char_two == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_ASN1_LIB);
goto err;
}
char_two->p.tpBasis = ASN1_INTEGER_new();
if (char_two->p.tpBasis == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_ASN1_LIB);
goto err;
}
if (!ASN1_INTEGER_set(char_two->p.tpBasis, (long)k)) {
char_two->p.ppBasis = X9_62_PENTANOMIAL_new();
if (char_two->p.ppBasis == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_ASN1_LIB);
goto err;
}
/* for ONB the parameters are (asn1) NULL */
char_two->p.onBasis = ASN1_NULL_new();
if (char_two->p.onBasis == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_ASN1_LIB);
goto err;
}
}
return 0;
if ((tmp_1 = BN_new()) == NULL || (tmp_2 = BN_new()) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
*/
len = ((size_t)EC_GROUP_get_degree(group) + 7) / 8;
if ((a_buf = OPENSSL_malloc(len)) == NULL
- || (b_buf = OPENSSL_malloc(len)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ || (b_buf = OPENSSL_malloc(len)) == NULL)
goto err;
- }
if (BN_bn2binpad(tmp_1, a_buf, len) < 0
|| BN_bn2binpad(tmp_2, b_buf, len) < 0) {
ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
if (group->seed) {
if (!curve->seed)
if ((curve->seed = ASN1_BIT_STRING_new()) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_ASN1_LIB);
goto err;
}
ossl_asn1_string_set_bits_left(curve->seed, 0);
if (params == NULL) {
if ((ret = ECPARAMETERS_new()) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_ASN1_LIB);
goto err;
}
} else
}
if (ret->base == NULL && (ret->base = ASN1_OCTET_STRING_new()) == NULL) {
OPENSSL_free(buffer);
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_ASN1_LIB);
goto err;
}
ASN1_STRING_set0(ret->base, buffer, len);
if (ret == NULL) {
if ((ret = ECPKPARAMETERS_new()) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_ASN1_LIB);
return NULL;
}
} else {
}
if ((p = BN_new()) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
goto err;
}
OPENSSL_free(ret->seed);
- if ((ret->seed = OPENSSL_malloc(params->curve->seed->length)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if ((ret->seed = OPENSSL_malloc(params->curve->seed->length)) == NULL)
goto err;
- }
memcpy(ret->seed, params->curve->seed->data,
params->curve->seed->length);
ret->seed_len = params->curve->seed->length;
if (a == NULL || *a == NULL) {
if ((ret = EC_KEY_new()) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
} else
}
if ((priv_key = EC_PRIVATEKEY_new()) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
if (!(a->enc_flag & EC_PKEY_NO_PUBKEY)) {
priv_key->publicKey = ASN1_BIT_STRING_new();
if (priv_key->publicKey == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_ASN1_LIB);
goto err;
}
if (a == NULL || *a == NULL) {
if ((ret = EC_KEY_new()) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
return NULL;
}
} else
return buf_len;
if (*out == NULL) {
- if ((*out = OPENSSL_malloc(buf_len)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if ((*out = OPENSSL_malloc(buf_len)) == NULL)
return 0;
- }
new_buffer = 1;
}
if (!EC_POINT_point2oct(a->group, a->pub_key, a->conv_form,
ECDSA_SIG *ECDSA_SIG_new(void)
{
ECDSA_SIG *sig = OPENSSL_zalloc(sizeof(*sig));
- if (sig == NULL)
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+
return sig;
}
BIGNUM *b = BN_CTX_get(bnctx);
if (b == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
if (!ossl_param_build_set_bn(tmpl, params, OSSL_PKEY_PARAM_EC_P, p)
|| !ossl_param_build_set_bn(tmpl, params, OSSL_PKEY_PARAM_EC_A, a)
|| !ossl_param_build_set_bn(tmpl, params, OSSL_PKEY_PARAM_EC_B, b)) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB);
goto err;
}
}
}
if (!ossl_param_build_set_bn(tmpl, params, OSSL_PKEY_PARAM_EC_ORDER,
order)) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB);
goto err;
}
}
if (!ossl_param_build_set_utf8_string(tmpl, params,
OSSL_PKEY_PARAM_EC_FIELD_TYPE,
field_type)) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB);
goto err;
}
}
if (!ossl_param_build_set_octet_string(tmpl, params,
OSSL_PKEY_PARAM_EC_GENERATOR,
*genbuf, genbuf_len)) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB);
goto err;
}
}
if (cofactor != NULL
&& !ossl_param_build_set_bn(tmpl, params,
OSSL_PKEY_PARAM_EC_COFACTOR, cofactor)) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB);
goto err;
}
}
&& !ossl_param_build_set_octet_string(tmpl, params,
OSSL_PKEY_PARAM_EC_SEED,
seed, seed_len)) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB);
goto err;
}
}
X509_ALGOR_get0(NULL, &ptype, &pval, palg);
if ((eckey = EC_KEY_new_ex(libctx, propq)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto ecerr;
}
if (ctx == NULL) {
ctx = new_ctx = BN_CTX_new_ex(NULL);
if (ctx == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
return NID_undef;
}
}
if (ctx == NULL) {
ctx = new_ctx = BN_CTX_new();
if (ctx == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
}
curve.meth != NULL ? curve.meth() : NULL);
if ((ctx = BN_CTX_new_ex(libctx)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
if ((buf_len = BN_num_bytes(bn)) == 0)
buf_len = 1;
- if ((buf = OPENSSL_malloc(buf_len)) == NULL) {
- ECerr(EC_F_EC_POINT_BN2POINT, ERR_R_MALLOC_FAILURE);
+ if ((buf = OPENSSL_malloc(buf_len)) == NULL)
return NULL;
- }
if (BN_bn2binpad(bn, buf, buf_len) < 0) {
OPENSSL_free(buf);
if (eckey->priv_key == NULL)
eckey->priv_key = BN_secure_new();
if (eckey->priv_key == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
return 0;
}
if (BN_bin2bn(buf, len, eckey->priv_key) == NULL) {
len = EC_KEY_priv2oct(eckey, NULL, 0);
if (len == 0)
return 0;
- if ((buf = OPENSSL_malloc(len)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if ((buf = OPENSSL_malloc(len)) == NULL)
return 0;
- }
len = EC_KEY_priv2oct(eckey, buf, len);
if (len == 0) {
OPENSSL_free(buf);
{
EC_KEY *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->libctx = libctx;
if (propq != NULL) {
ret->propq = OPENSSL_strdup(propq);
- if (ret->propq == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (ret->propq == NULL)
goto err;
- }
}
ret->references = 1;
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB);
goto err;
}
/* No ex_data inside the FIPS provider */
#ifndef FIPS_MODULE
if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_EC_KEY, ret, &ret->ex_data)) {
+ ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB);
goto err;
}
#endif
}
ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->libctx = libctx;
if (propq != NULL) {
ret->propq = OPENSSL_strdup(propq);
- if (ret->propq == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (ret->propq == NULL)
goto err;
- }
}
ret->meth = meth;
if ((ret->meth->flags & EC_FLAGS_CUSTOM_CURVE) == 0) {
if (src->seed) {
OPENSSL_free(dest->seed);
- if ((dest->seed = OPENSSL_malloc(src->seed_len)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if ((dest->seed = OPENSSL_malloc(src->seed_len)) == NULL)
return 0;
- }
if (!memcpy(dest->seed, src->seed, src->seed_len))
return 0;
dest->seed_len = src->seed_len;
if (!len || !p)
return 1;
- if ((group->seed = OPENSSL_malloc(len)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if ((group->seed = OPENSSL_malloc(len)) == NULL)
return 0;
- }
memcpy(group->seed, p, len);
group->seed_len = len;
}
ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->meth = group->meth;
ret->curve_name = group->curve_name;
/* If it gets here then we are trying explicit parameters */
bnctx = BN_CTX_new_ex(libctx);
if (bnctx == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
return 0;
}
BN_CTX_start(bnctx);
b = BN_CTX_get(bnctx);
order = BN_CTX_get(bnctx);
if (order == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
return NULL;
ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return ret;
- }
ret->group = group;
ret->blocksize = 8; /* default */
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB);
OPENSSL_free(ret);
return NULL;
}
if (((p = EC_POINT_new(group)) == NULL)
|| ((s = EC_POINT_new(group)) == NULL)) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
lambda = BN_CTX_get(ctx);
k = BN_CTX_get(ctx);
if (k == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
if (wNAF != NULL)
wNAF[0] = NULL; /* preliminary pivot */
- if (wsize == NULL || wNAF_len == NULL || wNAF == NULL || val_sub == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (wsize == NULL || wNAF_len == NULL || wNAF == NULL || val_sub == NULL)
goto err;
- }
/*
* num_val will be the total number of temporarily precomputed points
wNAF[i + 1] = NULL;
wNAF[i] = OPENSSL_malloc(wNAF_len[i]);
if (wNAF[i] == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
OPENSSL_free(tmp_wNAF);
goto err;
}
* subarray of 'pre_comp->points' if we already have precomputation.
*/
val = OPENSSL_malloc((num_val + 1) * sizeof(val[0]));
- if (val == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (val == NULL)
goto err;
- }
val[num_val] = NULL; /* pivot element */
/* allocate points for precomputation */
* and store */
points = OPENSSL_malloc(sizeof(*points) * (num + 1));
- if (points == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (points == NULL)
goto err;
- }
var = points;
var[num] = NULL; /* pivot */
for (i = 0; i < num; i++) {
if ((var[i] = EC_POINT_new(group)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
}
if ((tmp_point = EC_POINT_new(group)) == NULL
|| (base = EC_POINT_new(group)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
len = EC_POINT_point2oct(group, point, form, NULL, 0, NULL);
if (len == 0)
return 0;
- if ((buf = OPENSSL_malloc(len)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if ((buf = OPENSSL_malloc(len)) == NULL)
return 0;
- }
len = EC_POINT_point2oct(group, point, form, buf, len, ctx);
if (len == 0) {
OPENSSL_free(buf);
{
EC_PKEY_CTX *dctx;
- if ((dctx = OPENSSL_zalloc(sizeof(*dctx))) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if ((dctx = OPENSSL_zalloc(sizeof(*dctx))) == NULL)
return 0;
- }
dctx->cofactor_mode = -1;
dctx->kdf_type = EVP_PKEY_ECDH_KDF_NONE;
return 0;
if (!pkey_ec_derive(ctx, NULL, &ktmplen))
return 0;
- if ((ktmp = OPENSSL_malloc(ktmplen)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if ((ktmp = OPENSSL_malloc(ktmplen)) == NULL)
return 0;
- }
if (!pkey_ec_derive(ctx, ktmp, &ktmplen))
goto err;
/* Do KDF stuff */
BN_CTX_start(ctx);
x = BN_CTX_get(ctx);
if (x == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
* * peer_public_key.
*/
if (EC_KEY_get_flags(ecdh) & EC_FLAG_COFACTOR_ECDH) {
- if (!EC_GROUP_get_cofactor(group, x, NULL) ||
- !BN_mul(x, x, priv_key, ctx)) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (!EC_GROUP_get_cofactor(group, x, NULL)) {
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
+ goto err;
+ }
+ if (!BN_mul(x, x, priv_key, ctx)) {
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
priv_key = x;
}
if ((tmp = EC_POINT_new(group)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
ERR_raise(ERR_LIB_EC, ERR_R_INTERNAL_ERROR);
goto err;
}
- if ((buf = OPENSSL_malloc(buflen)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if ((buf = OPENSSL_malloc(buflen)) == NULL)
goto err;
- }
memset(buf, 0, buflen - len);
if (len != (size_t)BN_bn2bin(x, buf + buflen - len)) {
if ((ctx = ctx_in) == NULL) {
if ((ctx = BN_CTX_new_ex(eckey->libctx)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
return 0;
}
}
r = BN_new(); /* this value is later returned in *rp */
X = BN_new();
if (k == NULL || r == NULL || X == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
if ((tmp_point = EC_POINT_new(group)) == NULL) {
ret = ECDSA_SIG_new();
if (ret == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_ECDSA_LIB);
return NULL;
}
ret->r = BN_new();
ret->s = BN_new();
if (ret->r == NULL || ret->s == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
s = ret->s;
if ((ctx = BN_CTX_new_ex(eckey->libctx)) == NULL
|| (m = BN_new()) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
} else {
ckinv = in_kinv;
if (BN_copy(ret->r, in_r) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
}
ctx = BN_CTX_new_ex(eckey->libctx);
if (ctx == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
return -1;
}
BN_CTX_start(ctx);
}
if ((point = EC_POINT_new(group)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
if (!EC_POINT_mul(group, point, u1, pub_key, u2, ctx)) {
ctx = BN_CTX_new();
if (ctx == NULL) {
- reason = ERR_R_MALLOC_FAILURE;
+ reason = ERR_R_BN_LIB;
goto err;
}
if ((p = BN_new()) == NULL || (a = BN_new()) == NULL ||
(b = BN_new()) == NULL) {
- reason = ERR_R_MALLOC_FAILURE;
+ reason = ERR_R_BN_LIB;
goto err;
}
{
NISTP224_PRE_COMP *ret = OPENSSL_zalloc(sizeof(*ret));
- if (!ret) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return ret;
- }
ret->references = 1;
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB);
OPENSSL_free(ret);
return NULL;
}
tmp_felems =
OPENSSL_malloc(sizeof(felem) * (num_points * 17 + 1));
if ((secrets == NULL) || (pre_comp == NULL)
- || (mixed && (tmp_felems == NULL))) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ || (mixed && (tmp_felems == NULL)))
goto err;
- }
/*
* we treat NULL scalars as 0, and NULL points as points at infinity,
{
NISTP256_PRE_COMP *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return ret;
- }
ret->references = 1;
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB);
OPENSSL_free(ret);
return NULL;
}
tmp_smallfelems =
OPENSSL_malloc(sizeof(*tmp_smallfelems) * (num_points * 17 + 1));
if ((secrets == NULL) || (pre_comp == NULL)
- || (mixed && (tmp_smallfelems == NULL))) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ || (mixed && (tmp_smallfelems == NULL)))
goto err;
- }
/*
* we treat NULL scalars as 0, and NULL points as points at infinity,
{
NISTP521_PRE_COMP *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return ret;
- }
ret->references = 1;
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB);
OPENSSL_free(ret);
return NULL;
}
tmp_felems =
OPENSSL_malloc(sizeof(*tmp_felems) * (num_points * 17 + 1));
if ((secrets == NULL) || (pre_comp == NULL)
- || (mixed && (tmp_felems == NULL))) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ || (mixed && (tmp_felems == NULL)))
goto err;
- }
/*
* we treat NULL scalars as 0, and NULL points as points at infinity,
OPENSSL_malloc((num * 16 + 5) * sizeof(P256_POINT) + 64)) == NULL
|| (p_str =
OPENSSL_malloc(num * 33 * sizeof(unsigned char))) == NULL
- || (scalars = OPENSSL_malloc(num * sizeof(BIGNUM *))) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ || (scalars = OPENSSL_malloc(num * sizeof(BIGNUM *))) == NULL)
goto err;
- }
table = (void *)ALIGNPTR(table_storage, 64);
temp = (P256_POINT *)(table + num);
w = 7;
if ((precomp_storage =
- OPENSSL_malloc(37 * 64 * sizeof(P256_POINT_AFFINE) + 64)) == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ OPENSSL_malloc(37 * 64 * sizeof(P256_POINT_AFFINE) + 64)) == NULL)
goto err;
- }
preComputedTable = (void *)ALIGNPTR(precomp_storage, 64);
BIGNUM *tmp_scalar;
if ((num + 1) == 0 || (num + 1) > OPENSSL_MALLOC_MAX_NELEMS(void *)) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_PASSED_INVALID_ARGUMENT);
return 0;
}
* handled like a normal point.
*/
new_scalars = OPENSSL_malloc((num + 1) * sizeof(BIGNUM *));
- if (new_scalars == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (new_scalars == NULL)
goto err;
- }
new_points = OPENSSL_malloc((num + 1) * sizeof(EC_POINT *));
- if (new_points == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (new_points == NULL)
goto err;
- }
memcpy(new_scalars, scalars, num * sizeof(BIGNUM *));
new_scalars[num] = scalar;
ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return ret;
- }
ret->group = group;
ret->w = 6; /* default */
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB);
OPENSSL_free(ret);
return NULL;
}
k = BN_secure_new();
sig = ECDSA_SIG_new();
if (k == NULL || sig == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_ECDSA_LIB);
goto ret;
}
sig->r = BN_new();
sig->s = BN_new();
if (sig->r == NULL || sig->s == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto ret;
}
ctx = BN_CTX_new_ex(group->libctx);
if (ctx == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
return -1;
}
x = BN_CTX_get(ctx);
y = BN_CTX_get(ctx);
if (x == NULL || y == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto ret;
}
if (ctx == NULL) {
ctx = new_ctx = BN_CTX_new_ex(group->libctx);
if (ctx == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto err;
}
}
lambda = BN_CTX_get(ctx);
temp = BN_CTX_get(ctx);
if (temp == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
goto end;
}
{
ECX_KEY *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0
&& key->privkey != NULL) {
- if (ossl_ecx_key_allocate_privkey(ret) == NULL)
+ if (ossl_ecx_key_allocate_privkey(ret) == NULL) {
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
+ }
memcpy(ret->privkey, key->privkey, ret->keylen);
}
err:
ossl_ecx_key_free(ret);
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
return NULL;
}
key = ossl_ecx_key_new(libctx, KEYNID2TYPE(id), 1, propq);
if (key == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
return 0;
}
pubkey = key->pubkey;
} else {
privkey = ossl_ecx_key_allocate_privkey(key);
if (privkey == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
if (op == KEY_OP_KEYGEN) {
}
ret->lock = CRYPTO_THREAD_lock_new();
- if (ret->lock == NULL)
+ if (ret->lock == NULL) {
+ ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB);
goto err;
+ }
return ret;
err:
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (ret != NULL) {
+ OPENSSL_free(ret->propq);
+ CRYPTO_THREAD_lock_free(ret->lock);
+ }
OPENSSL_free(ret);
return NULL;
}
}
penc = OPENSSL_memdup(ecxkey->pubkey, KEYLEN(pkey));
- if (penc == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ if (penc == NULL)
return 0;
- }
if (!X509_PUBKEY_set0_param(pk, OBJ_nid2obj(pkey->ameth->pkey_id),
V_ASN1_UNDEF, NULL, penc, KEYLEN(pkey))) {
OPENSSL_free(penc);
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_X509_LIB);
return 0;
}
return 1;
penclen = i2d_ASN1_OCTET_STRING(&oct, &penc);
if (penclen < 0) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_ASN1_LIB);
return 0;
}
if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(pkey->ameth->pkey_id), 0,
V_ASN1_UNDEF, NULL, penc, penclen)) {
OPENSSL_clear_free(penc, penclen);
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_ASN1_LIB);
return 0;
}
pctx->propquery);
if (ecx == NULL) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DH, ERR_R_EC_LIB);
return 0;
}
unsigned char *privkey = NULL, *pubkey;
if (key == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
privkey = ossl_ecx_key_allocate_privkey(key);
if (privkey == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
unsigned char *privkey = NULL, *pubkey;
if (key == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
privkey = ossl_ecx_key_allocate_privkey(key);
if (privkey == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
int rv;
if (key == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
privkey = ossl_ecx_key_allocate_privkey(key);
if (privkey == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
int rv;
if (key == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
privkey = ossl_ecx_key_allocate_privkey(key);
if (privkey == NULL) {
- ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
goto err;
}
return 0;
}
- if ((decoder_inst = OPENSSL_zalloc(sizeof(*decoder_inst))) == NULL) {
- ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_MALLOC_FAILURE);
+ if ((decoder_inst = OPENSSL_zalloc(sizeof(*decoder_inst))) == NULL)
return 0;
- }
prov = OSSL_DECODER_get0_provider(decoder);
libctx = ossl_provider_libctx(prov);
if (ctx->decoder_insts == NULL
&& (ctx->decoder_insts =
sk_OSSL_DECODER_INSTANCE_new_null()) == NULL) {
- ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_CRYPTO_LIB);
return 0;
}
skdecoders = sk_OSSL_DECODER_new_null();
if (skdecoders == NULL) {
- ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_CRYPTO_LIB);
return 0;
}
OSSL_DECODER_do_all_provided(libctx, collect_all_decoders, skdecoders);
}
if ((cbio = ossl_core_bio_new_from_bio(bio)) == NULL) {
- ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_BIO_LIB);
goto end;
}
{
OSSL_DECODER *decoder = NULL;
- if ((decoder = OPENSSL_zalloc(sizeof(*decoder))) == NULL
- || (decoder->base.lock = CRYPTO_THREAD_lock_new()) == NULL) {
+ if ((decoder = OPENSSL_zalloc(sizeof(*decoder))) == NULL)
+ return NULL;
+ if ((decoder->base.lock = CRYPTO_THREAD_lock_new()) == NULL) {
OSSL_DECODER_free(decoder);
- ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_CRYPTO_LIB);
return NULL;
}
{
OSSL_DECODER_CTX *ctx;
- if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
- ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_MALLOC_FAILURE);
-
+ ctx = OPENSSL_zalloc(sizeof(*ctx));
return ctx;
}
} OSSL_TRACE_END(DECODER);
/* Allocate data. */
- if ((process_data = OPENSSL_zalloc(sizeof(*process_data))) == NULL
- || (propquery != NULL
- && (process_data->propq = OPENSSL_strdup(propquery)) == NULL)) {
- ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_MALLOC_FAILURE);
+ if ((process_data = OPENSSL_zalloc(sizeof(*process_data))) == NULL)
+ goto err;
+ if ((propquery != NULL
+ && (process_data->propq = OPENSSL_strdup(propquery)) == NULL))
goto err;
- }
/* Allocate our list of EVP_KEYMGMTs. */
keymgmts = sk_EVP_KEYMGMT_new_null();
if (keymgmts == NULL) {
- ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_CRYPTO_LIB);
goto err;
}
OSSL_DECODER_CTX *ctx = NULL;
if ((ctx = OSSL_DECODER_CTX_new()) == NULL) {
- ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_DECODER, ERR_R_OSSL_DECODER_LIB);
return NULL;
}
return 0;
}
- if ((encoder_inst = OPENSSL_zalloc(sizeof(*encoder_inst))) == NULL) {
- ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);
+ if ((encoder_inst = OPENSSL_zalloc(sizeof(*encoder_inst))) == NULL)
return 0;
- }
if (!OSSL_ENCODER_up_ref(encoder)) {
ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_INTERNAL_ERROR);
if (ctx->encoder_insts == NULL
&& (ctx->encoder_insts =
sk_OSSL_ENCODER_INSTANCE_new_null()) == NULL) {
- ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_CRYPTO_LIB);
return 0;
}
{
OSSL_ENCODER *encoder = NULL;
- if ((encoder = OPENSSL_zalloc(sizeof(*encoder))) == NULL
- || (encoder->base.lock = CRYPTO_THREAD_lock_new()) == NULL) {
+ if ((encoder = OPENSSL_zalloc(sizeof(*encoder))) == NULL)
+ return NULL;
+ if ((encoder->base.lock = CRYPTO_THREAD_lock_new()) == NULL) {
OSSL_ENCODER_free(encoder);
- ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_CRYPTO_LIB);
return NULL;
}
{
OSSL_ENCODER_CTX *ctx;
- if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
- ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);
-
+ ctx = OPENSSL_zalloc(sizeof(*ctx));
return ctx;
}
struct collected_encoder_st encoder_data;
struct collected_names_st keymgmt_data;
- if ((data = OPENSSL_zalloc(sizeof(*data))) == NULL) {
- ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);
+ if ((data = OPENSSL_zalloc(sizeof(*data))) == NULL)
goto err;
- }
/*
* Select the first encoder implementations in two steps.
*/
keymgmt_data.names = sk_OPENSSL_CSTRING_new_null();
if (keymgmt_data.names == NULL) {
- ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_CRYPTO_LIB);
goto err;
}
sk_OPENSSL_CSTRING_free(keymgmt_data.names);
if (encoder_data.error_occurred) {
- ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_CRYPTO_LIB);
goto err;
}
}
}
if ((ctx = OSSL_ENCODER_CTX_new()) == NULL) {
- ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_OSSL_ENCODER_LIB);
return NULL;
}
dynamic_data_ctx *c = OPENSSL_zalloc(sizeof(*c));
int ret = 0;
- if (c == NULL) {
- ERR_raise(ERR_LIB_ENGINE, ERR_R_MALLOC_FAILURE);
+ if (c == NULL)
return 0;
- }
c->dirs = sk_OPENSSL_STRING_new_null();
if (c->dirs == NULL) {
- ERR_raise(ERR_LIB_ENGINE, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ENGINE, ERR_R_CRYPTO_LIB);
goto end;
}
c->DYNAMIC_F1 = "v_check";
}
{
char *tmp_str = OPENSSL_strdup(p);
- if (tmp_str == NULL) {
- ERR_raise(ERR_LIB_ENGINE, ERR_R_MALLOC_FAILURE);
+ if (tmp_str == NULL)
return 0;
- }
if (!sk_OPENSSL_STRING_push(ctx->dirs, tmp_str)) {
OPENSSL_free(tmp_str);
- ERR_raise(ERR_LIB_ENGINE, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ENGINE, ERR_R_CRYPTO_LIB);
return 0;
}
}
return 0;
}
if (!RUN_ONCE(&engine_lock_init, do_engine_lock_init)) {
- ERR_raise(ERR_LIB_ENGINE, ERR_R_MALLOC_FAILURE);
+ /* Maybe this should be raised in do_engine_lock_init() */
+ ERR_raise(ERR_LIB_ENGINE, ERR_R_CRYPTO_LIB);
return 0;
}
if (!CRYPTO_THREAD_write_lock(global_engine_lock))
{
ENGINE *ret;
- if (!RUN_ONCE(&engine_lock_init, do_engine_lock_init)
- || (ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
- ERR_raise(ERR_LIB_ENGINE, ERR_R_MALLOC_FAILURE);
- return NULL;
+ if (!RUN_ONCE(&engine_lock_init, do_engine_lock_init)) {
+ /* Maybe this should be raised in do_engine_lock_init() */
+ ERR_raise(ERR_LIB_ENGINE, ERR_R_CRYPTO_LIB);
+ return 0;
}
+ if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
+ return NULL;
ret->struct_ref = 1;
ENGINE_REF_PRINT(ret, 0, 1);
if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_ENGINE, ret, &ret->ex_data)) {
{
ENGINE_CLEANUP_ITEM *item;
- if ((item = OPENSSL_malloc(sizeof(*item))) == NULL) {
- ERR_raise(ERR_LIB_ENGINE, ERR_R_MALLOC_FAILURE);
+ if ((item = OPENSSL_malloc(sizeof(*item))) == NULL)
return NULL;
- }
item->cb = cb;
return item;
}
ENGINE *ret;
if (!RUN_ONCE(&engine_lock_init, do_engine_lock_init)) {
- ERR_raise(ERR_LIB_ENGINE, ERR_R_MALLOC_FAILURE);
+ /* Maybe this should be raised in do_engine_lock_init() */
+ ERR_raise(ERR_LIB_ENGINE, ERR_R_CRYPTO_LIB);
return NULL;
}
ENGINE *ret;
if (!RUN_ONCE(&engine_lock_init, do_engine_lock_init)) {
- ERR_raise(ERR_LIB_ENGINE, ERR_R_MALLOC_FAILURE);
+ /* Maybe this should be raised in do_engine_lock_init() */
+ ERR_raise(ERR_LIB_ENGINE, ERR_R_CRYPTO_LIB);
return NULL;
}
ENGINE_load_builtin_engines();
if (!RUN_ONCE(&engine_lock_init, do_engine_lock_init)) {
- ERR_raise(ERR_LIB_ENGINE, ERR_R_MALLOC_FAILURE);
+ /* Maybe this should be raised in do_engine_lock_init() */
+ ERR_raise(ERR_LIB_ENGINE, ERR_R_CRYPTO_LIB);
return NULL;
}
{
OSSL_HMAC_PKEY_CTX *hctx;
- if ((hctx = OPENSSL_zalloc(sizeof(*hctx))) == NULL) {
- ERR_raise(ERR_LIB_ENGINE, ERR_R_MALLOC_FAILURE);
+ if ((hctx = OPENSSL_zalloc(sizeof(*hctx))) == NULL)
return 0;
- }
hctx->ktmp.type = V_ASN1_OCTET_STRING;
hctx->ctx = HMAC_CTX_new();
if (hctx->ctx == NULL) {
fstr.len = len;
if (!RUN_ONCE(&engine_lock_init, do_engine_lock_init)) {
- ERR_raise(ERR_LIB_ENGINE, ERR_R_MALLOC_FAILURE);
+ /* Maybe this should be raised in do_engine_lock_init() */
+ ERR_raise(ERR_LIB_ENGINE, ERR_R_CRYPTO_LIB);
return NULL;
}
BIO_R_NO_HOSTNAME_OR_SERVICE_SPECIFIED:144:no hostname or service specified
BIO_R_NO_PORT_DEFINED:113:no port defined
BIO_R_NO_SUCH_FILE:128:no such file
-BIO_R_PORT_MISMATCH:150:port mismatch
BIO_R_PEER_ADDR_NOT_AVAILABLE:114:peer addr not available
+BIO_R_PORT_MISMATCH:150:port mismatch
BIO_R_TFO_DISABLED:106:tfo disabled
BIO_R_TFO_NO_KERNEL_SUPPORT:108:tfo no kernel support
BIO_R_TRANSFER_ERROR:104:transfer error
DH_R_INVALID_PARAMETER_NID:114:invalid parameter nid
DH_R_INVALID_PUBKEY:102:invalid public key
DH_R_INVALID_SECRET:128:invalid secret
+DH_R_INVALID_SIZE:129:invalid size
DH_R_KDF_PARAMETER_ERROR:112:kdf parameter error
DH_R_KEYS_NOT_SET:108:keys not set
DH_R_MISSING_PUBKEY:125:missing pubkey
ESS_SIGNING_CERT *sc;
int i;
- if ((sc = ESS_SIGNING_CERT_new()) == NULL)
+ if ((sc = ESS_SIGNING_CERT_new()) == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ESS_LIB);
goto err;
+ }
if (sc->cert_ids == NULL
- && (sc->cert_ids = sk_ESS_CERT_ID_new_null()) == NULL)
+ && (sc->cert_ids = sk_ESS_CERT_ID_new_null()) == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_CRYPTO_LIB);
goto err;
+ }
if ((cid = ESS_CERT_ID_new_init(signcert, set_issuer_serial)) == NULL
- || !sk_ESS_CERT_ID_push(sc->cert_ids, cid))
+ || !sk_ESS_CERT_ID_push(sc->cert_ids, cid)) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ESS_LIB);
goto err;
+ }
for (i = 0; i < sk_X509_num(certs); ++i) {
X509 *cert = sk_X509_value(certs, i);
- if ((cid = ESS_CERT_ID_new_init(cert, 1)) == NULL
- || !sk_ESS_CERT_ID_push(sc->cert_ids, cid))
+ if ((cid = ESS_CERT_ID_new_init(cert, 1)) == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ESS_LIB);
+ goto err;
+ }
+ if (!sk_ESS_CERT_ID_push(sc->cert_ids, cid)) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_CRYPTO_LIB);
goto err;
+ }
}
return sc;
err:
ESS_SIGNING_CERT_free(sc);
ESS_CERT_ID_free(cid);
- ERR_raise(ERR_LIB_ESS, ERR_R_MALLOC_FAILURE);
return NULL;
}
GENERAL_NAME *name = NULL;
unsigned char cert_sha1[SHA_DIGEST_LENGTH];
- if ((cid = ESS_CERT_ID_new()) == NULL)
+ if ((cid = ESS_CERT_ID_new()) == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ESS_LIB);
goto err;
- if (!X509_digest(cert, EVP_sha1(), cert_sha1, NULL))
+ }
+ if (!X509_digest(cert, EVP_sha1(), cert_sha1, NULL)) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_X509_LIB);
goto err;
- if (!ASN1_OCTET_STRING_set(cid->hash, cert_sha1, SHA_DIGEST_LENGTH))
+ }
+ if (!ASN1_OCTET_STRING_set(cid->hash, cert_sha1, SHA_DIGEST_LENGTH)) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ASN1_LIB);
goto err;
+ }
/* Setting the issuer/serial if requested. */
if (!set_issuer_serial)
return cid;
if (cid->issuer_serial == NULL
- && (cid->issuer_serial = ESS_ISSUER_SERIAL_new()) == NULL)
+ && (cid->issuer_serial = ESS_ISSUER_SERIAL_new()) == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ESS_LIB);
goto err;
- if ((name = GENERAL_NAME_new()) == NULL)
+ }
+ if ((name = GENERAL_NAME_new()) == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ASN1_LIB);
goto err;
+ }
name->type = GEN_DIRNAME;
- if ((name->d.dirn = X509_NAME_dup(X509_get_issuer_name(cert))) == NULL)
+ if ((name->d.dirn = X509_NAME_dup(X509_get_issuer_name(cert))) == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_X509_LIB);
goto err;
- if (!sk_GENERAL_NAME_push(cid->issuer_serial->issuer, name))
+ }
+ if (!sk_GENERAL_NAME_push(cid->issuer_serial->issuer, name)) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_CRYPTO_LIB);
goto err;
+ }
name = NULL; /* Ownership is lost. */
ASN1_INTEGER_free(cid->issuer_serial->serial);
- if ((cid->issuer_serial->serial =
- ASN1_INTEGER_dup(X509_get0_serialNumber(cert))) == NULL)
+ if ((cid->issuer_serial->serial
+ = ASN1_INTEGER_dup(X509_get0_serialNumber(cert))) == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ASN1_LIB);
goto err;
+ }
return cid;
err:
GENERAL_NAME_free(name);
ESS_CERT_ID_free(cid);
- ERR_raise(ERR_LIB_ESS, ERR_R_MALLOC_FAILURE);
return NULL;
}
ESS_SIGNING_CERT_V2 *sc;
int i;
- if ((sc = ESS_SIGNING_CERT_V2_new()) == NULL)
+ if ((sc = ESS_SIGNING_CERT_V2_new()) == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ESS_LIB);
goto err;
+ }
cid = ESS_CERT_ID_V2_new_init(hash_alg, signcert, set_issuer_serial);
- if (cid == NULL)
+ if (cid == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ESS_LIB);
goto err;
- if (!sk_ESS_CERT_ID_V2_push(sc->cert_ids, cid))
+ }
+ if (!sk_ESS_CERT_ID_V2_push(sc->cert_ids, cid)) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_CRYPTO_LIB);
goto err;
+ }
cid = NULL;
for (i = 0; i < sk_X509_num(certs); ++i) {
X509 *cert = sk_X509_value(certs, i);
- if ((cid = ESS_CERT_ID_V2_new_init(hash_alg, cert, 1)) == NULL)
+ if ((cid = ESS_CERT_ID_V2_new_init(hash_alg, cert, 1)) == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ESS_LIB);
goto err;
- if (!sk_ESS_CERT_ID_V2_push(sc->cert_ids, cid))
+ }
+ if (!sk_ESS_CERT_ID_V2_push(sc->cert_ids, cid)) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_CRYPTO_LIB);
goto err;
+ }
cid = NULL;
}
err:
ESS_SIGNING_CERT_V2_free(sc);
ESS_CERT_ID_V2_free(cid);
- ERR_raise(ERR_LIB_ESS, ERR_R_MALLOC_FAILURE);
return NULL;
}
memset(hash, 0, sizeof(hash));
- if ((cid = ESS_CERT_ID_V2_new()) == NULL)
+ if ((cid = ESS_CERT_ID_V2_new()) == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ESS_LIB);
goto err;
+ }
if (!EVP_MD_is_a(hash_alg, SN_sha256)) {
alg = X509_ALGOR_new();
- if (alg == NULL)
+ if (alg == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ASN1_LIB);
goto err;
+ }
X509_ALGOR_set_md(alg, hash_alg);
- if (alg->algorithm == NULL)
+ if (alg->algorithm == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ASN1_LIB);
goto err;
+ }
cid->hash_alg = alg;
alg = NULL;
} else {
cid->hash_alg = NULL;
}
- if (!X509_digest(cert, hash_alg, hash, &hash_len))
+ if (!X509_digest(cert, hash_alg, hash, &hash_len)) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_X509_LIB);
goto err;
+ }
- if (!ASN1_OCTET_STRING_set(cid->hash, hash, hash_len))
+ if (!ASN1_OCTET_STRING_set(cid->hash, hash, hash_len)) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ASN1_LIB);
goto err;
+ }
if (!set_issuer_serial)
return cid;
- if ((cid->issuer_serial = ESS_ISSUER_SERIAL_new()) == NULL)
+ if ((cid->issuer_serial = ESS_ISSUER_SERIAL_new()) == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ESS_LIB);
goto err;
- if ((name = GENERAL_NAME_new()) == NULL)
+ }
+ if ((name = GENERAL_NAME_new()) == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ASN1_LIB);
goto err;
+ }
name->type = GEN_DIRNAME;
- if ((name->d.dirn = X509_NAME_dup(X509_get_issuer_name(cert))) == NULL)
+ if ((name->d.dirn = X509_NAME_dup(X509_get_issuer_name(cert))) == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ASN1_LIB);
goto err;
- if (!sk_GENERAL_NAME_push(cid->issuer_serial->issuer, name))
+ }
+ if (!sk_GENERAL_NAME_push(cid->issuer_serial->issuer, name)) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_CRYPTO_LIB);
goto err;
+ }
name = NULL; /* Ownership is lost. */
ASN1_INTEGER_free(cid->issuer_serial->serial);
cid->issuer_serial->serial = ASN1_INTEGER_dup(X509_get0_serialNumber(cert));
- if (cid->issuer_serial->serial == NULL)
+ if (cid->issuer_serial->serial == NULL) {
+ ERR_raise(ERR_LIB_ESS, ERR_R_ASN1_LIB);
goto err;
+ }
return cid;
err:
X509_ALGOR_free(alg);
GENERAL_NAME_free(name);
ESS_CERT_ID_V2_free(cid);
- ERR_raise(ERR_LIB_ESS, ERR_R_MALLOC_FAILURE);
return NULL;
}
{
EVP_ASYM_CIPHER *cipher = OPENSSL_zalloc(sizeof(EVP_ASYM_CIPHER));
- if (cipher == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (cipher == NULL)
return NULL;
- }
cipher->lock = CRYPTO_THREAD_lock_new();
if (cipher->lock == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
OPENSSL_free(cipher);
return NULL;
}
int gparamfncnt = 0, sparamfncnt = 0;
if ((cipher = evp_asym_cipher_new(prov)) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
goto err;
}
{
BIO_B64_CTX *ctx;
- if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
return 0;
- }
ctx->cont = 1;
ctx->start = 1;
{
BIO_ENC_CTX *ctx;
- if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
return 0;
- }
ctx->cipher = EVP_CIPHER_CTX_new();
if (ctx->cipher == NULL) {
{
BIO_OK_CTX *ctx;
- if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
return 0;
- }
ctx->cont = 1;
ctx->sigio = 1;
if (ctx->p2 != NULL) {
if (ctx->action_type == SET) {
ctx->buflen = BN_num_bytes(ctx->p2);
- if ((ctx->allocated_buf =
- OPENSSL_malloc(ctx->buflen)) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if ((ctx->allocated_buf
+ = OPENSSL_malloc(ctx->buflen)) == NULL)
return 0;
- }
if (BN_bn2nativepad(ctx->p2,
ctx->allocated_buf, ctx->buflen) < 0) {
OPENSSL_free(ctx->allocated_buf);
if ((ctx = EVP_MD_CTX_new()) == NULL
|| (pctx = EVP_PKEY_CTX_new_from_pkey(libctx, pkey, propq)) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
goto err;
}
if (!(ctx->flags & EVP_MD_CTX_FLAG_NO_INIT) && type->ctx_size) {
ctx->update = type->update;
ctx->md_data = OPENSSL_zalloc(type->ctx_size);
- if (ctx->md_data == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (ctx->md_data == NULL)
return 0;
- }
}
}
#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
out->md_data = tmp_buf;
else {
out->md_data = OPENSSL_malloc(out->digest->ctx_size);
- if (out->md_data == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (out->md_data == NULL)
return 0;
- }
}
memcpy(out->md_data, in->md_data, out->digest->ctx_size);
}
/* EVP_MD_fetch() will set the legacy NID if available */
if ((md = evp_md_new()) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
return NULL;
}
if (gctx->iv != c->iv)
OPENSSL_free(gctx->iv);
- if ((gctx->iv = OPENSSL_malloc(len)) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if ((gctx->iv = OPENSSL_malloc(len)) == NULL)
return 0;
- }
}
/* Add padding. */
memset(gctx->iv + arg, 0, len - arg - 8);
} else {
len = S390X_gcm_ivpadlen(gctx->ivlen);
- if ((gctx_out->iv = OPENSSL_malloc(len)) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if ((gctx_out->iv = OPENSSL_malloc(len)) == NULL)
return 0;
- }
memcpy(gctx_out->iv, gctx->iv, len);
}
if ((arg > EVP_MAX_IV_LENGTH) && (arg > gctx->ivlen)) {
if (gctx->iv != c->iv)
OPENSSL_free(gctx->iv);
- if ((gctx->iv = OPENSSL_malloc(arg)) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if ((gctx->iv = OPENSSL_malloc(arg)) == NULL)
return 0;
- }
}
gctx->ivlen = arg;
return 1;
if (gctx->iv == c->iv)
gctx_out->iv = out->iv;
else {
- if ((gctx_out->iv = OPENSSL_malloc(gctx->ivlen)) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if ((gctx_out->iv = OPENSSL_malloc(gctx->ivlen)) == NULL)
return 0;
- }
memcpy(gctx_out->iv, gctx->iv, gctx->ivlen);
}
return 1;
if ((arg > EVP_MAX_IV_LENGTH) && (arg > gctx->ivlen)) {
if (gctx->iv != c->iv)
OPENSSL_free(gctx->iv);
- if ((gctx->iv = OPENSSL_malloc(arg)) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if ((gctx->iv = OPENSSL_malloc(arg)) == NULL)
return 0;
- }
}
gctx->ivlen = arg;
return 1;
if (gctx->iv == c->iv)
gctx_out->iv = out->iv;
else {
- if ((gctx_out->iv = OPENSSL_malloc(gctx->ivlen)) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if ((gctx_out->iv = OPENSSL_malloc(gctx->ivlen)) == NULL)
return 0;
- }
memcpy(gctx_out->iv, gctx->iv, gctx->ivlen);
}
return 1;
ctx->cipher_data = OPENSSL_zalloc(ctx->cipher->ctx_size);
if (ctx->cipher_data == NULL) {
ctx->cipher = NULL;
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
return 0;
}
} else {
out->cipher_data = OPENSSL_malloc(in->cipher->ctx_size);
if (out->cipher_data == NULL) {
out->cipher = NULL;
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
return 0;
}
memcpy(out->cipher_data, in->cipher_data, in->cipher->ctx_size);
int fnciphcnt = 0, fnctxcnt = 0;
if ((cipher = evp_cipher_new()) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
return NULL;
}
pl2 = ossl_property_merge(pl1, *plp);
ossl_property_free(pl1);
if (pl2 == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
return 0;
}
if (!evp_set_parsed_default_properties(libctx, pl2, 0, 0)) {
}
propstr = OPENSSL_malloc(sz);
- if (propstr == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (propstr == NULL)
return NULL;
- }
if (ossl_property_list_to_string(libctx, *plp, propstr, sz) == 0) {
ERR_raise(ERR_LIB_EVP, ERR_R_INTERNAL_ERROR);
OPENSSL_free(propstr);
int EVP_PBE_alg_add_type(int pbe_type, int pbe_nid, int cipher_nid,
int md_nid, EVP_PBE_KEYGEN *keygen)
{
- EVP_PBE_CTL *pbe_tmp;
+ EVP_PBE_CTL *pbe_tmp = NULL;
if (pbe_algs == NULL) {
pbe_algs = sk_EVP_PBE_CTL_new(pbe_cmp);
- if (pbe_algs == NULL)
+ if (pbe_algs == NULL) {
+ ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
goto err;
+ }
}
if ((pbe_tmp = OPENSSL_zalloc(sizeof(*pbe_tmp))) == NULL)
pbe_tmp->keygen = keygen;
if (!sk_EVP_PBE_CTL_push(pbe_algs, pbe_tmp)) {
- OPENSSL_free(pbe_tmp);
+ ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
goto err;
}
return 1;
err:
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ OPENSSL_free(pbe_tmp);
return 0;
}
return NULL;
if ((pkey = EVP_PKEY_new()) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
return NULL;
}
} else {
p8 = PKCS8_PRIV_KEY_INFO_new();
if (p8 == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_ASN1_LIB);
return NULL;
}
#endif
if ((rand = evp_rand_new()) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
return NULL;
}
rand->name_id = name_id;
}
ctx = OPENSSL_zalloc(sizeof(*ctx));
- if (ctx == NULL || (ctx->refcnt_lock = CRYPTO_THREAD_lock_new()) == NULL) {
+ if (ctx == NULL)
+ return NULL;
+ if ((ctx->refcnt_lock = CRYPTO_THREAD_lock_new()) == NULL) {
OPENSSL_free(ctx);
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
return NULL;
}
if (parent != NULL) {
if ((ctx->algctx = rand->newctx(ossl_provider_ctx(rand->prov), parent_ctx,
parent_dispatch)) == NULL
|| !EVP_RAND_up_ref(rand)) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
rand->freectx(ctx->algctx);
CRYPTO_THREAD_lock_free(ctx->refcnt_lock);
OPENSSL_free(ctx);
{
EVP_KEYEXCH *exchange = OPENSSL_zalloc(sizeof(EVP_KEYEXCH));
- if (exchange == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (exchange == NULL)
return NULL;
- }
exchange->lock = CRYPTO_THREAD_lock_new();
if (exchange->lock == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
OPENSSL_free(exchange);
return NULL;
}
int fncnt = 0, sparamfncnt = 0, gparamfncnt = 0;
if ((exchange = evp_keyexch_new(prov)) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
goto err;
}
if (ctx == NULL
|| (ctx->algctx = kdf->newctx(ossl_provider_ctx(kdf->prov))) == NULL
|| !EVP_KDF_up_ref(kdf)) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
if (ctx != NULL)
kdf->freectx(ctx->algctx);
OPENSSL_free(ctx);
return NULL;
dst = OPENSSL_malloc(sizeof(*dst));
- if (dst == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (dst == NULL)
return NULL;
- }
memcpy(dst, src, sizeof(*dst));
if (!EVP_KDF_up_ref(dst->meth)) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
OPENSSL_free(dst);
return NULL;
}
int fnkdfcnt = 0, fnctxcnt = 0;
if ((kdf = evp_kdf_new()) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
return NULL;
}
kdf->name_id = name_id;
{
EVP_KEM *kem = OPENSSL_zalloc(sizeof(EVP_KEM));
- if (kem == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (kem == NULL)
return NULL;
- }
kem->lock = CRYPTO_THREAD_lock_new();
if (kem->lock == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
OPENSSL_free(kem);
return NULL;
}
int gparamfncnt = 0, sparamfncnt = 0;
if ((kem = evp_kem_new(prov)) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
goto err;
}
/* Just in time creation of keydata */
if (data->keydata == NULL) {
if ((data->keydata = evp_keymgmt_newdata(data->keymgmt)) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
return 0;
}
delete_on_error = 1;
{
EVP_KEYMGMT *keymgmt = NULL;
- if ((keymgmt = OPENSSL_zalloc(sizeof(*keymgmt))) == NULL
- || (keymgmt->lock = CRYPTO_THREAD_lock_new()) == NULL) {
+ if ((keymgmt = OPENSSL_zalloc(sizeof(*keymgmt))) == NULL)
+ return NULL;
+ if ((keymgmt->lock = CRYPTO_THREAD_lock_new()) == NULL) {
EVP_KEYMGMT_free(keymgmt);
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
return NULL;
}
{
EVP_MAC_CTX *ctx = OPENSSL_zalloc(sizeof(EVP_MAC_CTX));
- if (ctx == NULL
- || (ctx->algctx = mac->newctx(ossl_provider_ctx(mac->prov))) == NULL
- || !EVP_MAC_up_ref(mac)) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
- if (ctx != NULL)
- mac->freectx(ctx->algctx);
- OPENSSL_free(ctx);
- ctx = NULL;
- } else {
+ if (ctx != NULL) {
ctx->meth = mac;
+ if ((ctx->algctx = mac->newctx(ossl_provider_ctx(mac->prov))) == NULL
+ || !EVP_MAC_up_ref(mac)) {
+ mac->freectx(ctx->algctx);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
+ OPENSSL_free(ctx);
+ ctx = NULL;
+ }
}
return ctx;
}
return NULL;
dst = OPENSSL_malloc(sizeof(*dst));
- if (dst == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (dst == NULL)
return NULL;
- }
*dst = *src;
if (!EVP_MAC_up_ref(dst->meth)) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
OPENSSL_free(dst);
return NULL;
}
int fnmaccnt = 0, fnctxcnt = 0;
if ((mac = evp_mac_new()) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
return NULL;
}
mac->name_id = name_id;
pkey = EVP_PKEY_new();
if (pkey == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
goto err;
}
{
EVP_PKEY *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->type = EVP_PKEY_NONE;
ret->save_type = EVP_PKEY_NONE;
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- EVPerr(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
goto err;
}
#ifndef FIPS_MODULE
ret->save_parameters = 1;
if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_EVP_PKEY, ret, &ret->ex_data)) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
goto err;
}
#endif
if (*dest == NULL) {
allocpkey = *dest = EVP_PKEY_new();
if (*dest == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
return 0;
}
} else {
EVP_PKEY_CTX_new_from_pkey(libctx, *dest, NULL);
if (pctx == NULL)
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
if (pctx != NULL
&& evp_keymgmt_export(keymgmt, keydata,
return 1;
if ((pctx = EVP_PKEY_CTX_new(priv, NULL)) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
goto err;
}
|| EVP_PKEY_decrypt(pctx, NULL, &keylen, ek, ekl) <= 0)
goto err;
- if ((key = OPENSSL_malloc(keylen)) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if ((key = OPENSSL_malloc(keylen)) == NULL)
goto err;
- }
if (EVP_PKEY_decrypt(pctx, key, &keylen, ek, ekl) <= 0)
goto err;
pctx = EVP_PKEY_CTX_new_from_pkey(libctx, pubk[i], NULL);
if (pctx == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
goto err;
}
EVP_MD_CTX *tmp_ctx = EVP_MD_CTX_new();
if (tmp_ctx == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
return 0;
}
rv = EVP_MD_CTX_copy_ex(tmp_ctx, ctx);
EVP_MD_CTX *tmp_ctx = EVP_MD_CTX_new();
if (tmp_ctx == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
return 0;
}
rv = EVP_MD_CTX_copy_ex(tmp_ctx, ctx);
*ppkey = allocated_pkey = EVP_PKEY_new();
if (*ppkey == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
return -1;
}
allocated_pkey = *ppkey = EVP_PKEY_new();
if (*ppkey == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
return -1;
}
EVP_PKEY_METHOD *pmeth;
pmeth = OPENSSL_zalloc(sizeof(*pmeth));
- if (pmeth == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (pmeth == NULL)
return NULL;
- }
pmeth->pkey_id = id;
pmeth->flags = flags | EVP_PKEY_FLAG_DYNAMIC;
ERR_raise(ERR_LIB_EVP, EVP_R_UNSUPPORTED_ALGORITHM);
} else {
ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL)
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
}
#if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
}
# endif
rctx = OPENSSL_zalloc(sizeof(*rctx));
- if (rctx == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (rctx == NULL)
return NULL;
- }
if (pctx->pkey != NULL)
EVP_PKEY_up_ref(pctx->pkey);
if (app_pkey_methods == NULL) {
app_pkey_methods = sk_EVP_PKEY_METHOD_new(pmeth_cmp);
if (app_pkey_methods == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
return 0;
}
}
if (!sk_EVP_PKEY_METHOD_push(app_pkey_methods, pmeth)) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
return 0;
}
sk_EVP_PKEY_METHOD_sort(app_pkey_methods);
evp_pkey_ctx_free_cached_data(ctx, cmd, name);
if (name != NULL) {
ctx->cached_parameters.dist_id_name = OPENSSL_strdup(name);
- if (ctx->cached_parameters.dist_id_name == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (ctx->cached_parameters.dist_id_name == NULL)
return 0;
- }
}
if (data_len > 0) {
ctx->cached_parameters.dist_id = OPENSSL_memdup(data, data_len);
- if (ctx->cached_parameters.dist_id == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (ctx->cached_parameters.dist_id == NULL)
return 0;
- }
}
ctx->cached_parameters.dist_id_set = 1;
ctx->cached_parameters.dist_id_len = data_len;
{
EVP_SIGNATURE *signature = OPENSSL_zalloc(sizeof(EVP_SIGNATURE));
- if (signature == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (signature == NULL)
return NULL;
- }
signature->lock = CRYPTO_THREAD_lock_new();
if (signature->lock == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_CRYPTO_LIB);
OPENSSL_free(signature);
return NULL;
}
int gparamfncnt = 0, sparamfncnt = 0, gmdparamfncnt = 0, smdparamfncnt = 0;
if ((signature = evp_signature_new(prov)) == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_EVP, ERR_R_EVP_LIB);
goto err;
}
* "app_data" routines use ex_data index zero. See RT 3710. */
if (ip->meth == NULL
|| !sk_EX_CALLBACK_push(ip->meth, NULL)) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CRYPTO, ERR_R_CRYPTO_LIB);
goto err;
}
}
a = (EX_CALLBACK *)OPENSSL_malloc(sizeof(*a));
- if (a == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (a == NULL)
goto err;
- }
a->argl = argl;
a->argp = argp;
a->new_func = new_func;
a->priority = priority;
if (!sk_EX_CALLBACK_push(ip->meth, NULL)) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CRYPTO, ERR_R_CRYPTO_LIB);
OPENSSL_free(a);
goto err;
}
}
CRYPTO_THREAD_unlock(global->ex_data_lock);
- if (mx > 0 && storage == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (mx > 0 && storage == NULL)
return 0;
- }
for (i = 0; i < mx; i++) {
if (storage[i] != NULL && storage[i]->new_func != NULL) {
ptr = CRYPTO_get_ex_data(ad, i);
if (mx == 0)
return 1;
- if (storage == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (storage == NULL)
return 0;
- }
/*
* Make sure the ex_data stack is at least |mx| elements long to avoid
* issues in the for loop that follows; so go get the |mx|'th element
if (ad->sk == NULL) {
if ((ad->sk = sk_void_new_null()) == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CRYPTO, ERR_R_CRYPTO_LIB);
return 0;
}
}
for (i = sk_void_num(ad->sk); i <= idx; ++i) {
if (!sk_void_push(ad->sk, NULL)) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CRYPTO, ERR_R_CRYPTO_LIB);
return 0;
}
}
}
#endif
- if ((newhand = OPENSSL_malloc(sizeof(*newhand))) == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if ((newhand = OPENSSL_malloc(sizeof(*newhand))) == NULL)
return 0;
- }
newhand->handler = handler;
newhand->next = stop_handlers;
{
OPENSSL_LHASH *ret;
- if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
- /*
- * Do not set the error code, because the ERR code uses LHASH
- * and we want to avoid possible endless error loop.
- * ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
- */
+ if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
return NULL;
- }
if ((ret->b = OPENSSL_zalloc(sizeof(*ret->b) * MIN_NODES)) == NULL)
goto err;
ret->comp = ((c == NULL) ? (OPENSSL_LH_COMPFUNC)strcmp : c);
memset(ctx, 0, sizeof(*ctx));
ctx->l_index = 0;
ctx->max_l_index = 5;
- if ((ctx->l = OPENSSL_malloc(ctx->max_l_index * 16)) == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if ((ctx->l = OPENSSL_malloc(ctx->max_l_index * 16)) == NULL)
return 0;
- }
/*
* We set both the encryption and decryption key schedules - decryption
if (keydec)
dest->keydec = keydec;
if (src->l) {
- if ((dest->l = OPENSSL_malloc(src->max_l_index * 16)) == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if ((dest->l = OPENSSL_malloc(src->max_l_index * 16)) == NULL)
return 0;
- }
memcpy(dest->l, src->l, (src->l_index + 1) * 16);
}
return 1;
char *iterator;
char lastchar;
- if ((newname = OPENSSL_malloc(strlen(filename) + 1)) == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if ((newname = OPENSSL_malloc(strlen(filename) + 1)) == NULL)
return NULL;
- }
for (iterator = newname, lastchar = '\0';
*filename; filename++, iterator++) {
return NULL;
ret = CRYPTO_malloc(siz, file, line);
- if (ret == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
return memcpy(ret, data, siz);
}
return NULL;
}
buf_n /= 2;
- if ((buf = OPENSSL_malloc(buf_n)) == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if ((buf = OPENSSL_malloc(buf_n)) == NULL)
return NULL;
- }
if (buflen != NULL)
*buflen = 0;
return OPENSSL_zalloc(1);
tmp_n = (sep != CH_ZERO) ? buflen * 3 : 1 + buflen * 2;
- if ((tmp = OPENSSL_malloc(tmp_n)) == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if ((tmp = OPENSSL_malloc(tmp_n)) == NULL)
return NULL;
- }
if (buf2hexstr_sep(tmp, tmp_n, NULL, buf, buflen, sep))
return tmp;
for (i = sk_NAME_FUNCS_num(name_funcs_stack); i < names_type_num; i++) {
name_funcs = OPENSSL_zalloc(sizeof(*name_funcs));
if (name_funcs == NULL) {
- ERR_raise(ERR_LIB_OBJ, ERR_R_MALLOC_FAILURE);
ret = 0;
goto out;
}
push = sk_NAME_FUNCS_push(name_funcs_stack, name_funcs);
if (!push) {
- ERR_raise(ERR_LIB_OBJ, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OBJ, ERR_R_CRYPTO_LIB);
OPENSSL_free(name_funcs);
ret = 0;
goto out;
|| (o->sn != NULL
&& (ao[ADDED_SNAME] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL)
|| (o->ln != NULL
- && (ao[ADDED_LNAME] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL)) {
- ERR_raise(ERR_LIB_OBJ, ERR_R_MALLOC_FAILURE);
+ && (ao[ADDED_LNAME] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL))
goto err2;
- }
if (!ossl_obj_write_lock(lock)) {
ERR_raise(ERR_LIB_OBJ, ERR_R_UNABLE_TO_GET_WRITE_LOCK);
if (added == NULL) {
added = lh_ADDED_OBJ_new(added_obj_hash, added_obj_cmp);
if (added == NULL) {
- ERR_raise(ERR_LIB_OBJ, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OBJ, ERR_R_CRYPTO_LIB);
goto err;
}
}
if (j < 0)
return NULL;
- if ((buf = OPENSSL_malloc(j)) == NULL) {
- ERR_raise(ERR_LIB_OBJ, ERR_R_MALLOC_FAILURE);
+ if ((buf = OPENSSL_malloc(j)) == NULL)
return NULL;
- }
p = buf;
/* Write out tag+length */
return r;
err:
ASN1_OBJECT_free(r);
- ERR_raise(ERR_LIB_OBJ, ERR_R_MALLOC_FAILURE);
return NULL;
}
if (!obj_sig_init())
return 0;
- if ((ntr = OPENSSL_malloc(sizeof(*ntr))) == NULL) {
- ERR_raise(ERR_LIB_OBJ, ERR_R_MALLOC_FAILURE);
+ if ((ntr = OPENSSL_malloc(sizeof(*ntr))) == NULL)
return 0;
- }
ntr->sign_id = signid;
ntr->hash_id = dig_id;
ntr->pkey_id = pkey_id;
int ret = -1;
if (ctx == NULL) {
- ERR_raise(ERR_LIB_OCSP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OCSP, ERR_R_X509_LIB);
goto end;
}
if (!X509_STORE_CTX_init(ctx, st, signer, untrusted)) {
err:
if ((pos == NULL) || (*pos != os))
ASN1_OCTET_STRING_free(os);
- ERR_raise(ERR_LIB_OCSP, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OCSP, ERR_R_ASN1_LIB);
return NULL;
}
pkt->curr = 0;
pkt->written = 0;
- if ((pkt->subs = OPENSSL_zalloc(sizeof(*pkt->subs))) == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if ((pkt->subs = OPENSSL_zalloc(sizeof(*pkt->subs))) == NULL)
return 0;
- }
if (lenbytes == 0)
return 1;
if (lenbytes > 0 && pkt->endfirst)
return 0;
- if ((sub = OPENSSL_zalloc(sizeof(*sub))) == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if ((sub = OPENSSL_zalloc(sizeof(*sub))) == NULL)
return 0;
- }
sub->parent = pkt->subs;
pkt->subs = sub;
{
OSSL_PARAM_BLD_DEF *pd = OPENSSL_zalloc(sizeof(*pd));
- if (pd == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (pd == NULL)
return NULL;
- }
pd->key = key;
pd->type = type;
pd->size = size;
}
params = OPENSSL_malloc(total);
if (params == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
OPENSSL_secure_free(s);
return NULL;
}
}
if (b == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CRYPTO, ERR_R_BN_LIB);
return 0;
}
if (*val == NULL) {
char *const q = OPENSSL_malloc(alloc_sz);
- if (q == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (q == NULL)
return 0;
- }
*val = q;
*max_len = alloc_sz;
}
size_t sz = OSSL_PARAM_ALIGN_SIZE * (extra_blocks + out->blocks);
out->alloc = is_secure ? OPENSSL_secure_zalloc(sz) : OPENSSL_zalloc(sz);
- if (out->alloc == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, is_secure ? CRYPTO_R_SECURE_MALLOC_FAILURE
- : ERR_R_MALLOC_FAILURE);
+ if (out->alloc == NULL)
return 0;
- }
out->alloc_sz = sz;
out->cur = out->alloc + extra_blocks;
return 1;
/* Allocate enough space to store the merged parameters */
params = OPENSSL_zalloc((list1_sz + list2_sz + 1) * sizeof(*p1));
- if (params == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (params == NULL)
return NULL;
- }
dst = params;
p1cur = list1;
p2cur = list2;
¶mdef, &ishex, &buf_n, &tmpbn, found))
goto err;
- if ((buf = OPENSSL_zalloc(buf_n > 0 ? buf_n : 1)) == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if ((buf = OPENSSL_zalloc(buf_n > 0 ? buf_n : 1)) == NULL)
goto err;
- }
ok = construct_from_text(to, paramdef, value, value_n, ishex,
buf, buf_n, tmpbn);
data->_.expl_passphrase.passphrase_copy =
passphrase_len != 0 ? OPENSSL_memdup(passphrase, passphrase_len)
: OPENSSL_malloc(1);
- if (data->_.expl_passphrase.passphrase_copy == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (data->_.expl_passphrase.passphrase_copy == NULL)
return 0;
- }
data->_.expl_passphrase.passphrase_len = passphrase_len;
return 1;
}
}
if ((ui = UI_new()) == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CRYPTO, ERR_R_UI_LIB);
return 0;
}
/* Get an application constructed prompt */
prompt = UI_construct_prompt(ui, "pass phrase", prompt_info);
if (prompt == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CRYPTO, ERR_R_UI_LIB);
goto end;
}
/* Get a buffer for verification prompt */
ipass = OPENSSL_zalloc(pass_size + 1);
- if (ipass == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (ipass == NULL)
goto end;
- }
prompt_idx = UI_add_input_string(ui, prompt,
UI_INPUT_FLAG_DEFAULT_PWD,
if (verify) {
/* Get a buffer for verification prompt */
vpass = OPENSSL_zalloc(pass_size + 1);
- if (vpass == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (vpass == NULL)
goto end;
- }
verify_idx = UI_add_verify_string(ui, prompt,
UI_INPUT_FLAG_DEFAULT_PWD,
vpass, 0, pass_size,
ui_data = data->_.pem_password.password_cbarg;
if (ui_method == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CRYPTO, ERR_R_UI_LIB);
return 0;
}
} else if (data->type == is_ui_method) {
if (new_cache == NULL) {
OPENSSL_cleanse(pass, *pass_len);
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
return 0;
}
data->cached_passphrase = new_cache;
if (sk == NULL) {
if ((ret = sk_X509_INFO_new_null()) == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PEM, ERR_R_CRYPTO_LIB);
goto err;
}
} else
return 0;
}
-static void pem_free(void *p, unsigned int flags, size_t num)
+#define PEM_FREE(p, flags, num) \
+ pem_free((p), (flags), (num), OPENSSL_FILE, OPENSSL_LINE)
+static void pem_free(void *p, unsigned int flags, size_t num,
+ const char *file, int line)
{
if (flags & PEM_FLAG_SECURE)
- OPENSSL_secure_clear_free(p, num);
+ CRYPTO_secure_clear_free(p, num, file, line);
else
- OPENSSL_free(p);
+ CRYPTO_free(p, file, line);
}
-static void *pem_malloc(int num, unsigned int flags)
+#define PEM_MALLOC(num, flags) \
+ pem_malloc((num), (flags), OPENSSL_FILE, OPENSSL_LINE)
+static void *pem_malloc(int num, unsigned int flags,
+ const char *file, int line)
{
- return (flags & PEM_FLAG_SECURE) ? OPENSSL_secure_malloc(num)
- : OPENSSL_malloc(num);
+ return (flags & PEM_FLAG_SECURE) ? CRYPTO_secure_malloc(num, file, line)
+ : CRYPTO_malloc(num, file, line);
+
}
static int pem_bytes_read_bio_flags(unsigned char **pdata, long *plen,
int ret = 0;
do {
- pem_free(nm, flags, 0);
- pem_free(header, flags, 0);
- pem_free(data, flags, len);
+ PEM_FREE(nm, flags, 0);
+ PEM_FREE(header, flags, 0);
+ PEM_FREE(data, flags, len);
if (!PEM_read_bio_ex(bp, &nm, &header, &data, &len, flags)) {
if (ERR_GET_REASON(ERR_peek_error()) == PEM_R_NO_START_LINE)
ERR_add_error_data(2, "Expecting: ", name);
err:
if (!ret || pnm == NULL)
- pem_free(nm, flags, 0);
- pem_free(header, flags, 0);
+ PEM_FREE(nm, flags, 0);
+ PEM_FREE(header, flags, 0);
if (!ret)
- pem_free(data, flags, len);
+ PEM_FREE(data, flags, len);
return ret;
}
/* dsize + 8 bytes are needed */
/* actually it needs the cipher block size extra... */
data = OPENSSL_malloc((unsigned int)dsize + 20);
- if (data == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ if (data == NULL)
goto err;
- }
p = data;
i = i2d(x, &p);
int nlen, n, i, j, outl;
unsigned char *buf = NULL;
EVP_ENCODE_CTX *ctx = EVP_ENCODE_CTX_new();
- int reason = ERR_R_BUF_LIB;
+ int reason = 0;
int retval = 0;
if (ctx == NULL) {
- reason = ERR_R_MALLOC_FAILURE;
+ reason = ERR_R_EVP_LIB;
goto err;
}
if ((BIO_write(bp, "-----BEGIN ", 11) != 11) ||
(BIO_write(bp, name, nlen) != nlen) ||
- (BIO_write(bp, "-----\n", 6) != 6))
+ (BIO_write(bp, "-----\n", 6) != 6)) {
+ reason = ERR_R_BIO_LIB;
goto err;
+ }
i = header != NULL ? strlen(header) : 0;
if (i > 0) {
- if ((BIO_write(bp, header, i) != i) || (BIO_write(bp, "\n", 1) != 1))
+ if ((BIO_write(bp, header, i) != i) || (BIO_write(bp, "\n", 1) != 1)) {
+ reason = ERR_R_BIO_LIB;
goto err;
+ }
}
buf = OPENSSL_malloc(PEM_BUFSIZE * 8);
- if (buf == NULL) {
- reason = ERR_R_MALLOC_FAILURE;
+ if (buf == NULL)
goto err;
- }
i = j = 0;
while (len > 0) {
n = (int)((len > (PEM_BUFSIZE * 5)) ? (PEM_BUFSIZE * 5) : len);
- if (!EVP_EncodeUpdate(ctx, buf, &outl, &(data[j]), n))
+ if (!EVP_EncodeUpdate(ctx, buf, &outl, &(data[j]), n)) {
+ reason = ERR_R_EVP_LIB;
goto err;
- if ((outl) && (BIO_write(bp, (char *)buf, outl) != outl))
+ }
+ if ((outl) && (BIO_write(bp, (char *)buf, outl) != outl)) {
+ reason = ERR_R_BIO_LIB;
goto err;
+ }
i += outl;
len -= n;
j += n;
}
EVP_EncodeFinal(ctx, buf, &outl);
- if ((outl > 0) && (BIO_write(bp, (char *)buf, outl) != outl))
+ if ((outl > 0) && (BIO_write(bp, (char *)buf, outl) != outl)) {
+ reason = ERR_R_BIO_LIB;
goto err;
+ }
if ((BIO_write(bp, "-----END ", 9) != 9) ||
(BIO_write(bp, name, nlen) != nlen) ||
- (BIO_write(bp, "-----\n", 6) != 6))
+ (BIO_write(bp, "-----\n", 6) != 6)) {
+ reason = ERR_R_BIO_LIB;
goto err;
+ }
retval = i + outl;
err:
- if (retval == 0)
+ if (retval == 0 && reason != 0)
ERR_raise(ERR_LIB_PEM, reason);
EVP_ENCODE_CTX_free(ctx);
OPENSSL_clear_free(buf, PEM_BUFSIZE * 8);
* Need to hold trailing NUL (accounted for by BIO_gets() and the newline
* that will be added by sanitize_line() (the extra '1').
*/
- linebuf = pem_malloc(LINESIZE + 1, flags);
- if (linebuf == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ linebuf = PEM_MALLOC(LINESIZE + 1, flags);
+ if (linebuf == NULL)
return 0;
- }
do {
len = BIO_gets(bp, linebuf, LINESIZE);
|| !HAS_PREFIX(linebuf + len - TAILLEN, TAILSTR));
linebuf[len - TAILLEN] = '\0';
len = len - BEGINLEN - TAILLEN + 1;
- *name = pem_malloc(len, flags);
- if (*name == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ *name = PEM_MALLOC(len, flags);
+ if (*name == NULL)
goto err;
- }
memcpy(*name, linebuf + BEGINLEN, len);
ret = 1;
err:
- pem_free(linebuf, flags, LINESIZE + 1);
+ PEM_FREE(linebuf, flags, LINESIZE + 1);
return ret;
}
/* Need to hold trailing NUL (accounted for by BIO_gets() and the newline
* that will be added by sanitize_line() (the extra '1'). */
- linebuf = pem_malloc(LINESIZE + 1, flags);
- if (linebuf == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ linebuf = PEM_MALLOC(LINESIZE + 1, flags);
+ if (linebuf == NULL)
return 0;
- }
for (line = 0; ; line++) {
flags_mask = ~0u;
ret = 1;
err:
- pem_free(linebuf, flags, LINESIZE + 1);
+ PEM_FREE(linebuf, flags, LINESIZE + 1);
return ret;
}
headerB = BIO_new(bmeth);
dataB = BIO_new(bmeth);
if (headerB == NULL || dataB == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PEM, ERR_R_BIO_LIB);
goto end;
}
ctx = EVP_ENCODE_CTX_new();
if (ctx == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PEM, ERR_R_EVP_LIB);
goto end;
}
buf_mem->length = len;
headerlen = BIO_get_mem_data(headerB, NULL);
- *header = pem_malloc(headerlen + 1, flags);
- *data = pem_malloc(len, flags);
+ *header = PEM_MALLOC(headerlen + 1, flags);
+ *data = PEM_MALLOC(len, flags);
if (*header == NULL || *data == NULL)
goto out_free;
if (headerlen != 0 && BIO_read(headerB, *header, headerlen) != headerlen)
goto end;
out_free:
- pem_free(*header, flags, 0);
- pem_free(*data, flags, 0);
+ PEM_FREE(*header, flags, 0);
+ PEM_FREE(*data, flags, 0);
end:
EVP_ENCODE_CTX_free(ctx);
- pem_free(name, flags, 0);
+ PEM_FREE(name, flags, 0);
BIO_free(headerB);
BIO_free(dataB);
return ret;
unsigned int m_len;
m = OPENSSL_malloc(EVP_PKEY_get_size(pkey));
- if (m == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ if (m == NULL)
goto err;
- }
if (EVP_SignFinal(ctx, m, &m_len, pkey) <= 0)
goto err;
case EVP_PKEY_RSA:
if (EVP_PKEY_set1_RSA(pkey, key))
break;
+ ERR_raise(ERR_LIB_PEM, ERR_R_EVP_LIB);
EVP_PKEY_free(pkey);
pkey = NULL;
break;
case EVP_PKEY_DSA:
if (EVP_PKEY_set1_DSA(pkey, key))
break;
+ ERR_raise(ERR_LIB_PEM, ERR_R_EVP_LIB);
EVP_PKEY_free(pkey);
pkey = NULL;
break;
#endif
}
+ } else {
+ ERR_raise(ERR_LIB_PEM, ERR_R_EVP_LIB);
}
switch (evp_type) {
#endif
}
- if (pkey == NULL)
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
return pkey;
}
return NULL;
}
buf = OPENSSL_malloc(length);
- if (buf == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ if (buf == NULL)
goto err;
- }
p = buf;
if (BIO_read(in, buf, length) != (int)length) {
ERR_raise(ERR_LIB_PEM, PEM_R_KEYBLOB_TOO_SHORT);
dsa = DSA_new();
if (dsa == NULL)
- goto memerr;
+ goto dsaerr;
if (!read_lebn(&p, nbyte, &pbn))
- goto memerr;
+ goto bnerr;
if (!read_lebn(&p, 20, &qbn))
- goto memerr;
+ goto bnerr;
if (!read_lebn(&p, nbyte, &gbn))
- goto memerr;
+ goto bnerr;
if (ispub) {
if (!read_lebn(&p, nbyte, &pub_key))
- goto memerr;
+ goto bnerr;
} else {
if (!read_lebn(&p, 20, &priv_key))
- goto memerr;
+ goto bnerr;
/* Set constant time flag before public key calculation */
BN_set_flags(priv_key, BN_FLG_CONSTTIME);
/* Calculate public key */
pub_key = BN_new();
if (pub_key == NULL)
- goto memerr;
+ goto bnerr;
if ((ctx = BN_CTX_new()) == NULL)
- goto memerr;
+ goto bnerr;
if (!BN_mod_exp(pub_key, gbn, priv_key, pbn, ctx))
- goto memerr;
+ goto bnerr;
BN_CTX_free(ctx);
ctx = NULL;
}
if (!DSA_set0_pqg(dsa, pbn, qbn, gbn))
- goto memerr;
+ goto dsaerr;
pbn = qbn = gbn = NULL;
if (!DSA_set0_key(dsa, pub_key, priv_key))
- goto memerr;
+ goto dsaerr;
pub_key = priv_key = NULL;
*in = p;
return dsa;
- memerr:
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ dsaerr:
+ ERR_raise(ERR_LIB_PEM, ERR_R_DSA_LIB);
+ goto err;
+ bnerr:
+ ERR_raise(ERR_LIB_PEM, ERR_R_BN_LIB);
+
+ err:
DSA_free(dsa);
BN_free(pbn);
BN_free(qbn);
rsa = RSA_new();
if (rsa == NULL)
- goto memerr;
+ goto rsaerr;
e = BN_new();
if (e == NULL)
- goto memerr;
+ goto bnerr;
if (!BN_set_word(e, read_ledword(&pin)))
- goto memerr;
+ goto bnerr;
if (!read_lebn(&pin, nbyte, &n))
- goto memerr;
+ goto bnerr;
if (!ispub) {
if (!read_lebn(&pin, hnbyte, &p))
- goto memerr;
+ goto bnerr;
if (!read_lebn(&pin, hnbyte, &q))
- goto memerr;
+ goto bnerr;
if (!read_lebn(&pin, hnbyte, &dmp1))
- goto memerr;
+ goto bnerr;
if (!read_lebn(&pin, hnbyte, &dmq1))
- goto memerr;
+ goto bnerr;
if (!read_lebn(&pin, hnbyte, &iqmp))
- goto memerr;
+ goto bnerr;
if (!read_lebn(&pin, nbyte, &d))
- goto memerr;
+ goto bnerr;
if (!RSA_set0_factors(rsa, p, q))
- goto memerr;
+ goto rsaerr;
p = q = NULL;
if (!RSA_set0_crt_params(rsa, dmp1, dmq1, iqmp))
- goto memerr;
+ goto rsaerr;
dmp1 = dmq1 = iqmp = NULL;
}
if (!RSA_set0_key(rsa, n, e, d))
- goto memerr;
+ goto rsaerr;
n = e = d = NULL;
*in = pin;
return rsa;
- memerr:
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+
+ rsaerr:
+ ERR_raise(ERR_LIB_PEM, ERR_R_RSA_LIB);
+ goto err;
+ bnerr:
+ ERR_raise(ERR_LIB_PEM, ERR_R_BN_LIB);
+
+ err:
BN_free(e);
BN_free(n);
BN_free(p);
p = *out;
else {
if ((p = OPENSSL_malloc(outlen)) == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
outlen = -1;
goto end;
}
EVP_CIPHER_CTX *cctx = EVP_CIPHER_CTX_new();
if (cctx == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PEM, ERR_R_EVP_LIB);
goto err;
}
goto err;
}
enctmp = OPENSSL_malloc(keylen + 8);
- if (enctmp == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ if (enctmp == NULL)
goto err;
- }
if (!derive_pvk_key(keybuf, sizeof(keybuf), p, saltlen,
(unsigned char *)psbuf, inlen, libctx, propq))
goto err;
return 0;
buflen = (int)keylen + saltlen;
buf = OPENSSL_malloc(buflen);
- if (buf == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ if (buf == NULL)
return 0;
- }
p = buf;
if (BIO_read(in, buf, buflen) != buflen) {
ERR_raise(ERR_LIB_PEM, PEM_R_PVK_DATA_TOO_SHORT);
p = *out;
} else {
start = p = OPENSSL_malloc(outlen);
- if (p == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ if (p == NULL)
return -1;
- }
}
cctx = EVP_CIPHER_CTX_new();
PKCS12_SAFEBAG *safebag;
if ((bag = PKCS12_BAGS_new()) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
return NULL;
}
bag->type = OBJ_nid2obj(nid1);
if (!ASN1_item_pack(obj, it, &bag->value.octet)) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
goto err;
}
if ((safebag = PKCS12_SAFEBAG_new()) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
goto err;
}
safebag->value.bag = bag;
PKCS7 *p7;
if ((p7 = PKCS7_new()) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
return NULL;
}
p7->type = OBJ_nid2obj(NID_pkcs7_data);
if ((p7->d.data = ASN1_OCTET_STRING_new()) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
goto err;
}
EVP_CIPHER *pbe_ciph_fetch = NULL;
if ((p7 = PKCS7_new_ex(ctx, propq)) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
return NULL;
}
if (!PKCS7_set_type(p7, NID_pkcs7_encrypted)) {
}
if (pbe == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
goto err;
}
X509_ALGOR_free(p7->d.encrypted->enc_data->algorithm);
int max_out_len, mac_len = 0;
if (ctx == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_EVP_LIB);
goto err;
}
}
}
- if ((out = OPENSSL_malloc(max_out_len)) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ if ((out = OPENSSL_malloc(max_out_len)) == NULL)
goto err;
- }
if (!EVP_CipherUpdate(ctx, out, &i, in, inlen)) {
OPENSSL_free(out);
int inlen;
if ((oct = ASN1_OCTET_STRING_new()) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
goto err;
}
inlen = ASN1_item_i2d(obj, &in, it);
PKCS12 *pkcs12;
if ((pkcs12 = PKCS12_new()) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
return NULL;
}
if (!ASN1_INTEGER_set(pkcs12->version, 3))
ossl_pkcs7_set0_libctx(pkcs12->authsafes, ctx);
if (!ossl_pkcs7_set1_propq(pkcs12->authsafes, propq)) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_PKCS7_LIB);
goto err;
}
switch (mode) {
case NID_pkcs7_data:
if ((pkcs12->authsafes->d.data = ASN1_OCTET_STRING_new()) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
goto err;
}
break;
unipass = NULL;
uniplen = 0;
} else if (!OPENSSL_asc2uni(pass, passlen, &unipass, &uniplen)) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_PKCS12_LIB);
return 0;
}
ret = PKCS12_key_gen_uni_ex(unipass, uniplen, salt, saltlen, id, iter,
unipass = NULL;
uniplen = 0;
} else if (!OPENSSL_utf82uni(pass, passlen, &unipass, &uniplen)) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_PKCS12_LIB);
return 0;
}
ret = PKCS12_key_gen_uni_ex(unipass, uniplen, salt, saltlen, id, iter,
/* If needed, allocate stack for other certificates */
if ((cert != NULL || ca != NULL)
&& (ocerts = sk_X509_new_null()) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_CRYPTO_LIB);
goto err;
}
return PKCS12_ERROR;
if (iter > 1) {
if ((p12->mac->iter = ASN1_INTEGER_new()) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
return 0;
}
if (!ASN1_INTEGER_set(p12->mac->iter, iter)) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
return 0;
}
}
saltlen = PKCS12_SALT_LEN;
else if (saltlen < 0)
return 0;
- if ((p12->mac->salt->data = OPENSSL_malloc(saltlen)) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ if ((p12->mac->salt->data = OPENSSL_malloc(saltlen)) == NULL)
return 0;
- }
p12->mac->salt->length = saltlen;
if (salt == NULL) {
if (RAND_bytes_ex(p12->authsafes->ctx.libctx, p12->mac->salt->data,
X509_SIG_getm(p12->mac->dinfo, &macalg, NULL);
if (!X509_ALGOR_set0(macalg, OBJ_nid2obj(EVP_MD_get_type(md_type)),
V_ASN1_NULL, NULL)) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
return 0;
}
p8 = OPENSSL_zalloc(sizeof(*p8));
if (p8 == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
ASN1_OCTET_STRING_free(enckey);
return NULL;
}
PKCS12_SAFEBAG *safebag;
if ((bag = PKCS12_BAGS_new()) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
return NULL;
}
bag->type = OBJ_nid2obj(type);
ASN1_OCTET_STRING *strtmp = ASN1_OCTET_STRING_new();
if (strtmp == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
goto err;
}
/* Pack data into an octet string */
bag->value.other = ASN1_TYPE_new();
if (bag->value.other == NULL) {
ASN1_OCTET_STRING_free(strtmp);
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
goto err;
}
ASN1_TYPE_set(bag->value.other, vtype, strtmp);
}
if ((safebag = PKCS12_SAFEBAG_new()) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
goto err;
}
safebag->value.bag = bag;
PKCS12_SAFEBAG *bag = PKCS12_SAFEBAG_new();
if (bag == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
return NULL;
}
bag->type = OBJ_nid2obj(NID_keyBag);
/* Set up the safe bag */
if (bag == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS12, ERR_R_ASN1_LIB);
return NULL;
}
bag->type = OBJ_nid2obj(NID_pkcs8ShroudedKeyBag);
if (asclen < 0)
return NULL;
ulen = asclen * 2 + 2;
- if ((unitmp = OPENSSL_malloc(ulen)) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ if ((unitmp = OPENSSL_malloc(ulen)) == NULL)
return NULL;
- }
for (i = 0; i < ulen - 2; i += 2) {
unitmp[i] = 0;
unitmp[i + 1] = asc[i >> 1];
if (!unilen || uni[unilen - 1])
asclen++;
uni++;
- if ((asctmp = OPENSSL_malloc(asclen)) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ if ((asctmp = OPENSSL_malloc(asclen)) == NULL)
return NULL;
- }
for (i = 0; i < unilen; i += 2)
asctmp[i >> 1] = uni[i];
asctmp[asclen - 1] = 0;
ulen += 2; /* for trailing UTF16 zero */
- if ((ret = OPENSSL_malloc(ulen)) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ if ((ret = OPENSSL_malloc(ulen)) == NULL)
return NULL;
- }
/* re-run the loop writing down UTF-16 characters in big-endian order */
for (unitmp = ret, i = 0; i < asclen; i += j) {
j = UTF8_getc((const unsigned char *)asc+i, asclen-i, &utf32chr);
if (!unilen || (uni[unilen-2]||uni[unilen - 1]))
asclen++;
- if ((asctmp = OPENSSL_malloc(asclen)) == NULL) {
- ERR_raise(ERR_LIB_PKCS12, ERR_R_MALLOC_FAILURE);
+ if ((asctmp = OPENSSL_malloc(asclen)) == NULL)
return NULL;
- }
/* re-run the loop emitting UTF-8 string */
for (asclen = 0, i = 0; i < unilen; ) {
if (pkcs7->ctx.propq == NULL) {
PKCS7_free(pkcs7);
pkcs7 = NULL;
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
}
}
}
ASN1_STRING *seq;
if ((seq = ASN1_STRING_new()) == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_ASN1_LIB);
return 0;
}
seq->length = ASN1_item_i2d((ASN1_VALUE *)cap, &seq->data,
X509_ALGOR *alg;
if ((alg = X509_ALGOR_new()) == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_ASN1_LIB);
return 0;
}
ASN1_OBJECT_free(alg->algorithm);
alg->algorithm = OBJ_nid2obj(nid);
if (arg > 0) {
if ((alg->parameter = ASN1_TYPE_new()) == NULL) {
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_ASN1_LIB);
goto err;
}
if ((nbit = ASN1_INTEGER_new()) == NULL) {
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_ASN1_LIB);
goto err;
}
if (!ASN1_INTEGER_set(nbit, arg)) {
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_ASN1_LIB);
goto err;
}
alg->parameter->value.integer = nbit;
nbit = NULL;
}
if (!sk_X509_ALGOR_push(sk, alg)) {
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_CRYPTO_LIB);
goto err;
}
return 1;
err:
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
ASN1_INTEGER_free(nbit);
X509_ALGOR_free(alg);
return 0;
int PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t)
{
if (t == NULL && (t = X509_gmtime_adj(NULL, 0)) == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_X509_LIB);
return 0;
}
return PKCS7_add_signed_attribute(si, NID_pkcs9_signingTime,
goto err;
ek = OPENSSL_malloc(eklen);
-
- if (ek == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ if (ek == NULL)
goto err;
- }
if (EVP_PKEY_encrypt(pctx, ek, &eklen, key, keylen) <= 0)
goto err;
goto err;
ek = OPENSSL_malloc(eklen);
-
- if (ek == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ if (ek == NULL)
goto err;
- }
if (EVP_PKEY_decrypt(pctx, ek, &eklen,
ri->enc_key->data, ri->enc_key->length) <= 0
/* Add signing time if not already present */
if (!PKCS7_get_signed_attribute(si, NID_pkcs9_signingTime)) {
if (!PKCS7_add0_attrib_signing_time(si, NULL)) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_PKCS7_LIB);
return 0;
}
}
return 0;
}
if (!PKCS7_add1_attrib_digest(si, md_data, md_len)) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_PKCS7_LIB);
return 0;
}
ctx_tmp = EVP_MD_CTX_new();
if (ctx_tmp == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_EVP_LIB);
return 0;
}
if (os == NULL) {
os = ASN1_OCTET_STRING_new();
if (os == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_ASN1_LIB);
goto err;
}
p7->d.signed_and_enveloped->enc_data->enc_data = os;
if (os == NULL) {
os = ASN1_OCTET_STRING_new();
if (os == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_ASN1_LIB);
goto err;
}
p7->d.enveloped->enc_data->enc_data = os;
mctx = EVP_MD_CTX_new();
if (mctx == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_EVP_LIB);
goto err;
}
mdc_tmp = EVP_MD_CTX_new();
if (mdc_tmp == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_EVP_LIB);
goto err;
}
if ((alg = X509_ALGOR_new()) == NULL
|| (alg->parameter = ASN1_TYPE_new()) == NULL) {
X509_ALGOR_free(alg);
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_ASN1_LIB);
return 0;
}
/*
if (*sk == NULL)
*sk = sk_X509_CRL_new_null();
if (*sk == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_CRYPTO_LIB);
return 0;
}
}
if (propq != NULL) {
p7->ctx.propq = OPENSSL_strdup(propq);
- if (p7->ctx.propq == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (p7->ctx.propq == NULL)
return 0;
- }
}
return 1;
}
{
if (PKCS7_type_is_digest(p7)) {
if ((p7->d.digest->md->parameter = ASN1_TYPE_new()) == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_ASN1_LIB);
return 0;
}
p7->d.digest->md->parameter->type = V_ASN1_NULL;
int i;
if ((p7 = PKCS7_new_ex(libctx, propq)) == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_PKCS7_LIB);
return NULL;
}
int ret = 0;
if ((p7bio = PKCS7_dataInit(p7, NULL)) == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_PKCS7_LIB);
return 0;
}
/* Add SMIMECapabilities */
if (!(flags & PKCS7_NOSMIMECAP)) {
if ((smcap = sk_X509_ALGOR_new_null()) == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_CRYPTO_LIB);
goto err;
}
if (!add_cipher_smcap(smcap, NID_aes_256_cbc, -1)
if (flags & PKCS7_TEXT) {
if ((tmpout = BIO_new(BIO_s_mem())) == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_BIO_LIB);
goto err;
}
BIO_set_mem_eof_return(tmpout, 0);
tmpout = out;
/* We now have to 'read' from p7bio to calculate digests etc. */
- if ((buf = OPENSSL_malloc(BUFFERSIZE)) == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ if ((buf = OPENSSL_malloc(BUFFERSIZE)) == NULL)
goto err;
- }
for (;;) {
i = BIO_read(p7bio, buf, BUFFERSIZE);
if (i <= 0)
}
if ((signers = sk_X509_new_null()) == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_CRYPTO_LIB);
return NULL;
}
X509 *x509;
if ((p7 = PKCS7_new_ex(libctx, propq)) == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_PKCS7_LIB);
return NULL;
}
BIO *tmpbuf, *bread;
/* Encrypt BIOs can't do BIO_gets() so add a buffer BIO */
if ((tmpbuf = BIO_new(BIO_f_buffer())) == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_BIO_LIB);
BIO_free_all(tmpmem);
return 0;
}
if ((bread = BIO_push(tmpbuf, tmpmem)) == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PKCS7, ERR_R_BIO_LIB);
BIO_free_all(tmpbuf);
BIO_free_all(tmpmem);
return 0;
BIO_free_all(bread);
return ret;
}
- if ((buf = OPENSSL_malloc(BUFFERSIZE)) == NULL) {
- ERR_raise(ERR_LIB_PKCS7, ERR_R_MALLOC_FAILURE);
+ if ((buf = OPENSSL_malloc(BUFFERSIZE)) == NULL)
goto err;
- }
for (;;) {
i = BIO_read(tmpmem, buf, BUFFERSIZE);
if (i <= 0) {
}
memset(&entry, 0, sizeof(entry));
entry.name = OPENSSL_strdup(name);
- if (entry.name == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (entry.name == NULL)
return 0;
- }
entry.init = init_fn;
if (!ossl_provider_info_add_to_store(libctx, &entry)) {
ossl_provider_info_clear(&entry);
ok = 1;
if (name != NULL) {
entry.name = OPENSSL_strdup(name);
- if (entry.name == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (entry.name == NULL)
ok = 0;
- }
}
if (ok && path != NULL) {
entry.path = OPENSSL_strdup(path);
- if (entry.path == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (entry.path == NULL)
ok = 0;
- }
}
if (ok)
ok = provider_conf_params(NULL, &entry, NULL, value, cnf);
if (store->provinfosz == 0) {
store->provinfo = OPENSSL_zalloc(sizeof(*store->provinfo)
* BUILTINS_BLOCK_SIZE);
- if (store->provinfo == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (store->provinfo == NULL)
goto err;
- }
store->provinfosz = BUILTINS_BLOCK_SIZE;
} else if (store->numprovinfo == store->provinfosz) {
OSSL_PROVIDER_INFO *tmpbuiltins;
tmpbuiltins = OPENSSL_realloc(store->provinfo,
sizeof(*store->provinfo) * newsz);
- if (tmpbuiltins == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (tmpbuiltins == NULL)
goto err;
- }
store->provinfo = tmpbuiltins;
store->provinfosz = newsz;
}
{
OSSL_PROVIDER *prov = NULL;
- if ((prov = OPENSSL_zalloc(sizeof(*prov))) == NULL
+ if ((prov = OPENSSL_zalloc(sizeof(*prov))) == NULL)
+ return NULL;
#ifndef HAVE_ATOMICS
- || (prov->refcnt_lock = CRYPTO_THREAD_lock_new()) == NULL
-#endif
- ) {
+ if ((prov->refcnt_lock = CRYPTO_THREAD_lock_new()) == NULL) {
OPENSSL_free(prov);
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CRYPTO, ERR_R_CRYPTO_LIB);
return NULL;
}
+#endif
prov->refcnt = 1; /* 1 One reference to be returned */
if ((prov->opbits_lock = CRYPTO_THREAD_lock_new()) == NULL
|| (prov->flag_lock = CRYPTO_THREAD_lock_new()) == NULL
- || (prov->name = OPENSSL_strdup(name)) == NULL
|| (prov->parameters = sk_INFOPAIR_deep_copy(parameters,
infopair_copy,
infopair_free)) == NULL) {
ossl_provider_free(prov);
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CRYPTO, ERR_R_CRYPTO_LIB);
+ return NULL;
+ }
+ if ((prov->name = OPENSSL_strdup(name)) == NULL) {
+ ossl_provider_free(prov);
return NULL;
}
if (actualprov != NULL) {
if (!ossl_provider_up_ref(actualtmp)) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_CRYPTO, ERR_R_CRYPTO_LIB);
actualtmp = NULL;
return 0;
}
return 1;
if ((prov->path = OPENSSL_strdup(module_path)) != NULL)
return 1;
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
return 0;
}
{
INFOPAIR *pair = NULL;
- if ((pair = OPENSSL_zalloc(sizeof(*pair))) != NULL
- && (*infopairsk != NULL
- || (*infopairsk = sk_INFOPAIR_new_null()) != NULL)
- && (pair->name = OPENSSL_strdup(name)) != NULL
- && (pair->value = OPENSSL_strdup(value)) != NULL
- && sk_INFOPAIR_push(*infopairsk, pair) > 0)
- return 1;
+ if ((pair = OPENSSL_zalloc(sizeof(*pair))) == NULL
+ || (pair->name = OPENSSL_strdup(name)) == NULL
+ || (pair->value = OPENSSL_strdup(value)) == NULL)
+ goto err;
+
+ if ((*infopairsk == NULL
+ && (*infopairsk = sk_INFOPAIR_new_null()) == NULL)
+ || sk_INFOPAIR_push(*infopairsk, pair) <= 0) {
+ ERR_raise(ERR_LIB_CRYPTO, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
+
+ return 1;
+ err:
if (pair != NULL) {
OPENSSL_free(pair->name);
OPENSSL_free(pair->value);
OPENSSL_free(pair);
}
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
return 0;
}
if (path != NULL) {
p = OPENSSL_strdup(path);
- if (p == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (p == NULL)
return 0;
- }
}
if ((store = get_provider_store(libctx)) != NULL
&& CRYPTO_THREAD_write_lock(store->default_path_lock)) {
if (store->default_path != NULL) {
allocated_load_dir = OPENSSL_strdup(store->default_path);
CRYPTO_THREAD_unlock(store->default_path_lock);
- if (allocated_load_dir == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (allocated_load_dir == NULL)
goto end;
- }
load_dir = allocated_load_dir;
} else {
CRYPTO_THREAD_unlock(store->default_path_lock);
if (tmp == NULL) {
CRYPTO_THREAD_unlock(provider->opbits_lock);
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
return 0;
}
provider->operation_bits = tmp;
pool = ossl_rand_pool_new(entropy, 1, min_len, max_len);
if (pool == NULL) {
- ERR_raise(ERR_LIB_RAND, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_RAND, ERR_R_RAND_LIB);
return 0;
}
pool = ossl_rand_pool_new(0, 0, min_len, max_len);
if (pool == NULL) {
- ERR_raise(ERR_LIB_RAND, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_RAND, ERR_R_RAND_LIB);
return 0;
}
if (s != NULL) {
d = OPENSSL_strdup(s);
- if (d == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (d == NULL)
return 0;
- }
}
OPENSSL_free(*p);
*p = d;
RAND_POOL *pool = OPENSSL_zalloc(sizeof(*pool));
size_t min_alloc_size = RAND_POOL_MIN_ALLOCATION(secure);
- if (pool == NULL) {
- ERR_raise(ERR_LIB_RAND, ERR_R_MALLOC_FAILURE);
+ if (pool == NULL)
return NULL;
- }
pool->min_len = min_len;
pool->max_len = (max_len > RAND_POOL_MAX_LENGTH) ?
else
pool->buffer = OPENSSL_zalloc(pool->alloc_len);
- if (pool->buffer == NULL) {
- ERR_raise(ERR_LIB_RAND, ERR_R_MALLOC_FAILURE);
+ if (pool->buffer == NULL)
goto err;
- }
pool->entropy_requested = entropy_requested;
pool->secure = secure;
{
RAND_POOL *pool = OPENSSL_zalloc(sizeof(*pool));
- if (pool == NULL) {
- ERR_raise(ERR_LIB_RAND, ERR_R_MALLOC_FAILURE);
+ if (pool == NULL)
return NULL;
- }
/*
* The const needs to be cast away, but attached buffers will not be
p = OPENSSL_secure_zalloc(newlen);
else
p = OPENSSL_zalloc(newlen);
- if (p == NULL) {
- ERR_raise(ERR_LIB_RAND, ERR_R_MALLOC_FAILURE);
+ if (p == NULL)
return 0;
- }
memcpy(p, pool->buffer, pool->len);
if (pool->secure)
OPENSSL_secure_clear_free(pool->buffer, pool->alloc_len);
rklen = i2d_RSAPrivateKey(pkey->pkey.rsa, &rk);
if (rklen <= 0) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_RSA, ERR_R_ASN1_LIB);
ASN1_STRING_free(str);
return 0;
}
if (!PKCS8_pkey_set0(p8, OBJ_nid2obj(pkey->ameth->pkey_id), 0,
strtype, str, rk, rklen)) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_RSA, ERR_R_ASN1_LIB);
ASN1_STRING_free(str);
OPENSSL_clear_free(rk, rklen);
return 0;
int ok = 0;
if (rsa == NULL) {
- ERR_raise(ERR_LIB_DH, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_DH, ERR_R_RSA_LIB);
return 0;
}
const RSA_PRIME_INFO *pinfo = NULL;
RSA_PRIME_INFO *duppinfo = NULL;
- if ((duppinfo = OPENSSL_zalloc(sizeof(*duppinfo))) == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if ((duppinfo = OPENSSL_zalloc(sizeof(*duppinfo))) == NULL)
goto err;
- }
/* push first so cleanup in error case works */
(void)sk_RSA_PRIME_INFO_push(dupkey->prime_infos, duppinfo);
if (i == NULL || j == NULL || k == NULL || l == NULL
|| m == NULL || ctx == NULL) {
ret = -1;
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_RSA, ERR_R_BN_LIB);
goto err;
}
BN_CTX_start(ctx);
e = BN_CTX_get(ctx);
if (e == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_RSA, ERR_R_BN_LIB);
goto err;
}
BIGNUM *n = BN_new();
if (n == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_RSA, ERR_R_BN_LIB);
goto err;
}
BN_with_flags(n, rsa->n, BN_FLG_CONSTTIME);
{
RSA *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->references = 1;
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_RSA, ERR_R_CRYPTO_LIB);
OPENSSL_free(ret);
return NULL;
}
goto err;
/* Using ossl_rsa_multip_info_new() is wasteful, so allocate directly */
- if ((pinfo = OPENSSL_zalloc(sizeof(*pinfo))) == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if ((pinfo = OPENSSL_zalloc(sizeof(*pinfo))) == NULL)
goto err;
- }
pinfo->r = prime;
pinfo->d = exp;
OPENSSL_free(meth);
}
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
return NULL;
}
OPENSSL_free(ret);
}
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
return NULL;
}
{
char *tmpname = OPENSSL_strdup(name);
- if (tmpname == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (tmpname == NULL)
return 0;
- }
OPENSSL_free(meth->name);
meth->name = tmpname;
RSA_PRIME_INFO *pinfo;
/* create a RSA_PRIME_INFO structure */
- if ((pinfo = OPENSSL_zalloc(sizeof(RSA_PRIME_INFO))) == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if ((pinfo = OPENSSL_zalloc(sizeof(RSA_PRIME_INFO))) == NULL)
return NULL;
- }
if ((pinfo->r = BN_secure_new()) == NULL)
goto err;
if ((pinfo->d = BN_secure_new()) == NULL)
dbmask_len = emlen - mdlen;
dbmask = OPENSSL_malloc(dbmask_len);
- if (dbmask == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (dbmask == NULL)
goto err;
- }
/* step 3e: dbMask = MGF(mgfSeed, nLen - HLen - 1) */
if (PKCS1_MGF1(dbmask, dbmask_len, seed, mdlen, mgf1md) < 0)
dblen = num - mdlen - 1;
db = OPENSSL_malloc(dblen);
- if (db == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (db == NULL)
goto cleanup;
- }
em = OPENSSL_malloc(num);
- if (em == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (em == NULL)
goto cleanup;
- }
/*
* Caller is encouraged to pass zero-padded message created with
ret = BN_CTX_get(ctx);
num = BN_num_bytes(rsa->n);
buf = OPENSSL_malloc(num);
- if (ret == NULL || buf == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL || buf == NULL)
goto err;
- }
switch (padding) {
case RSA_PKCS1_PADDING:
ret = BN_CTX_get(ctx);
num = BN_num_bytes(rsa->n);
buf = OPENSSL_malloc(num);
- if (ret == NULL || buf == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL || buf == NULL)
goto err;
- }
switch (padding) {
case RSA_PKCS1_PADDING:
if (blinding != NULL) {
if (!local_blinding && ((unblind = BN_CTX_get(ctx)) == NULL)) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_RSA, ERR_R_BN_LIB);
goto err;
}
if (!rsa_blinding_convert(blinding, f, unblind, ctx))
} else {
BIGNUM *d = BN_new();
if (d == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_RSA, ERR_R_BN_LIB);
goto err;
}
if (rsa->d == NULL) {
BN_CTX_start(ctx);
f = BN_CTX_get(ctx);
ret = BN_CTX_get(ctx);
+ if (ret == NULL) {
+ ERR_raise(ERR_LIB_RSA, ERR_R_BN_LIB);
+ goto err;
+ }
num = BN_num_bytes(rsa->n);
buf = OPENSSL_malloc(num);
- if (ret == NULL || buf == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (buf == NULL)
goto err;
- }
/*
* This check was for equality but PGP does evil things and chops off the
if (blinding != NULL) {
if (!local_blinding && ((unblind = BN_CTX_get(ctx)) == NULL)) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_RSA, ERR_R_BN_LIB);
goto err;
}
if (!rsa_blinding_convert(blinding, f, unblind, ctx))
} else {
BIGNUM *d = BN_new();
if (d == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_RSA, ERR_R_BN_LIB);
goto err;
}
if (rsa->d == NULL) {
BN_CTX_start(ctx);
f = BN_CTX_get(ctx);
ret = BN_CTX_get(ctx);
+ if (ret == NULL) {
+ ERR_raise(ERR_LIB_RSA, ERR_R_BN_LIB);
+ goto err;
+ }
num = BN_num_bytes(rsa->n);
buf = OPENSSL_malloc(num);
- if (ret == NULL || buf == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (buf == NULL)
goto err;
- }
/*
* This check was for equality but PGP does evil things and chops off the
}
em = OPENSSL_malloc(num);
- if (em == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (em == NULL)
return -1;
- }
/*
* Caller is encouraged to pass zero-padded message created with
* BN_bn2binpad. Trouble is that since we can't read out of |from|'s
if (ctx->tbuf != NULL)
return 1;
if ((ctx->tbuf =
- OPENSSL_malloc(RSA_size(EVP_PKEY_get0_RSA(pk->pkey)))) == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ OPENSSL_malloc(RSA_size(EVP_PKEY_get0_RSA(pk->pkey)))) == NULL)
return 0;
- }
return 1;
}
return -1;
}
if (!setup_tbuf(rctx, ctx)) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_RSA, ERR_R_RSA_LIB);
return -1;
}
memcpy(rctx->tbuf, tbs, tbslen);
maskedDBLen = emLen - hLen - 1;
H = EM + maskedDBLen;
DB = OPENSSL_malloc(maskedDBLen);
- if (DB == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (DB == NULL)
goto err;
- }
if (PKCS1_MGF1(DB, maskedDBLen, H, hLen, mgf1Hash) < 0)
goto err;
for (i = 0; i < maskedDBLen; i++)
}
if (sLen > 0) {
salt = OPENSSL_malloc(sLen);
- if (salt == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (salt == NULL)
goto err;
- }
if (RAND_bytes_ex(rsa->libctx, salt, sLen, 0) <= 0)
goto err;
}
return 0;
}
s = OPENSSL_malloc((unsigned int)j + 1);
- if (s == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (s == NULL)
return 0;
- }
p = s;
i2d_ASN1_OCTET_STRING(&sig, &p);
i = RSA_private_encrypt(i, s, sigret, rsa, RSA_PKCS1_PADDING);
}
s = OPENSSL_malloc((unsigned int)siglen);
- if (s == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (s == NULL)
goto err;
- }
i = RSA_public_decrypt((int)siglen, sigbuf, s, rsa, RSA_PKCS1_PADDING);
if (i <= 0)
}
dig_info_len = di_prefix_len + m_len;
dig_info = OPENSSL_malloc(dig_info_len);
- if (dig_info == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (dig_info == NULL)
return 0;
- }
memcpy(dig_info, di_prefix, di_prefix_len);
memcpy(dig_info + di_prefix_len, m, m_len);
/* Recover the encoded digest. */
decrypt_buf = OPENSSL_malloc(siglen);
- if (decrypt_buf == NULL) {
- ERR_raise(ERR_LIB_RSA, ERR_R_MALLOC_FAILURE);
+ if (decrypt_buf == NULL)
goto err;
- }
len = RSA_public_decrypt((int)siglen, sigbuf, decrypt_buf, rsa,
RSA_PKCS1_PADDING);
kG = EC_POINT_new(group);
kP = EC_POINT_new(group);
+ if (kG == NULL || kP == NULL) {
+ ERR_raise(ERR_LIB_SM2, ERR_R_EC_LIB);
+ goto done;
+ }
ctx = BN_CTX_new_ex(libctx);
- if (kG == NULL || kP == NULL || ctx == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL) {
+ ERR_raise(ERR_LIB_SM2, ERR_R_BN_LIB);
goto done;
}
x2y2 = OPENSSL_zalloc(2 * field_size);
C3 = OPENSSL_zalloc(C3_size);
- if (x2y2 == NULL || C3 == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ if (x2y2 == NULL || C3 == NULL)
goto done;
- }
memset(ciphertext_buf, 0, *ciphertext_len);
}
msg_mask = OPENSSL_zalloc(msg_len);
- if (msg_mask == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ if (msg_mask == NULL)
goto done;
- }
/* X9.63 with no salt happens to match the KDF used in SM2 */
if (!ossl_ecdh_kdf_X9_63(msg_mask, msg_len, x2y2, 2 * field_size, NULL, 0,
ctext_struct.C2 = ASN1_OCTET_STRING_new();
if (ctext_struct.C3 == NULL || ctext_struct.C2 == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SM2, ERR_R_ASN1_LIB);
goto done;
}
if (!ASN1_OCTET_STRING_set(ctext_struct.C3, C3, C3_size)
ctx = BN_CTX_new_ex(libctx);
if (ctx == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SM2, ERR_R_BN_LIB);
goto done;
}
x2y2 = OPENSSL_zalloc(2 * field_size);
computed_C3 = OPENSSL_zalloc(hash_size);
- if (msg_mask == NULL || x2y2 == NULL || computed_C3 == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ if (msg_mask == NULL || x2y2 == NULL || computed_C3 == NULL)
goto done;
- }
C1 = EC_POINT_new(group);
if (C1 == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SM2, ERR_R_EC_LIB);
goto done;
}
hash = EVP_MD_CTX_new();
if (hash == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SM2, ERR_R_EVP_LIB);
goto done;
}
uint8_t e_byte = 0;
hash = EVP_MD_CTX_new();
+ if (hash == NULL) {
+ ERR_raise(ERR_LIB_SM2, ERR_R_EVP_LIB);
+ goto done;
+ }
ctx = BN_CTX_new_ex(ossl_ec_key_get_libctx(key));
- if (hash == NULL || ctx == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL) {
+ ERR_raise(ERR_LIB_SM2, ERR_R_BN_LIB);
goto done;
}
yA = BN_CTX_get(ctx);
if (yA == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SM2, ERR_R_BN_LIB);
goto done;
}
p_bytes = BN_num_bytes(p);
buf = OPENSSL_zalloc(p_bytes);
- if (buf == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ if (buf == NULL)
goto done;
- }
if (BN_bn2binpad(a, buf, p_bytes) < 0
|| !EVP_DigestUpdate(hash, buf, p_bytes)
ERR_raise(ERR_LIB_SM2, SM2_R_INVALID_DIGEST);
goto done;
}
+ if (hash == NULL) {
+ ERR_raise(ERR_LIB_SM2, ERR_R_EVP_LIB);
+ goto done;
+ }
z = OPENSSL_zalloc(md_size);
- if (hash == NULL || z == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ if (z == NULL)
goto done;
- }
fetched_digest = EVP_MD_fetch(libctx, EVP_MD_get0_name(digest), propq);
if (fetched_digest == NULL) {
OSSL_LIB_CTX *libctx = ossl_ec_key_get_libctx(key);
kG = EC_POINT_new(group);
+ if (kG == NULL) {
+ ERR_raise(ERR_LIB_SM2, ERR_R_EC_LIB);
+ goto done;
+ }
ctx = BN_CTX_new_ex(libctx);
- if (kG == NULL || ctx == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL) {
+ ERR_raise(ERR_LIB_SM2, ERR_R_BN_LIB);
goto done;
}
x1 = BN_CTX_get(ctx);
tmp = BN_CTX_get(ctx);
if (tmp == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SM2, ERR_R_BN_LIB);
goto done;
}
s = BN_new();
if (r == NULL || s == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SM2, ERR_R_BN_LIB);
goto done;
}
sig = ECDSA_SIG_new();
if (sig == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SM2, ERR_R_ECDSA_LIB);
goto done;
}
ctx = BN_CTX_new_ex(libctx);
pt = EC_POINT_new(group);
if (ctx == NULL || pt == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SM2, ERR_R_EC_LIB);
goto done;
}
t = BN_CTX_get(ctx);
x1 = BN_CTX_get(ctx);
if (x1 == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SM2, ERR_R_BN_LIB);
goto done;
}
s = ECDSA_SIG_new();
if (s == NULL) {
- ERR_raise(ERR_LIB_SM2, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SM2, ERR_R_ECDSA_LIB);
goto done;
}
if (d2i_ECDSA_SIG(&s, &p, sig_len) == NULL) {
{
SRP_user_pwd *ret;
- if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL) {
- /* ERR_raise(ERR_LIB_SRP, ERR_R_MALLOC_FAILURE); */ /*ckerr_ignore*/
+ if ((ret = OPENSSL_malloc(sizeof(*ret))) == NULL)
return NULL;
- }
ret->N = NULL;
ret->g = NULL;
ret->s = NULL;
return ret;
err:
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
OPENSSL_sk_free(ret);
return NULL;
}
return ret;
err:
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
OPENSSL_sk_free(ret);
return NULL;
}
* At this point, |st->num_alloc| and |st->num| are 0;
* so |num_alloc| value is |n| or |min_nodes| if greater than |n|.
*/
- if ((st->data = OPENSSL_zalloc(sizeof(void *) * num_alloc)) == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if ((st->data = OPENSSL_zalloc(sizeof(void *) * num_alloc)) == NULL)
return 0;
- }
st->num_alloc = num_alloc;
return 1;
}
}
tmpdata = OPENSSL_realloc((void *)st->data, sizeof(void *) * num_alloc);
- if (tmpdata == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (tmpdata == NULL)
return 0;
- }
st->data = tmpdata;
st->num_alloc = num_alloc;
{
OPENSSL_STACK *st = OPENSSL_zalloc(sizeof(OPENSSL_STACK));
- if (st == NULL) {
- ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
+ if (st == NULL)
return NULL;
- }
st->comp = c;
OSSL_TRACE2(STORE, "Opened %s => %p\n", uri, (void *)loader_ctx);
if ((propq != NULL && (propq_copy = OPENSSL_strdup(propq)) == NULL)
- || (ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ || (ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
goto err;
- }
if (ui_method != NULL
&& (!ossl_pw_set_ui_method(&ctx->pwdata, ui_method, ui_data)
}
if ((bld = OSSL_PARAM_BLD_new()) == NULL) {
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_CRYPTO_LIB);
return 0;
}
OSSL_STORE_INFO *info = OSSL_STORE_INFO_new(OSSL_STORE_INFO_NAME, NULL);
if (info == NULL) {
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_OSSL_STORE_LIB);
return NULL;
}
OSSL_STORE_INFO *info = OSSL_STORE_INFO_new(OSSL_STORE_INFO_PARAMS, params);
if (info == NULL)
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_OSSL_STORE_LIB);
return info;
}
OSSL_STORE_INFO *info = OSSL_STORE_INFO_new(OSSL_STORE_INFO_PUBKEY, pkey);
if (info == NULL)
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_OSSL_STORE_LIB);
return info;
}
OSSL_STORE_INFO *info = OSSL_STORE_INFO_new(OSSL_STORE_INFO_PKEY, pkey);
if (info == NULL)
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_OSSL_STORE_LIB);
return info;
}
OSSL_STORE_INFO *info = OSSL_STORE_INFO_new(OSSL_STORE_INFO_CERT, x509);
if (info == NULL)
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_OSSL_STORE_LIB);
return info;
}
OSSL_STORE_INFO *info = OSSL_STORE_INFO_new(OSSL_STORE_INFO_CRL, crl);
if (info == NULL)
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_OSSL_STORE_LIB);
return info;
}
char *OSSL_STORE_INFO_get1_NAME(const OSSL_STORE_INFO *info)
{
- if (info->type == OSSL_STORE_INFO_NAME) {
- char *ret = OPENSSL_strdup(info->_.name.name);
-
- if (ret == NULL)
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
- return ret;
- }
+ if (info->type == OSSL_STORE_INFO_NAME)
+ return OPENSSL_strdup(info->_.name.name);
ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_NOT_A_NAME);
return NULL;
}
char *OSSL_STORE_INFO_get1_NAME_description(const OSSL_STORE_INFO *info)
{
- if (info->type == OSSL_STORE_INFO_NAME) {
- char *ret = OPENSSL_strdup(info->_.name.desc
- ? info->_.name.desc : "");
-
- if (ret == NULL)
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
- return ret;
- }
+ if (info->type == OSSL_STORE_INFO_NAME)
+ return OPENSSL_strdup(info->_.name.desc ? info->_.name.desc : "");
ERR_raise(ERR_LIB_OSSL_STORE, OSSL_STORE_R_NOT_A_NAME);
return NULL;
}
{
OSSL_STORE_SEARCH *search = OPENSSL_zalloc(sizeof(*search));
- if (search == NULL) {
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ if (search == NULL)
return NULL;
- }
search->search_type = OSSL_STORE_SEARCH_BY_NAME;
search->name = name;
{
OSSL_STORE_SEARCH *search = OPENSSL_zalloc(sizeof(*search));
- if (search == NULL) {
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ if (search == NULL)
return NULL;
- }
search->search_type = OSSL_STORE_SEARCH_BY_ISSUER_SERIAL;
search->name = name;
{
OSSL_STORE_SEARCH *search = OPENSSL_zalloc(sizeof(*search));
- if (search == NULL) {
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ if (search == NULL)
return NULL;
- }
if (digest != NULL && len != (size_t)EVP_MD_get_size(digest)) {
ERR_raise_data(ERR_LIB_OSSL_STORE,
{
OSSL_STORE_SEARCH *search = OPENSSL_zalloc(sizeof(*search));
- if (search == NULL) {
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ if (search == NULL)
return NULL;
- }
search->search_type = OSSL_STORE_SEARCH_BY_ALIAS;
search->string = (const unsigned char *)alias;
if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
ERR_clear_last_mark();
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
return NULL;
}
return NULL;
}
- if ((res = OPENSSL_zalloc(sizeof(*res))) == NULL) {
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ if ((res = OPENSSL_zalloc(sizeof(*res))) == NULL)
return NULL;
- }
res->engine = e;
res->scheme = scheme;
}
if (!RUN_ONCE(®istry_init, do_registry_init)) {
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ /* Should this error be raised in do_registry_init()? */
+ ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_CRYPTO_LIB);
return 0;
}
if (!CRYPTO_THREAD_write_lock(registry_lock))
template.open_ex = NULL;
if (!RUN_ONCE(®istry_init, do_registry_init)) {
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ /* Should this error be raised in do_registry_init()? */
+ ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_CRYPTO_LIB);
return NULL;
}
if (!CRYPTO_THREAD_write_lock(registry_lock))
template.closefn = NULL;
if (!RUN_ONCE(®istry_init, do_registry_init)) {
- ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_MALLOC_FAILURE);
+ /* Should this error be raised in do_registry_init()? */
+ ERR_raise(ERR_LIB_OSSL_STORE, ERR_R_CRYPTO_LIB);
return NULL;
}
if (!CRYPTO_THREAD_write_lock(registry_lock))
return 1;
new_msg_imprint = TS_MSG_IMPRINT_dup(msg_imprint);
if (new_msg_imprint == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_TS_LIB);
return 0;
}
TS_MSG_IMPRINT_free(a->msg_imprint);
return 1;
new_alg = X509_ALGOR_dup(alg);
if (new_alg == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
return 0;
}
X509_ALGOR_free(a->hash_algo);
return 1;
new_policy = OBJ_dup(policy);
if (new_policy == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_OBJ_LIB);
return 0;
}
ASN1_OBJECT_free(a->policy_id);
return 1;
new_nonce = ASN1_INTEGER_dup(nonce);
if (new_nonce == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
return 0;
}
ASN1_INTEGER_free(a->nonce);
return serial;
err:
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
TS_RESP_CTX_set_status_info(ctx, TS_STATUS_REJECTION,
"Error during serial number generation.");
ASN1_INTEGER_free(serial);
{
TS_RESP_CTX *ctx;
- if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
return NULL;
- }
if (propq != NULL) {
ctx->propq = OPENSSL_strdup(propq);
if (ctx->propq == NULL) {
OPENSSL_free(ctx);
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
return NULL;
}
}
goto err;
return 1;
err:
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_OBJ_LIB);
return 0;
}
ASN1_OBJECT *copy = NULL;
if (ctx->policies == NULL
- && (ctx->policies = sk_ASN1_OBJECT_new_null()) == NULL)
+ && (ctx->policies = sk_ASN1_OBJECT_new_null()) == NULL) {
+ ERR_raise(ERR_LIB_TS, ERR_R_CRYPTO_LIB);
goto err;
- if ((copy = OBJ_dup(policy)) == NULL)
+ }
+ if ((copy = OBJ_dup(policy)) == NULL) {
+ ERR_raise(ERR_LIB_TS, ERR_R_OBJ_LIB);
goto err;
- if (!sk_ASN1_OBJECT_push(ctx->policies, copy))
+ }
+ if (!sk_ASN1_OBJECT_push(ctx->policies, copy)) {
+ ERR_raise(ERR_LIB_TS, ERR_R_CRYPTO_LIB);
goto err;
+ }
return 1;
err:
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
ASN1_OBJECT_free(copy);
return 0;
}
return 1;
err:
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_CRYPTO_LIB);
return 0;
}
return 1;
err:
TS_RESP_CTX_accuracy_free(ctx);
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
return 0;
}
ASN1_UTF8STRING *utf8_text = NULL;
int ret = 0;
- if ((si = TS_STATUS_INFO_new()) == NULL)
+ if ((si = TS_STATUS_INFO_new()) == NULL) {
+ ERR_raise(ERR_LIB_TS, ERR_R_TS_LIB);
goto err;
- if (!ASN1_INTEGER_set(si->status, status))
+ }
+ if (!ASN1_INTEGER_set(si->status, status)) {
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
goto err;
+ }
if (text) {
if ((utf8_text = ASN1_UTF8STRING_new()) == NULL
- || !ASN1_STRING_set(utf8_text, text, strlen(text)))
+ || !ASN1_STRING_set(utf8_text, text, strlen(text))) {
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
goto err;
+ }
if (si->text == NULL
- && (si->text = sk_ASN1_UTF8STRING_new_null()) == NULL)
+ && (si->text = sk_ASN1_UTF8STRING_new_null()) == NULL) {
+ ERR_raise(ERR_LIB_TS, ERR_R_CRYPTO_LIB);
goto err;
- if (!sk_ASN1_UTF8STRING_push(si->text, utf8_text))
+ }
+ if (!sk_ASN1_UTF8STRING_push(si->text, utf8_text)) {
+ ERR_raise(ERR_LIB_TS, ERR_R_CRYPTO_LIB);
goto err;
+ }
utf8_text = NULL; /* Ownership is lost. */
}
- if (!TS_RESP_set_status_info(ctx->response, si))
+ if (!TS_RESP_set_status_info(ctx->response, si)) {
+ ERR_raise(ERR_LIB_TS, ERR_R_TS_LIB);
goto err;
+ }
ret = 1;
err:
- if (!ret)
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
TS_STATUS_INFO_free(si);
ASN1_UTF8STRING_free(utf8_text);
return ret;
goto err;
return 1;
err:
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
return 0;
}
ts_RESP_CTX_init(ctx);
if ((ctx->response = TS_RESP_new()) == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_TS_LIB);
goto end;
}
if ((ctx->request = d2i_TS_REQ_bio(req_bio, NULL)) == NULL) {
}
if ((p7 = PKCS7_new_ex(ctx->libctx, ctx->propq)) == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
goto err;
}
if (!PKCS7_set_type(p7, NID_pkcs7_signed))
if (!ts_TST_INFO_content_new(p7))
goto err;
if ((p7bio = PKCS7_dataInit(p7, NULL)) == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_PKCS7_LIB);
goto err;
}
if (!i2d_TS_TST_INFO_bio(p7bio, ctx->tst_info)) {
return 1;
new_status_info = TS_STATUS_INFO_dup(status_info);
if (new_status_info == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_TS_LIB);
return 0;
}
TS_STATUS_INFO_free(a->status_info);
return 1;
new_policy = OBJ_dup(policy);
if (new_policy == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_OBJ_LIB);
return 0;
}
ASN1_OBJECT_free(a->policy_id);
return 1;
new_msg_imprint = TS_MSG_IMPRINT_dup(msg_imprint);
if (new_msg_imprint == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_TS_LIB);
return 0;
}
TS_MSG_IMPRINT_free(a->msg_imprint);
return 1;
new_serial = ASN1_INTEGER_dup(serial);
if (new_serial == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
return 0;
}
ASN1_INTEGER_free(a->serial);
return 1;
new_time = ASN1_STRING_dup(gtime);
if (new_time == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
return 0;
}
ASN1_GENERALIZEDTIME_free(a->time);
return 1;
new_accuracy = TS_ACCURACY_dup(accuracy);
if (new_accuracy == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_TS_LIB);
return 0;
}
TS_ACCURACY_free(a->accuracy);
return 1;
new_seconds = ASN1_INTEGER_dup(seconds);
if (new_seconds == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
return 0;
}
ASN1_INTEGER_free(a->seconds);
if (millis != NULL) {
new_millis = ASN1_INTEGER_dup(millis);
if (new_millis == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
return 0;
}
}
if (micros != NULL) {
new_micros = ASN1_INTEGER_dup(micros);
if (new_micros == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
return 0;
}
}
return 1;
new_nonce = ASN1_INTEGER_dup(nonce);
if (new_nonce == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
return 0;
}
ASN1_INTEGER_free(a->nonce);
return 1;
new_tsa = GENERAL_NAME_dup(tsa);
if (new_tsa == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_ASN1_LIB);
return 0;
}
GENERAL_NAME_free(a->tsa);
*chain = NULL;
cert_ctx = X509_STORE_CTX_new();
if (cert_ctx == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_X509_LIB);
goto err;
}
if (!X509_STORE_CTX_init(cert_ctx, store, signer, untrusted))
if (length < 0)
goto err;
*imprint_len = length;
- if ((*imprint = OPENSSL_malloc(*imprint_len)) == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ if ((*imprint = OPENSSL_malloc(*imprint_len)) == NULL)
goto err;
- }
md_ctx = EVP_MD_CTX_new();
if (md_ctx == NULL) {
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_TS, ERR_R_EVP_LIB);
goto err;
}
if (!EVP_DigestInit(md_ctx, md))
{
TS_VERIFY_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
- if (ctx == NULL)
- ERR_raise(ERR_LIB_TS, ERR_R_MALLOC_FAILURE);
return ctx;
}
{
UI *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_UI, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_UI, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_UI, ERR_R_CRYPTO_LIB);
OPENSSL_free(ret);
return NULL;
}
if (prompt != NULL) {
prompt_copy = OPENSSL_strdup(prompt);
- if (prompt_copy == NULL) {
- ERR_raise(ERR_LIB_UI, ERR_R_MALLOC_FAILURE);
+ if (prompt_copy == NULL)
return 0;
- }
}
return general_allocate_string(ui, prompt_copy, 1,
if (prompt != NULL) {
prompt_copy = OPENSSL_strdup(prompt);
- if (prompt_copy == NULL) {
- ERR_raise(ERR_LIB_UI, ERR_R_MALLOC_FAILURE);
+ if (prompt_copy == NULL)
return -1;
- }
}
return general_allocate_string(ui, prompt_copy, 1,
if (prompt != NULL) {
prompt_copy = OPENSSL_strdup(prompt);
- if (prompt_copy == NULL) {
- ERR_raise(ERR_LIB_UI, ERR_R_MALLOC_FAILURE);
+ if (prompt_copy == NULL)
goto err;
- }
}
if (action_desc != NULL) {
action_desc_copy = OPENSSL_strdup(action_desc);
- if (action_desc_copy == NULL) {
- ERR_raise(ERR_LIB_UI, ERR_R_MALLOC_FAILURE);
+ if (action_desc_copy == NULL)
goto err;
- }
}
if (ok_chars != NULL) {
ok_chars_copy = OPENSSL_strdup(ok_chars);
- if (ok_chars_copy == NULL) {
- ERR_raise(ERR_LIB_UI, ERR_R_MALLOC_FAILURE);
+ if (ok_chars_copy == NULL)
goto err;
- }
}
if (cancel_chars != NULL) {
cancel_chars_copy = OPENSSL_strdup(cancel_chars);
- if (cancel_chars_copy == NULL) {
- ERR_raise(ERR_LIB_UI, ERR_R_MALLOC_FAILURE);
+ if (cancel_chars_copy == NULL)
goto err;
- }
}
return general_allocate_boolean(ui, prompt_copy, action_desc_copy,
if (text != NULL) {
text_copy = OPENSSL_strdup(text);
- if (text_copy == NULL) {
- ERR_raise(ERR_LIB_UI, ERR_R_MALLOC_FAILURE);
+ if (text_copy == NULL)
return -1;
- }
}
return general_allocate_string(ui, text_copy, 1, UIT_INFO, 0, NULL,
if (text != NULL) {
text_copy = OPENSSL_strdup(text);
- if (text_copy == NULL) {
- ERR_raise(ERR_LIB_UI, ERR_R_MALLOC_FAILURE);
+ if (text_copy == NULL)
return -1;
- }
}
return general_allocate_string(ui, text_copy, 1, UIT_ERROR, 0, NULL,
0, 0, NULL);
len += sizeof(prompt2) - 1 + strlen(object_name);
len += sizeof(prompt3) - 1;
- if ((prompt = OPENSSL_malloc(len + 1)) == NULL) {
- ERR_raise(ERR_LIB_UI, ERR_R_MALLOC_FAILURE);
+ if ((prompt = OPENSSL_malloc(len + 1)) == NULL)
return NULL;
- }
OPENSSL_strlcpy(prompt, prompt1, len + 1);
OPENSSL_strlcat(prompt, phrase_desc, len + 1);
if (object_name != NULL) {
duplicate = ui->meth->ui_duplicate_data(ui, user_data);
if (duplicate == NULL) {
- ERR_raise(ERR_LIB_UI, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_UI, ERR_R_UI_LIB);
return -1;
}
|| (ui_method->name = OPENSSL_strdup(name)) == NULL
|| !CRYPTO_new_ex_data(CRYPTO_EX_INDEX_UI_METHOD, ui_method,
&ui_method->ex_data)) {
- if (ui_method)
+
+ if (ui_method != NULL) {
+ if (ui_method->name != NULL)
+ /*
+ * These conditions indicate that the CRYPTO_new_ex_data()
+ * call failed.
+ */
+ ERR_raise(ERR_LIB_UI, ERR_R_CRYPTO_LIB);
OPENSSL_free(ui_method->name);
+ }
OPENSSL_free(ui_method);
- ERR_raise(ERR_LIB_UI, ERR_R_MALLOC_FAILURE);
return NULL;
}
return ui_method;
{
BY_DIR *a = OPENSSL_malloc(sizeof(*a));
- if (a == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if (a == NULL)
return 0;
- }
if ((a->buffer = BUF_MEM_new()) == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_BN_LIB);
goto err;
}
a->dirs = NULL;
a->lock = CRYPTO_THREAD_lock_new();
if (a->lock == NULL) {
BUF_MEM_free(a->buffer);
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto err;
}
lu->method_data = a;
if (ctx->dirs == NULL) {
ctx->dirs = sk_BY_DIR_ENTRY_new_null();
if (!ctx->dirs) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
return 0;
}
}
ent = OPENSSL_malloc(sizeof(*ent));
- if (ent == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if (ent == NULL)
return 0;
- }
ent->dir_type = type;
ent->hashes = sk_BY_DIR_HASH_new(by_dir_hash_cmp);
ent->dir = OPENSSL_strndup(ss, len);
}
if (!sk_BY_DIR_ENTRY_push(ctx->dirs, ent)) {
by_dir_entry_free(ent);
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
return 0;
}
}
ent = sk_BY_DIR_ENTRY_value(ctx->dirs, i);
j = strlen(ent->dir) + 1 + 8 + 6 + 1 + 1;
if (!BUF_MEM_grow(b, j)) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_BUF_LIB);
goto finish;
}
if (type == X509_LU_CRL && ent->hashes) {
hent = OPENSSL_malloc(sizeof(*hent));
if (hent == NULL) {
CRYPTO_THREAD_unlock(ctx->lock);
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
ok = 0;
goto finish;
}
if (!sk_BY_DIR_HASH_push(ent->hashes, hent)) {
CRYPTO_THREAD_unlock(ctx->lock);
OPENSSL_free(hent);
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
ok = 0;
goto finish;
}
}
x = X509_new_ex(libctx, propq);
if (x == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
goto err;
}
goto bad_policy;
cache->data = sk_X509_POLICY_DATA_new(policy_data_cmp);
if (cache->data == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
goto just_cleanup;
}
for (i = 0; i < num; i++) {
policy = sk_POLICYINFO_value(policies, i);
data = ossl_policy_data_new(policy, NULL, crit);
if (data == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_X509_LIB);
goto just_cleanup;
}
/*
ret = -1;
goto bad_policy;
} else if (!sk_X509_POLICY_DATA_push(cache->data, data)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
goto bad_policy;
}
data = NULL;
if (x->policy_cache != NULL)
return 1;
cache = OPENSSL_malloc(sizeof(*cache));
- if (cache == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if (cache == NULL)
return 0;
- }
cache->anyPolicy = NULL;
cache->data = NULL;
cache->any_skip = -1;
ret = OPENSSL_zalloc(sizeof(*ret));
if (ret == NULL) {
ASN1_OBJECT_free(id);
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
return NULL;
}
ret->expected_policy_set = sk_ASN1_OBJECT_new_null();
if (ret->expected_policy_set == NULL) {
OPENSSL_free(ret);
ASN1_OBJECT_free(id);
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
return NULL;
}
X509_POLICY_NODE *node;
node = OPENSSL_zalloc(sizeof(*node));
- if (node == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if (node == NULL)
return NULL;
- }
node->data = data;
node->parent = parent;
if (level) {
if (level->nodes == NULL)
level->nodes = ossl_policy_node_cmp_new();
if (level->nodes == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_X509_LIB);
goto node_error;
}
if (!sk_X509_POLICY_NODE_push(level->nodes, node)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
goto node_error;
}
}
if (tree->extra_data == NULL)
tree->extra_data = sk_X509_POLICY_DATA_new_null();
if (tree->extra_data == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
goto node_error;
}
if (!sk_X509_POLICY_DATA_push(tree->extra_data, data)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
goto node_error;
}
}
return ret;
/* If we get this far initialize the tree */
- if ((tree = OPENSSL_zalloc(sizeof(*tree))) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if ((tree = OPENSSL_zalloc(sizeof(*tree))) == NULL)
return X509_PCY_TREE_INTERNAL;
- }
/*
* http://tools.ietf.org/html/rfc5280#section-6.1.2, figure 3.
*/
if ((tree->levels = OPENSSL_zalloc(sizeof(*tree->levels)*(n+1))) == NULL) {
OPENSSL_free(tree);
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
return X509_PCY_TREE_INTERNAL;
}
tree->nlevel = n+1;
int i;
if ((addr = sk_IPAddressFamily_new(IPAddressFamily_cmp)) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
return NULL;
}
} else {
s = OPENSSL_strdup(val->value);
}
- if (s == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if (s == NULL)
goto err;
- }
/*
* Check for inheritance. Not worth additional complexity to
goto err;
}
if (!X509v3_addr_add_prefix(addr, afi, safi, min, prefixlen)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_X509V3_LIB);
goto err;
}
break;
goto err;
}
if (!X509v3_addr_add_range(addr, afi, safi, min, max)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_X509V3_LIB);
goto err;
}
break;
case '\0':
if (!X509v3_addr_add_prefix(addr, afi, safi, min, length * 8)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_X509V3_LIB);
goto err;
}
break;
validation_err(X509_V_ERR_INVALID_EXTENSION);
(void)sk_IPAddressFamily_set_cmp_func(ext, IPAddressFamily_cmp);
if ((child = sk_IPAddressFamily_dup(ext)) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
if (ctx != NULL)
ctx->error = X509_V_ERR_OUT_OF_MEM;
ret = 0;
if (akeyid->keyid) {
tmp = i2s_ASN1_OCTET_STRING(NULL, akeyid->keyid);
if (tmp == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
return NULL;
}
if (!X509V3_add_value((akeyid->issuer || akeyid->serial) ? "keyid" : NULL,
if (akeyid->serial) {
tmp = i2s_ASN1_OCTET_STRING(NULL, akeyid->serial);
if (tmp == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
if (!X509V3_add_value("serial", tmp, &extlist)) {
if (isname != NULL) {
if ((gens = sk_GENERAL_NAME_new_null()) == NULL
- || (gen = GENERAL_NAME_new()) == NULL
- || !sk_GENERAL_NAME_push(gens, gen)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ || (gen = GENERAL_NAME_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
+ if (!sk_GENERAL_NAME_push(gens, gen)) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
goto err;
}
gen->type = GEN_DIRNAME;
if ((bn == NULL && (bn = BN_new()) == NULL) ||
ASN1_INTEGER_to_BN(a_max, bn) == NULL ||
!BN_add_word(bn, 1)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_BN_LIB);
goto done;
}
if ((a_max_plus_one =
BN_to_ASN1_INTEGER(bn, orig = a_max_plus_one)) == NULL) {
a_max_plus_one = orig;
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto done;
}
if ((bn == NULL && (bn = BN_new()) == NULL) ||
ASN1_INTEGER_to_BN(a_max, bn) == NULL ||
!BN_add_word(bn, 1)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_BN_LIB);
goto done;
}
if ((a_max_plus_one =
BN_to_ASN1_INTEGER(bn, orig = a_max_plus_one)) == NULL) {
a_max_plus_one = orig;
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto done;
}
ASRange *r;
switch (a->type) {
case ASIdOrRange_id:
- if ((r = OPENSSL_malloc(sizeof(*r))) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if ((r = OPENSSL_malloc(sizeof(*r))) == NULL)
goto done;
- }
r->min = a_min;
r->max = b_max;
a->type = ASIdOrRange_range;
int i;
if ((asid = ASIdentifiers_new()) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_X509V3_LIB);
return NULL;
}
*/
if (!is_range) {
if (!X509V3_get_value_int(val, &min)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_X509V3_LIB);
goto err;
}
} else {
char *s = OPENSSL_strdup(val->value);
- if (s == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if (s == NULL)
goto err;
- }
s[i1] = '\0';
min = s2i_ASN1_INTEGER(NULL, s);
max = s2i_ASN1_INTEGER(NULL, s + i2);
OPENSSL_free(s);
if (min == NULL || max == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_X509V3_LIB);
goto err;
}
if (ASN1_INTEGER_cmp(min, max) > 0) {
}
}
if (!X509v3_asid_add_id_or_range(asid, which, min, max)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_X509V3_LIB);
goto err;
}
min = max = NULL;
int i;
if ((bcons = BASIC_CONSTRAINTS_new()) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
return NULL;
}
for (i = 0; i < sk_CONF_VALUE_num(values); i++) {
int i;
BIT_STRING_BITNAME *bnam;
if ((bs = ASN1_BIT_STRING_new()) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
return NULL;
}
for (i = 0; i < sk_CONF_VALUE_num(nval); i++) {
if (strcmp(bnam->sname, val->name) == 0
|| strcmp(bnam->lname, val->name) == 0) {
if (!ASN1_BIT_STRING_set_bit(bs, bnam->bitnum, 1)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
ASN1_BIT_STRING_free(bs);
return NULL;
}
ext_der = NULL;
ext_len =
ASN1_item_i2d(ext_struc, &ext_der, ASN1_ITEM_ptr(method->it));
- if (ext_len < 0)
- goto merr;
+ if (ext_len < 0) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
} else {
unsigned char *p;
ext_len = method->i2d(ext_struc, NULL);
- if (ext_len <= 0)
- goto merr;
+ if (ext_len <= 0) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
if ((ext_der = OPENSSL_malloc(ext_len)) == NULL)
- goto merr;
+ goto err;
p = ext_der;
method->i2d(ext_struc, &p);
}
- if ((ext_oct = ASN1_OCTET_STRING_new()) == NULL)
- goto merr;
+ if ((ext_oct = ASN1_OCTET_STRING_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
ext_oct->data = ext_der;
ext_der = NULL;
ext_oct->length = ext_len;
ext = X509_EXTENSION_create_by_NID(NULL, ext_nid, crit, ext_oct);
- if (!ext)
- goto merr;
+ if (!ext) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_X509V3_LIB);
+ goto err;
+ }
ASN1_OCTET_STRING_free(ext_oct);
return ext;
- merr:
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ err:
OPENSSL_free(ext_der);
ASN1_OCTET_STRING_free(ext_oct);
return NULL;
}
if ((oct = ASN1_OCTET_STRING_new()) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
pols = sk_POLICYINFO_new_reserve(NULL, num);
if (pols == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
goto err;
}
pol = POLICYINFO_new();
if (pol == NULL) {
ASN1_OBJECT_free(pobj);
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
pol->policyid = pobj;
}
if (!sk_POLICYINFO_push(pols, pol)) {
POLICYINFO_free(pol);
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
goto err;
}
}
POLICYINFO *pol;
POLICYQUALINFO *qual;
- if ((pol = POLICYINFO_new()) == NULL)
- goto merr;
+ if ((pol = POLICYINFO_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
for (i = 0; i < sk_CONF_VALUE_num(polstrs); i++) {
cnf = sk_CONF_VALUE_value(polstrs, i);
if (strcmp(cnf->name, "policyIdentifier") == 0) {
} else if (!ossl_v3_name_cmp(cnf->name, "CPS")) {
if (pol->qualifiers == NULL)
pol->qualifiers = sk_POLICYQUALINFO_new_null();
- if ((qual = POLICYQUALINFO_new()) == NULL)
- goto merr;
- if (!sk_POLICYQUALINFO_push(pol->qualifiers, qual))
- goto merr;
+ if ((qual = POLICYQUALINFO_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
+ if (!sk_POLICYQUALINFO_push(pol->qualifiers, qual)) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
if ((qual->pqualid = OBJ_nid2obj(NID_id_qt_cps)) == NULL) {
ERR_raise(ERR_LIB_X509V3, ERR_R_INTERNAL_ERROR);
goto err;
}
- if ((qual->d.cpsuri = ASN1_IA5STRING_new()) == NULL)
- goto merr;
+ if ((qual->d.cpsuri = ASN1_IA5STRING_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
if (!ASN1_STRING_set(qual->d.cpsuri, cnf->value,
- strlen(cnf->value)))
- goto merr;
+ strlen(cnf->value))) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
} else if (!ossl_v3_name_cmp(cnf->name, "userNotice")) {
STACK_OF(CONF_VALUE) *unot;
if (*cnf->value != '@') {
goto err;
if (pol->qualifiers == NULL)
pol->qualifiers = sk_POLICYQUALINFO_new_null();
- if (!sk_POLICYQUALINFO_push(pol->qualifiers, qual))
- goto merr;
+ if (!sk_POLICYQUALINFO_push(pol->qualifiers, qual)) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
} else {
ERR_raise(ERR_LIB_X509V3, X509V3_R_INVALID_OPTION);
X509V3_conf_err(cnf);
return pol;
- merr:
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
-
err:
POLICYINFO_free(pol);
return NULL;
POLICYQUALINFO *qual;
char *value = NULL;
- if ((qual = POLICYQUALINFO_new()) == NULL)
- goto merr;
+ if ((qual = POLICYQUALINFO_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
if ((qual->pqualid = OBJ_nid2obj(NID_id_qt_unotice)) == NULL) {
ERR_raise(ERR_LIB_X509V3, ERR_R_INTERNAL_ERROR);
goto err;
}
- if ((not = USERNOTICE_new()) == NULL)
- goto merr;
+ if ((not = USERNOTICE_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
qual->d.usernotice = not;
for (i = 0; i < sk_CONF_VALUE_num(unot); i++) {
cnf = sk_CONF_VALUE_value(unot, i);
value = cnf->value;
if (strcmp(cnf->name, "explicitText") == 0) {
tag = displaytext_str2tag(value, &tag_len);
- if ((not->exptext = ASN1_STRING_type_new(tag)) == NULL)
- goto merr;
+ if ((not->exptext = ASN1_STRING_type_new(tag)) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
if (tag_len != 0)
value += tag_len + 1;
len = strlen(value);
- if (!ASN1_STRING_set(not->exptext, value, len))
- goto merr;
+ if (!ASN1_STRING_set(not->exptext, value, len)) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
} else if (strcmp(cnf->name, "organization") == 0) {
NOTICEREF *nref;
if (!not->noticeref) {
- if ((nref = NOTICEREF_new()) == NULL)
- goto merr;
+ if ((nref = NOTICEREF_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
not->noticeref = nref;
} else
nref = not->noticeref;
else
nref->organization->type = V_ASN1_VISIBLESTRING;
if (!ASN1_STRING_set(nref->organization, cnf->value,
- strlen(cnf->value)))
- goto merr;
+ strlen(cnf->value))) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
} else if (strcmp(cnf->name, "noticeNumbers") == 0) {
NOTICEREF *nref;
STACK_OF(CONF_VALUE) *nos;
if (!not->noticeref) {
- if ((nref = NOTICEREF_new()) == NULL)
- goto merr;
+ if ((nref = NOTICEREF_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
not->noticeref = nref;
} else
nref = not->noticeref;
return qual;
- merr:
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
-
err:
POLICYQUALINFO_free(qual);
return NULL;
cnf = sk_CONF_VALUE_value(nos, i);
if ((aint = s2i_ASN1_INTEGER(NULL, cnf->name)) == NULL) {
ERR_raise(ERR_LIB_X509V3, X509V3_R_INVALID_NUMBER);
- goto err;
+ return 0;
+ }
+ if (!sk_ASN1_INTEGER_push(nnums, aint)) {
+ ASN1_INTEGER_free(aint);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
+ return 0;
}
- if (!sk_ASN1_INTEGER_push(nnums, aint))
- goto merr;
}
return 1;
-
- merr:
- ASN1_INTEGER_free(aint);
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
-
- err:
- return 0;
}
static int i2r_certpol(X509V3_EXT_METHOD *method, STACK_OF(POLICYINFO) *pol,
int i;
crld = sk_DIST_POINT_new_reserve(NULL, num);
- if (crld == NULL)
- goto merr;
+ if (crld == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
for (i = 0; i < num; i++) {
DIST_POINT *point;
} else {
if ((gen = v2i_GENERAL_NAME(method, ctx, cnf)) == NULL)
goto err;
- if ((gens = GENERAL_NAMES_new()) == NULL)
- goto merr;
- if (!sk_GENERAL_NAME_push(gens, gen))
- goto merr;
+ if ((gens = GENERAL_NAMES_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
+ if (!sk_GENERAL_NAME_push(gens, gen)) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
gen = NULL;
- if ((point = DIST_POINT_new()) == NULL)
- goto merr;
+ if ((point = DIST_POINT_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
sk_DIST_POINT_push(crld, point); /* no failure as it was reserved */
- if ((point->distpoint = DIST_POINT_NAME_new()) == NULL)
- goto merr;
+ if ((point->distpoint = DIST_POINT_NAME_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
point->distpoint->name.fullname = gens;
point->distpoint->type = 0;
gens = NULL;
}
return crld;
- merr:
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
err:
GENERAL_NAME_free(gen);
GENERAL_NAMES_free(gens);
char *name, *val;
int i, ret;
idp = ISSUING_DIST_POINT_new();
- if (idp == NULL)
- goto merr;
+ if (idp == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
for (i = 0; i < sk_CONF_VALUE_num(nval); i++) {
cnf = sk_CONF_VALUE_value(nval, i);
name = cnf->name;
}
return idp;
- merr:
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
err:
ISSUING_DIST_POINT_free(idp);
return NULL;
extku = sk_ASN1_OBJECT_new_reserve(NULL, num);
if (extku == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
sk_ASN1_OBJECT_free(extku);
return NULL;
}
if (ia5 == NULL || ia5->length <= 0)
return NULL;
- if ((tmp = OPENSSL_malloc(ia5->length + 1)) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if ((tmp = OPENSSL_malloc(ia5->length + 1)) == NULL)
return NULL;
- }
memcpy(tmp, ia5->data, ia5->length);
tmp[ia5->length] = 0;
return tmp;
ERR_raise(ERR_LIB_X509V3, X509V3_R_INVALID_NULL_ARGUMENT);
return NULL;
}
- if ((ia5 = ASN1_IA5STRING_new()) == NULL)
- goto err;
+ if ((ia5 = ASN1_IA5STRING_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ return NULL;
+ }
if (!ASN1_STRING_set((ASN1_STRING *)ia5, str, strlen(str))) {
ASN1_IA5STRING_free(ia5);
return NULL;
ebcdic2ascii(ia5->data, ia5->data, ia5->length);
#endif /* CHARSET_EBCDIC */
return ia5;
- err:
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
- return NULL;
}
desc = sk_ACCESS_DESCRIPTION_value(ainfo, i);
tmp = i2v_GENERAL_NAME(method, desc->location, tret);
- if (tmp == NULL)
+ if (tmp == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
+ }
tret = tmp;
vtmp = sk_CONF_VALUE_value(tret, i);
i2t_ASN1_OBJECT(objtmp, sizeof(objtmp), desc->method);
return tret;
err:
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
if (ret == NULL && tret != NULL)
sk_CONF_VALUE_pop_free(tret, X509V3_conf_free);
return NULL;
char *objtmp, *ptmp;
if ((ainfo = sk_ACCESS_DESCRIPTION_new_reserve(NULL, num)) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
return NULL;
}
for (i = 0; i < num; i++) {
cnf = sk_CONF_VALUE_value(nval, i);
if ((acc = ACCESS_DESCRIPTION_new()) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
sk_ACCESS_DESCRIPTION_push(ainfo, acc); /* Cannot fail due to reserve */
ctmp.value = cnf->value;
if (!v2i_GENERAL_NAME_ex(acc->location, method, ctx, &ctmp, 0))
goto err;
- if ((objtmp = OPENSSL_strndup(cnf->name, ptmp - cnf->name)) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if ((objtmp = OPENSSL_strndup(cnf->name, ptmp - cnf->name)) == NULL)
goto err;
- }
acc->method = OBJ_txt2obj(objtmp, 0);
if (!acc->method) {
ERR_raise_data(ERR_LIB_X509V3, X509V3_R_BAD_OBJECT,
int i;
if (ist == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
return NULL;
}
for (i = 0; i < sk_CONF_VALUE_num(nval); ++i) {
if (strcmp(cnf->name, "signTool") == 0) {
ist->signTool = ASN1_UTF8STRING_new();
if (ist->signTool == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
ISSUER_SIGN_TOOL_free(ist);
return NULL;
}
} else if (strcmp(cnf->name, "cATool") == 0) {
ist->cATool = ASN1_UTF8STRING_new();
if (ist->cATool == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
ISSUER_SIGN_TOOL_free(ist);
return NULL;
}
} else if (strcmp(cnf->name, "signToolCert") == 0) {
ist->signToolCert = ASN1_UTF8STRING_new();
if (ist->signToolCert == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
ISSUER_SIGN_TOOL_free(ist);
return NULL;
}
} else if (strcmp(cnf->name, "cAToolCert") == 0) {
ist->cAToolCert = ASN1_UTF8STRING_new();
if (ist->cAToolCert == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
ISSUER_SIGN_TOOL_free(ist);
return NULL;
}
{
if (ext_list == NULL
&& (ext_list = sk_X509V3_EXT_METHOD_new(ext_cmp)) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
return 0;
}
if (!sk_X509V3_EXT_METHOD_push(ext_list, ext)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
return 0;
}
return 1;
ERR_raise(ERR_LIB_X509V3, X509V3_R_EXTENSION_NOT_FOUND);
return 0;
}
- if ((tmpext = OPENSSL_malloc(sizeof(*tmpext))) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if ((tmpext = OPENSSL_malloc(sizeof(*tmpext))) == NULL)
return 0;
- }
*tmpext = *ext;
tmpext->ext_nid = nid_to;
tmpext->ext_flags |= X509V3_EXT_DYNAMIC;
return 1;
m_fail:
- /* ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE); */
+ /* ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB); */
if (ret != *x)
sk_X509_EXTENSION_free(ret);
X509_EXTENSION_free(ext);
GENERAL_SUBTREE *sub = NULL;
ncons = NAME_CONSTRAINTS_new();
- if (ncons == NULL)
- goto memerr;
+ if (ncons == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
for (i = 0; i < sk_CONF_VALUE_num(nval); i++) {
val = sk_CONF_VALUE_value(nval, i);
if (HAS_PREFIX(val->name, "permitted") && val->name[9]) {
}
tval.value = val->value;
sub = GENERAL_SUBTREE_new();
- if (sub == NULL)
- goto memerr;
- if (!v2i_GENERAL_NAME_ex(sub->base, method, ctx, &tval, 1))
+ if (sub == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ goto err;
+ }
+ if (!v2i_GENERAL_NAME_ex(sub->base, method, ctx, &tval, 1)) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_X509V3_LIB);
goto err;
+ }
if (*ptree == NULL)
*ptree = sk_GENERAL_SUBTREE_new_null();
- if (*ptree == NULL || !sk_GENERAL_SUBTREE_push(*ptree, sub))
- goto memerr;
+ if (*ptree == NULL || !sk_GENERAL_SUBTREE_push(*ptree, sub)) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
sub = NULL;
}
return ncons;
- memerr:
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
err:
NAME_CONSTRAINTS_free(ncons);
GENERAL_SUBTREE_free(sub);
if (*policy == NULL) {
*policy = ASN1_OCTET_STRING_new();
if (*policy == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
X509V3_conf_err(val);
return 0;
}
OPENSSL_free((*policy)->data);
(*policy)->data = NULL;
(*policy)->length = 0;
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
X509V3_conf_err(val);
goto err;
}
OPENSSL_free((*policy)->data);
(*policy)->data = NULL;
(*policy)->length = 0;
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
X509V3_conf_err(val);
BIO_free_all(b);
goto err;
OPENSSL_free((*policy)->data);
(*policy)->data = NULL;
(*policy)->length = 0;
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
X509V3_conf_err(val);
goto err;
}
goto err;
}
if (!tmp_data) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
X509V3_conf_err(val);
goto err;
}
pci = PROXY_CERT_INFO_EXTENSION_new();
if (pci == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
int i;
if ((pcons = POLICY_CONSTRAINTS_new()) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
return NULL;
}
for (i = 0; i < sk_CONF_VALUE_num(values); i++) {
int i;
if ((pmaps = sk_POLICY_MAPPING_new_reserve(NULL, num)) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
return NULL;
}
}
pmap = POLICY_MAPPING_new();
if (pmap == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
pmap->issuerDomainPolicy = obj1;
idx = X509_PURPOSE_get_by_id(id);
/* Need a new entry */
if (idx == -1) {
- if ((ptmp = OPENSSL_malloc(sizeof(*ptmp))) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if ((ptmp = OPENSSL_malloc(sizeof(*ptmp))) == NULL)
return 0;
- }
ptmp->flags = X509_PURPOSE_DYNAMIC;
} else {
ptmp = X509_PURPOSE_get0(idx);
/* Dup supplied name */
ptmp->name = OPENSSL_strdup(name);
ptmp->sname = OPENSSL_strdup(sname);
- if (ptmp->name == NULL || ptmp->sname == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if (ptmp->name == NULL || ptmp->sname == NULL)
goto err;
- }
/* Keep the dynamic flag of existing entry */
ptmp->flags &= X509_PURPOSE_DYNAMIC;
/* Set all other flags */
if (idx == -1) {
if (xptable == NULL
&& (xptable = sk_X509_PURPOSE_new(xp_cmp)) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
goto err;
}
if (!sk_X509_PURPOSE_push(xptable, ptmp)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
goto err;
}
}
int i;
if (gens == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
sk_GENERAL_NAME_free(gens);
return NULL;
}
num = sk_GENERAL_NAME_num(ialt);
if (!sk_GENERAL_NAME_reserve(gens, num)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
goto err;
}
gens = sk_GENERAL_NAME_new_reserve(NULL, num);
if (gens == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
sk_GENERAL_NAME_free(gens);
return NULL;
}
i--;
}
if (email == NULL || (gen = GENERAL_NAME_new()) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
gen->d.ia5 = email;
email = NULL;
gen->type = GEN_EMAIL;
if (!sk_GENERAL_NAME_push(gens, gen)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
goto err;
}
gen = NULL;
gens = sk_GENERAL_NAME_new_reserve(NULL, num);
if (gens == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
sk_GENERAL_NAME_free(gens);
return NULL;
}
else {
gen = GENERAL_NAME_new();
if (gen == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
return NULL;
}
}
if ((gen->d.ia5 = ASN1_IA5STRING_new()) == NULL ||
!ASN1_STRING_set(gen->d.ia5, (unsigned char *)value,
strlen(value))) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
}
long length;
if ((oct = ASN1_OCTET_STRING_new()) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
return NULL;
}
if ((izone = ASN1_INTEGER_new()) == NULL
|| !ASN1_INTEGER_set(izone, lzone)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
ASN1_INTEGER_free(izone);
return 0;
}
return 0;
}
if (*psx == NULL) {
- if ((sx = SXNET_new()) == NULL)
+ if ((sx = SXNET_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
- if (!ASN1_INTEGER_set(sx->version, 0))
+ }
+ if (!ASN1_INTEGER_set(sx->version, 0)) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
+ }
} else
sx = *psx;
if (SXNET_get_id_INTEGER(sx, zone)) {
return 0;
}
- if ((id = SXNETID_new()) == NULL)
+ if ((id = SXNETID_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
+ }
- if (!ASN1_OCTET_STRING_set(id->user, (const unsigned char *)user, userlen))
+ if (!ASN1_OCTET_STRING_set(id->user, (const unsigned char *)user, userlen)){
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
- if (!sk_SXNETID_push(sx->ids, id))
+ }
+ if (!sk_SXNETID_push(sx->ids, id)) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
goto err;
+ }
id->zone = zone;
*psx = sx;
return 1;
err:
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
SXNETID_free(id);
if (*psx == NULL)
SXNET_free(sx);
if ((izone = ASN1_INTEGER_new()) == NULL
|| !ASN1_INTEGER_set(izone, lzone)) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
ASN1_INTEGER_free(izone);
return NULL;
}
long tlsextid;
if ((tlsf = sk_ASN1_INTEGER_new_null()) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
return NULL;
}
if ((ai = ASN1_INTEGER_new()) == NULL
|| !ASN1_INTEGER_set(ai, tlsextid)
|| sk_ASN1_INTEGER_push(tlsf, ai) <= 0) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
goto err;
}
/* So it doesn't get purged if an error occurs next time around */
ERR_raise(ERR_LIB_X509V3, ERR_R_PASSED_NULL_PARAMETER);
return NULL;
}
- if ((tmp = OPENSSL_malloc(utf8->length + 1)) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if ((tmp = OPENSSL_malloc(utf8->length + 1)) == NULL)
return NULL;
- }
memcpy(tmp, utf8->data, utf8->length);
tmp[utf8->length] = 0;
return tmp;
return NULL;
}
if ((utf8 = ASN1_UTF8STRING_new()) == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
return NULL;
}
if (!ASN1_STRING_set((ASN1_STRING *)utf8, str, strlen(str))) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
ASN1_UTF8STRING_free(utf8);
return NULL;
}
}
if ((vtmp = OPENSSL_malloc(sizeof(*vtmp))) == NULL)
goto err;
- if (sk_allocated && (*extlist = sk_CONF_VALUE_new_null()) == NULL)
+ if (sk_allocated && (*extlist = sk_CONF_VALUE_new_null()) == NULL) {
+ ERR_raise(ERR_LIB_X509V3, ERR_R_CRYPTO_LIB);
goto err;
+ }
vtmp->section = NULL;
vtmp->name = tname;
vtmp->value = tvalue;
goto err;
return 1;
err:
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
if (sk_allocated) {
sk_CONF_VALUE_free(*extlist);
*extlist = NULL;
len = strlen(tmp) + 3;
ret = OPENSSL_malloc(len);
if (ret == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
OPENSSL_free(tmp);
return NULL;
}
if (!a)
return NULL;
- if ((bntmp = ASN1_ENUMERATED_to_BN(a, NULL)) == NULL
- || (strtmp = bignum_to_string(bntmp)) == NULL)
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if ((bntmp = ASN1_ENUMERATED_to_BN(a, NULL)) == NULL)
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ else if ((strtmp = bignum_to_string(bntmp)) == NULL)
+ ERR_raise(ERR_LIB_X509V3, ERR_R_X509V3_LIB);
BN_free(bntmp);
return strtmp;
}
if (!a)
return NULL;
- if ((bntmp = ASN1_INTEGER_to_BN(a, NULL)) == NULL
- || (strtmp = bignum_to_string(bntmp)) == NULL)
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if ((bntmp = ASN1_INTEGER_to_BN(a, NULL)) == NULL)
+ ERR_raise(ERR_LIB_X509V3, ERR_R_ASN1_LIB);
+ else if ((strtmp = bignum_to_string(bntmp)) == NULL)
+ ERR_raise(ERR_LIB_X509V3, ERR_R_X509V3_LIB);
BN_free(bntmp);
return strtmp;
}
}
bn = BN_new();
if (bn == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509V3, ERR_R_BN_LIB);
return NULL;
}
if (value[0] == '-') {
/* We are going to modify the line so copy it first */
linebuf = OPENSSL_strdup(line);
- if (linebuf == NULL) {
- ERR_raise(ERR_LIB_X509V3, ERR_R_MALLOC_FAILURE);
+ if (linebuf == NULL)
goto err;
- }
state = HDR_NAME;
ntmp = NULL;
/* Go through all characters */
}
if (*x == NULL) {
- if ((sk = sk_X509_ATTRIBUTE_new_null()) == NULL)
+ if ((sk = sk_X509_ATTRIBUTE_new_null()) == NULL) {
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto err;
+ }
} else {
sk = *x;
}
if ((new_attr = X509_ATTRIBUTE_dup(attr)) == NULL)
- goto err2;
- if (!sk_X509_ATTRIBUTE_push(sk, new_attr))
goto err;
+ if (!sk_X509_ATTRIBUTE_push(sk, new_attr)) {
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
if (*x == NULL)
*x = sk;
return sk;
err:
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
- err2:
X509_ATTRIBUTE_free(new_attr);
if (*x == NULL)
sk_X509_ATTRIBUTE_free(sk);
if (attr == NULL || *attr == NULL) {
if ((ret = X509_ATTRIBUTE_new()) == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
return NULL;
}
} else {
}
atype = stmp->type;
} else if (len != -1) {
- if ((stmp = ASN1_STRING_type_new(attrtype)) == NULL)
- goto err;
- if (!ASN1_STRING_set(stmp, data, len))
+ if ((stmp = ASN1_STRING_type_new(attrtype)) == NULL
+ || !ASN1_STRING_set(stmp, data, len)) {
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
goto err;
+ }
atype = attrtype;
}
/*
ASN1_STRING_free(stmp);
return 1;
}
- if ((ttmp = ASN1_TYPE_new()) == NULL)
+ if ((ttmp = ASN1_TYPE_new()) == NULL) {
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
goto err;
+ }
if (len == -1 && (attrtype & MBSTRING_FLAG) == 0) {
- if (!ASN1_TYPE_set1(ttmp, attrtype, data))
+ if (!ASN1_TYPE_set1(ttmp, attrtype, data)) {
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
goto err;
+ }
} else {
ASN1_TYPE_set(ttmp, atype, stmp);
stmp = NULL;
}
- if (!sk_ASN1_TYPE_push(attr->set, ttmp))
+ if (!sk_ASN1_TYPE_push(attr->set, ttmp)) {
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto err;
+ }
return 1;
err:
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
ASN1_TYPE_free(ttmp);
ASN1_STRING_free(stmp);
return 0;
int ossl_x509_add_cert_new(STACK_OF(X509) **p_sk, X509 *cert, int flags)
{
if (*p_sk == NULL && (*p_sk = sk_X509_new_null()) == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
return 0;
}
return X509_add_cert(*p_sk, cert, flags);
}
if (!sk_X509_insert(sk, cert,
(flags & X509_ADD_FLAG_PREPEND) != 0 ? 0 : -1)) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
return 0;
}
if ((flags & X509_ADD_FLAG_UP_REF) != 0)
{
X509_LOOKUP *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->method = method;
if (method->new_item != NULL && method->new_item(ret) == 0) {
{
X509_STORE *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
if ((ret->objs = sk_X509_OBJECT_new(x509_object_cmp)) == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto err;
}
ret->cache = 1;
if ((ret->get_cert_methods = sk_X509_LOOKUP_new_null()) == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto err;
}
if ((ret->param = X509_VERIFY_PARAM_new()) == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
goto err;
}
if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509_STORE, ret, &ret->ex_data)) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto err;
}
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto err;
}
ret->references = 1;
/* a new one */
lu = X509_LOOKUP_new(m);
if (lu == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
return NULL;
}
lu->store_ctx = xs;
if (sk_X509_LOOKUP_push(xs->get_cert_methods, lu))
return lu;
- /* malloc failed */
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ /* sk_X509_LOOKUP_push() failed */
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
X509_LOOKUP_free(lu);
return NULL;
}
int X509_STORE_add_cert(X509_STORE *xs, X509 *x)
{
if (!x509_store_add(xs, x, 0)) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
return 0;
}
return 1;
int X509_STORE_add_crl(X509_STORE *xs, X509_CRL *x)
{
if (!x509_store_add(xs, x, 1)) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
return 0;
}
return 1;
{
X509_OBJECT *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->type = X509_LU_NONE;
return ret;
}
if (method != NULL) {
method->name = OPENSSL_strdup(name);
- if (method->name == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if (method->name == NULL)
goto err;
- }
}
return method;
if (buf == NULL) {
if ((b = BUF_MEM_new()) == NULL)
- goto err;
+ goto buferr;
if (!BUF_MEM_grow(b, 200))
- goto err;
+ goto buferr;
b->data[0] = '\0';
len = 200;
} else if (len == 0) {
}
if (b != NULL) {
if (!BUF_MEM_grow(b, l + 1))
- goto err;
+ goto buferr;
p = &(b->data[lold]);
} else if (l > len) {
break;
if (i == 0)
*p = '\0';
return p;
- err:
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ buferr:
+ ERR_raise(ERR_LIB_X509, ERR_R_BUF_LIB);
end:
BUF_MEM_free(b);
return NULL;
EVP_PKEY *pubkey = NULL;
if ((ret = X509_new()) == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
return NULL;
}
ret = X509_REQ_new_ex(x->libctx, x->propq);
if (ret == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
goto err;
}
idx = X509_TRUST_get_by_id(id);
/* Need a new entry */
if (idx < 0) {
- if ((trtmp = OPENSSL_malloc(sizeof(*trtmp))) == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if ((trtmp = OPENSSL_malloc(sizeof(*trtmp))) == NULL)
return 0;
- }
trtmp->flags = X509_TRUST_DYNAMIC;
} else
trtmp = X509_TRUST_get0(idx);
if (trtmp->flags & X509_TRUST_DYNAMIC_NAME)
OPENSSL_free(trtmp->name);
/* dup supplied name */
- if ((trtmp->name = OPENSSL_strdup(name)) == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if ((trtmp->name = OPENSSL_strdup(name)) == NULL)
goto err;
- }
/* Keep the dynamic flag of existing entry */
trtmp->flags &= X509_TRUST_DYNAMIC;
/* Set all other flags */
if (idx < 0) {
if (trtable == NULL
&& (trtable = sk_X509_TRUST_new(tr_cmp)) == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto err;
}
if (!sk_X509_TRUST_push(trtable, trtmp)) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto err;
}
}
if (x == NULL) {
ERR_raise(ERR_LIB_X509, ERR_R_PASSED_NULL_PARAMETER);
- goto err2;
+ goto err;
}
if (*x == NULL) {
- if ((sk = sk_X509_EXTENSION_new_null()) == NULL)
+ if ((sk = sk_X509_EXTENSION_new_null()) == NULL) {
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto err;
+ }
} else
sk = *x;
else if (loc < 0)
loc = n;
- if ((new_ex = X509_EXTENSION_dup(ex)) == NULL)
- goto err2;
- if (!sk_X509_EXTENSION_insert(sk, new_ex, loc))
+ if ((new_ex = X509_EXTENSION_dup(ex)) == NULL) {
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
goto err;
+ }
+ if (!sk_X509_EXTENSION_insert(sk, new_ex, loc)) {
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
if (*x == NULL)
*x = sk;
return sk;
err:
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
- err2:
X509_EXTENSION_free(new_ex);
if (x != NULL && *x == NULL)
sk_X509_EXTENSION_free(sk);
if ((ex == NULL) || (*ex == NULL)) {
if ((ret = X509_EXTENSION_new()) == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
return NULL;
}
} else
*/
tmpsubject = X509_NAME_dup(tmpsubject);
if (tmpsubject == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
ctx->error = X509_V_ERR_OUT_OF_MEM;
return -1;
}
* was verified via a bare public key, and pop it off right after the
* X509_policy_check() call.
*/
- if (ctx->bare_ta_signed && !sk_X509_push(ctx->chain, NULL))
+ if (ctx->bare_ta_signed && !sk_X509_push(ctx->chain, NULL)) {
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto memerr;
+ }
ret = X509_policy_check(&ctx->tree, &ctx->explicit_policy, ctx->chain,
ctx->param->policies, ctx->param->flags);
if (ctx->bare_ta_signed)
(void)sk_X509_pop(ctx->chain);
- if (ret == X509_PCY_TREE_INTERNAL)
+ if (ret == X509_PCY_TREE_INTERNAL) {
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
goto memerr;
+ }
/* Invalid or inconsistent extensions */
if (ret == X509_PCY_TREE_INVALID) {
int i;
return 1;
memerr:
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
ctx->error = X509_V_ERR_OUT_OF_MEM;
return -1;
}
}
/* Create new CRL */
crl = X509_CRL_new_ex(base->libctx, base->propq);
- if (crl == NULL || !X509_CRL_set_version(crl, X509_CRL_VERSION_2))
- goto memerr;
+ if (crl == NULL || !X509_CRL_set_version(crl, X509_CRL_VERSION_2)) {
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
+ goto err;
+ }
/* Set issuer name */
- if (!X509_CRL_set_issuer_name(crl, X509_CRL_get_issuer(newer)))
- goto memerr;
+ if (!X509_CRL_set_issuer_name(crl, X509_CRL_get_issuer(newer))) {
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
+ goto err;
+ }
- if (!X509_CRL_set1_lastUpdate(crl, X509_CRL_get0_lastUpdate(newer)))
- goto memerr;
- if (!X509_CRL_set1_nextUpdate(crl, X509_CRL_get0_nextUpdate(newer)))
- goto memerr;
+ if (!X509_CRL_set1_lastUpdate(crl, X509_CRL_get0_lastUpdate(newer))) {
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
+ goto err;
+ }
+ if (!X509_CRL_set1_nextUpdate(crl, X509_CRL_get0_nextUpdate(newer))) {
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
+ goto err;
+ }
/* Set base CRL number: must be critical */
- if (!X509_CRL_add1_ext_i2d(crl, NID_delta_crl, base->crl_number, 1, 0))
- goto memerr;
+ if (!X509_CRL_add1_ext_i2d(crl, NID_delta_crl, base->crl_number, 1, 0)) {
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
+ goto err;
+ }
/*
* Copy extensions across from newest CRL to delta: this will set CRL
for (i = 0; i < X509_CRL_get_ext_count(newer); i++) {
X509_EXTENSION *ext = X509_CRL_get_ext(newer, i);
- if (!X509_CRL_add_ext(crl, ext, -1))
- goto memerr;
+ if (!X509_CRL_add_ext(crl, ext, -1)) {
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
+ goto err;
+ }
}
/* Go through revoked entries, copying as needed */
*/
if (!X509_CRL_get0_by_serial(base, &rvtmp, &rvn->serialNumber)) {
rvtmp = X509_REVOKED_dup(rvn);
- if (rvtmp == NULL)
- goto memerr;
+ if (rvtmp == NULL) {
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
+ goto err;
+ }
if (!X509_CRL_add0_revoked(crl, rvtmp)) {
X509_REVOKED_free(rvtmp);
- goto memerr;
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
+ goto err;
}
}
}
- if (skey != NULL && md != NULL && !X509_CRL_sign(crl, skey, md))
- goto memerr;
+ if (skey != NULL && md != NULL && !X509_CRL_sign(crl, skey, md)) {
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
+ goto err;
+ }
return crl;
- memerr:
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ err:
X509_CRL_free(crl);
return NULL;
}
{
X509_STORE_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
- if (ctx == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL)
return NULL;
- }
ctx->libctx = libctx;
if (propq != NULL) {
ctx->propq = OPENSSL_strdup(propq);
if (ctx->propq == NULL) {
OPENSSL_free(ctx);
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
return NULL;
}
}
ctx->param = X509_VERIFY_PARAM_new();
if (ctx->param == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
goto err;
}
if (CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509_STORE_CTX, ctx,
&ctx->ex_data))
return 1;
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
err:
/*
}
if (len < 0 || buf == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
return NULL;
}
}
/* Initialize empty untrusted stack. */
- if ((sk_untrusted = sk_X509_new_null()) == NULL)
+ if ((sk_untrusted = sk_X509_new_null()) == NULL) {
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto memerr;
+ }
/*
* If we got any "Cert(0) Full(0)" trust anchors from DNS, *prepend* them
* to our working copy of the untrusted certificate stack.
*/
if (DANETLS_ENABLED(dane) && dane->certs != NULL
- && !X509_add_certs(sk_untrusted, dane->certs, X509_ADD_FLAG_DEFAULT))
+ && !X509_add_certs(sk_untrusted, dane->certs, X509_ADD_FLAG_DEFAULT)) {
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
goto memerr;
+ }
/*
* Shallow-copy the stack of untrusted certificates (with TLS, this is
* typically the content of the peer's certificate message) so we can make
* multiple passes over it, while free to remove elements as we go.
*/
- if (!X509_add_certs(sk_untrusted, ctx->untrusted, X509_ADD_FLAG_DEFAULT))
+ if (!X509_add_certs(sk_untrusted, ctx->untrusted, X509_ADD_FLAG_DEFAULT)) {
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
goto memerr;
+ }
/*
* Still absurdly large, but arithmetically safe, a lower hard upper bound
/* Grow the chain by trusted issuer */
if (!sk_X509_push(ctx->chain, issuer)) {
X509_free(issuer);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto memerr;
}
if ((self_signed = X509_self_signed(issuer, 0)) < 0)
return -1;
memerr:
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
ctx->error = X509_V_ERR_OUT_OF_MEM;
sk_X509_free(sk_untrusted);
return -1;
X509_VERIFY_PARAM *param;
param = OPENSSL_zalloc(sizeof(*param));
- if (param == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if (param == NULL)
return NULL;
- }
param->trust = X509_TRUST_DEFAULT;
/* param->inh_flags = X509_VP_FLAG_DEFAULT; */
param->depth = -1;
goto err;
new_name->set = set;
if (!sk_X509_NAME_ENTRY_insert(sk, new_name, loc)) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto err;
}
if (inc) {
NETSCAPE_SPKI *spki;
if (len <= 0)
len = strlen(str);
- if ((spki_der = OPENSSL_malloc(len + 1)) == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if ((spki_der = OPENSSL_malloc(len + 1)) == NULL)
return NULL;
- }
spki_len = EVP_DecodeBlock(spki_der, (const unsigned char *)str, len);
if (spki_len < 0) {
ERR_raise(ERR_LIB_X509, X509_R_BASE64_DECODE_ERROR);
der_spki = OPENSSL_malloc(der_len);
b64_str = OPENSSL_malloc(der_len * 2);
if (der_spki == NULL || b64_str == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
OPENSSL_free(der_spki);
OPENSSL_free(b64_str);
return NULL;
if (inf->revoked == NULL)
inf->revoked = sk_X509_REVOKED_new(X509_REVOKED_cmp);
if (inf->revoked == NULL || !sk_X509_REVOKED_push(inf->revoked, rev)) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_CRYPTO_LIB);
return 0;
}
inf->enc.modified = 1;
{
X509_CRL_METHOD *m = OPENSSL_malloc(sizeof(*m));
- if (m == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if (m == NULL)
return NULL;
- }
m->crl_init = crl_init;
m->crl_free = crl_free;
m->crl_lookup = crl_lookup;
X509_NAME *ret = OPENSSL_zalloc(sizeof(*ret));
if (ret == NULL)
- goto memerr;
- if ((ret->entries = sk_X509_NAME_ENTRY_new_null()) == NULL)
- goto memerr;
- if ((ret->bytes = BUF_MEM_new()) == NULL)
- goto memerr;
+ return 0;
+ if ((ret->entries = sk_X509_NAME_ENTRY_new_null()) == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
+ if ((ret->bytes = BUF_MEM_new()) == NULL) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_BUF_LIB);
+ goto err;
+ }
ret->modified = 1;
*val = (ASN1_VALUE *)ret;
return 1;
- memerr:
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ err:
if (ret) {
sk_X509_NAME_ENTRY_free(ret->entries);
OPENSSL_free(ret);
intname.s = sk_STACK_OF_X509_NAME_ENTRY_new_null();
if (!intname.s)
- goto memerr;
+ goto cerr;
for (i = 0; i < sk_X509_NAME_ENTRY_num(a->entries); i++) {
entry = sk_X509_NAME_ENTRY_value(a->entries, i);
if (entry->set != set) {
entries = sk_X509_NAME_ENTRY_new_null();
if (!entries)
- goto memerr;
+ goto cerr;
if (!sk_STACK_OF_X509_NAME_ENTRY_push(intname.s, entries)) {
sk_X509_NAME_ENTRY_free(entries);
- goto memerr;
+ goto cerr;
}
set = entry->set;
}
if (!sk_X509_NAME_ENTRY_push(entries, entry))
- goto memerr;
+ goto cerr;
}
len = ASN1_item_ex_i2d(&intname.a, NULL,
ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1);
- if (!BUF_MEM_grow(a->bytes, len))
- goto memerr;
+ if (!BUF_MEM_grow(a->bytes, len)) {
+ ERR_raise(ERR_LIB_ASN1, ERR_R_BUF_LIB);
+ goto err;
+ }
p = (unsigned char *)a->bytes->data;
ASN1_item_ex_i2d(&intname.a,
&p, ASN1_ITEM_rptr(X509_NAME_INTERNAL), -1, -1);
local_sk_X509_NAME_ENTRY_free);
a->modified = 0;
return len;
- memerr:
+ cerr:
+ ERR_raise(ERR_LIB_ASN1, ERR_R_CRYPTO_LIB);
+ err:
sk_STACK_OF_X509_NAME_ENTRY_pop_free(intname.s,
local_sk_X509_NAME_ENTRY_free);
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
return -1;
}
}
intname = sk_STACK_OF_X509_NAME_ENTRY_new_null();
if (intname == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto err;
}
for (i = 0; i < sk_X509_NAME_ENTRY_num(a->entries); i++) {
goto err;
if (!sk_STACK_OF_X509_NAME_ENTRY_push(intname, entries)) {
sk_X509_NAME_ENTRY_free(entries);
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto err;
}
set = entry->set;
}
tmpentry = X509_NAME_ENTRY_new();
if (tmpentry == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
goto err;
}
tmpentry->object = OBJ_dup(entry->object);
if (tmpentry->object == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_OBJ_LIB);
goto err;
}
if (!asn1_string_canon(tmpentry->value, entry->value))
goto err;
if (!sk_X509_NAME_ENTRY_push(entries, tmpentry)) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_CRYPTO_LIB);
goto err;
}
tmpentry = NULL;
a->canon_enclen = len;
p = OPENSSL_malloc(a->canon_enclen);
- if (p == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if (p == NULL)
goto err;
- }
a->canon_enc = p;
{
X509_PUBKEY *ret;
- if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL
- || !x509_pubkey_ex_populate((ASN1_VALUE **)&ret, NULL)
+ if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
+ return 0;
+ if (!x509_pubkey_ex_populate((ASN1_VALUE **)&ret, NULL)
|| !x509_pubkey_set0_libctx(ret, libctx, propq)) {
x509_pubkey_ex_free((ASN1_VALUE **)&ret, NULL);
ret = NULL;
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_X509_LIB);
} else {
*pval = (ASN1_VALUE *)ret;
}
if (*pval == NULL && !x509_pubkey_ex_new_ex(pval, it, libctx, propq))
return 0;
if (!x509_pubkey_ex_populate(pval, NULL)) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_X509_LIB);
return 0;
}
*/
if (aclass != V_ASN1_UNIVERSAL) {
tmpbuf = OPENSSL_memdup(in_saved, publen);
- if (tmpbuf == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ if (tmpbuf == NULL)
return 0;
- }
in_saved = tmpbuf;
*tmpbuf = V_ASN1_CONSTRUCTED | V_ASN1_SEQUENCE;
}
{
X509_PUBKEY *pubkey = OPENSSL_zalloc(sizeof(*pubkey));
- if (pubkey == NULL
- || !x509_pubkey_set0_libctx(pubkey, a->libctx, a->propq)
- || (pubkey->algor = X509_ALGOR_dup(a->algor)) == NULL
- || (pubkey->public_key = ASN1_BIT_STRING_new()) == NULL
- || !ASN1_BIT_STRING_set(pubkey->public_key,
- a->public_key->data,
- a->public_key->length)) {
+ if (pubkey == NULL)
+ return NULL;
+ if (!x509_pubkey_set0_libctx(pubkey, a->libctx, a->propq)) {
+ ERR_raise(ERR_LIB_X509, ERR_R_X509_LIB);
+ x509_pubkey_ex_free((ASN1_VALUE **)&pubkey,
+ ASN1_ITEM_rptr(X509_PUBKEY_INTERNAL));
+ return NULL;
+ }
+ if ((pubkey->algor = X509_ALGOR_dup(a->algor)) == NULL
+ || (pubkey->public_key = ASN1_BIT_STRING_new()) == NULL
+ || !ASN1_BIT_STRING_set(pubkey->public_key,
+ a->public_key->data,
+ a->public_key->length)) {
x509_pubkey_ex_free((ASN1_VALUE **)&pubkey,
ASN1_ITEM_rptr(X509_PUBKEY_INTERNAL));
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
return NULL;
}
if (pkey->ameth != NULL) {
if ((pk = X509_PUBKEY_new()) == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_ASN1_LIB);
goto error;
}
if (pkey->ameth->pub_encode != NULL) {
pkey = EVP_PKEY_new();
if (pkey == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_EVP_LIB);
return -1;
}
*/
if (libctx != NULL || propq != NULL || force_legacy) {
xpk2 = OPENSSL_zalloc(sizeof(*xpk2));
- if (xpk2 == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if (xpk2 == NULL)
return NULL;
- }
if (!x509_pubkey_set0_libctx(xpk2, libctx, propq))
goto end;
xpk2->flag_force_legacy = !!force_legacy;
return 0;
pktmp = EVP_PKEY_new();
if (pktmp == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
return -1;
}
(void)EVP_PKEY_assign_RSA(pktmp, (RSA *)a);
return 0;
pktmp = EVP_PKEY_new();
if (pktmp == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
return -1;
}
(void)EVP_PKEY_assign_DH(pktmp, (DH *)a);
return 0;
pktmp = EVP_PKEY_new();
if (pktmp == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
return -1;
}
(void)EVP_PKEY_assign(pktmp, EVP_PKEY_DHX, (DH *)a);
return 0;
pktmp = EVP_PKEY_new();
if (pktmp == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
return -1;
}
(void)EVP_PKEY_assign_DSA(pktmp, (DSA *)a);
if (a == NULL)
return 0;
if ((pktmp = EVP_PKEY_new()) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
return -1;
}
(void)EVP_PKEY_assign_EC_KEY(pktmp, (EC_KEY *)a);
if (a == NULL)
return 0;
if ((pktmp = EVP_PKEY_new()) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
return -1;
}
(void)EVP_PKEY_assign(pktmp, EVP_PKEY_ED25519, (ECX_KEY *)a);
if (a == NULL)
return 0;
if ((pktmp = EVP_PKEY_new()) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
return -1;
}
(void)EVP_PKEY_assign(pktmp, EVP_PKEY_ED448, (ECX_KEY *)a);
if (a == NULL)
return 0;
if ((pktmp = EVP_PKEY_new()) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
return -1;
}
(void)EVP_PKEY_assign(pktmp, EVP_PKEY_X25519, (ECX_KEY *)a);
if (a == NULL)
return 0;
if ((pktmp = EVP_PKEY_new()) == NULL) {
- ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_ASN1, ERR_R_EVP_LIB);
return -1;
}
(void)EVP_PKEY_assign(pktmp, EVP_PKEY_X448, (ECX_KEY *)a);
if (pkey != NULL) {
pkey = EVP_PKEY_dup(pkey);
if (pkey == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_X509, ERR_R_EVP_LIB);
return 0;
}
if (!X509_PUBKEY_set(&ret->req_info.pubkey, pkey)) {
/* Allocate requisite combined storage */
*pp = tmp = OPENSSL_malloc(length);
- if (tmp == NULL) {
- ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
+ if (tmp == NULL)
return -1;
- }
/* Encode, but keep *pp at the originally malloced pointer */
length = i2d_x509_aux_internal(a, &tmp);
ctx->storename = tmpstr;
CAPI_trace(ctx, "Setting store name to %s\n", p);
} else {
- CAPIerr(CAPI_F_CAPI_CTRL, ERR_R_MALLOC_FAILURE);
ret = 0;
}
break;
ctx->debug_file = tmpstr;
CAPI_trace(ctx, "Setting debug file to %s\n", ctx->debug_file);
} else {
- CAPIerr(CAPI_F_CAPI_CTRL, ERR_R_MALLOC_FAILURE);
ret = 0;
}
break;
if (capi_idx < 0) {
capi_idx = ENGINE_get_ex_new_index(0, NULL, NULL, NULL, 0);
- if (capi_idx < 0)
- goto memerr;
+ if (capi_idx < 0) {
+ CAPIerr(CAPI_F_CAPI_INIT, ERR_R_ENGINE_LIB);
+ goto err;
+ }
cert_capi_idx = X509_get_ex_new_index(0, NULL, NULL, NULL, 0);
RSA_meth_get_bn_mod_exp(ossl_rsa_meth))
|| !RSA_meth_set_finish(capi_rsa_method, capi_rsa_free)
|| !RSA_meth_set_sign(capi_rsa_method, capi_rsa_sign)) {
- goto memerr;
+ CAPIerr(CAPI_F_CAPI_INIT, ERR_R_RSA_LIB);
+ goto err;
}
# ifndef OPENSSL_NO_DSA
DSA_meth_get_mod_exp(ossl_dsa_meth))
|| !DSA_meth_set_bn_mod_exp(capi_dsa_method,
DSA_meth_get_bn_mod_exp(ossl_dsa_meth))) {
- goto memerr;
+ CAPIerr(CAPI_F_CAPI_INIT, ERR_R_DSA_LIB);
+ goto err;
}
# endif
}
ctx = capi_ctx_new();
- if (ctx == NULL)
- goto memerr;
+ if (ctx == NULL) {
+ CAPIerr(CAPI_F_CAPI_INIT, ERR_R_CAPI_LIB);
+ goto err;
+ }
ENGINE_set_ex_data(e, capi_idx, ctx);
return 1;
- memerr:
- CAPIerr(CAPI_F_CAPI_INIT, ERR_R_MALLOC_FAILURE);
+ err:
return 0;
-
- return 1;
}
static int capi_destroy(ENGINE *e)
pubkey = OPENSSL_malloc(len);
if (pubkey == NULL)
- goto memerr;
+ goto err;
if (!CryptExportKey(key->key, 0, PUBLICKEYBLOB, 0, pubkey, &len)) {
CAPIerr(CAPI_F_CAPI_GET_PKEY, CAPI_R_PUBKEY_EXPORT_ERROR);
}
rsa_modulus = (unsigned char *)(rp + 1);
rkey = RSA_new_method(eng);
- if (!rkey)
- goto memerr;
+ if (!rkey) {
+ CAPIerr(CAPI_F_CAPI_GET_PKEY, ERR_R_RSA_LIB);
+ goto err;
+ }
e = BN_new();
n = BN_new();
if (e == NULL || n == NULL) {
BN_free(e);
BN_free(n);
- goto memerr;
+ CAPIerr(CAPI_F_CAPI_GET_PKEY, ERR_R_BN_LIB);
+ goto err;
}
RSA_set0_key(rkey, n, e, NULL);
- if (!BN_set_word(e, rp->pubexp))
- goto memerr;
+ if (!BN_set_word(e, rp->pubexp)) {
+ CAPIerr(CAPI_F_CAPI_GET_PKEY, ERR_R_BN_LIB);
+ goto err;
+ }
rsa_modlen = rp->bitlen / 8;
- if (!lend_tobn(n, rsa_modulus, rsa_modlen))
- goto memerr;
+ if (!lend_tobn(n, rsa_modulus, rsa_modlen)) {
+ CAPIerr(CAPI_F_CAPI_GET_PKEY, ERR_R_BN_LIB);
+ goto err;
+ }
RSA_set_ex_data(rkey, rsa_capi_idx, key);
- if ((ret = EVP_PKEY_new()) == NULL)
- goto memerr;
+ if ((ret = EVP_PKEY_new()) == NULL) {
+ CAPIerr(CAPI_F_CAPI_GET_PKEY, ERR_R_EVP_LIB);
+ goto err;
+ }
EVP_PKEY_assign_RSA(ret, rkey);
rkey = NULL;
dsa_plen = dp->bitlen / 8;
btmp = (unsigned char *)(dp + 1);
dkey = DSA_new_method(eng);
- if (!dkey)
- goto memerr;
+ if (!dkey) {
+ CAPIerr(CAPI_F_CAPI_GET_PKEY, ERR_R_DSA_LIB);
+ goto err;
+ }
p = BN_new();
q = BN_new();
g = BN_new();
BN_free(q);
BN_free(g);
BN_free(pub_key);
- goto memerr;
+ CAPIerr(CAPI_F_CAPI_GET_PKEY, ERR_R_BN_LIB);
+ goto err;
}
DSA_set0_pqg(dkey, p, q, g);
DSA_set0_key(dkey, pub_key, NULL);
- if (!lend_tobn(p, btmp, dsa_plen))
- goto memerr;
+ if (!lend_tobn(p, btmp, dsa_plen)) {
+ CAPIerr(CAPI_F_CAPI_GET_PKEY, ERR_R_CAPI_LIB);
+ goto err;
+ }
btmp += dsa_plen;
- if (!lend_tobn(q, btmp, 20))
- goto memerr;
+ if (!lend_tobn(q, btmp, 20)) {
+ CAPIerr(CAPI_F_CAPI_GET_PKEY, ERR_R_CAPI_LIB);
+ goto err;
+ }
btmp += 20;
- if (!lend_tobn(g, btmp, dsa_plen))
- goto memerr;
+ if (!lend_tobn(g, btmp, dsa_plen)) {
+ CAPIerr(CAPI_F_CAPI_GET_PKEY, ERR_R_CAPI_LIB);
+ goto err;
+ }
btmp += dsa_plen;
- if (!lend_tobn(pub_key, btmp, dsa_plen))
- goto memerr;
+ if (!lend_tobn(pub_key, btmp, dsa_plen)) {
+ CAPIerr(CAPI_F_CAPI_GET_PKEY, ERR_R_CAPI_LIB);
+ goto err;
+ }
btmp += dsa_plen;
DSA_set_ex_data(dkey, dsa_capi_idx, key);
- if ((ret = EVP_PKEY_new()) == NULL)
- goto memerr;
+ if ((ret = EVP_PKEY_new()) == NULL) {
+ CAPIerr(CAPI_F_CAPI_GET_PKEY, ERR_R_EVP_LIB);
+ goto err;
+ }
EVP_PKEY_assign_DSA(ret, dkey);
dkey = NULL;
}
return ret;
-
- memerr:
- CAPIerr(CAPI_F_CAPI_GET_PKEY, ERR_R_MALLOC_FAILURE);
- goto err;
-
}
static EVP_PKEY *capi_load_privkey(ENGINE *eng, const char *key_id,
}
/* Create temp reverse order version of input */
- if ((tmpbuf = OPENSSL_malloc(flen)) == NULL) {
- CAPIerr(CAPI_F_CAPI_RSA_PRIV_DEC, ERR_R_MALLOC_FAILURE);
+ if ((tmpbuf = OPENSSL_malloc(flen)) == NULL)
return -1;
- }
for (i = 0; i < flen; i++)
tmpbuf[flen - i - 1] = from[i];
return NULL;
}
str = OPENSSL_malloc(sz);
- if (str == NULL) {
- CAPIerr(CAPI_F_WIDE_TO_ASC, ERR_R_MALLOC_FAILURE);
+ if (str == NULL)
return NULL;
- }
if (!WideCharToMultiByte(CP_ACP, 0, wstr, len_0, str, sz, NULL, NULL)) {
OPENSSL_free(str);
CAPIerr(CAPI_F_WIDE_TO_ASC, CAPI_R_WIN32_ERROR);
return 0;
}
name = OPENSSL_malloc(len);
- if (name == NULL) {
- CAPIerr(CAPI_F_CAPI_GET_PROVNAME, ERR_R_MALLOC_FAILURE);
+ if (name == NULL)
return 0;
- }
if (!CryptEnumProviders(idx, NULL, 0, ptype, name, &len)) {
err = GetLastError();
OPENSSL_free(name);
if (buflen == 0)
buflen = 1024;
cname = OPENSSL_malloc(buflen);
- if (cname == NULL) {
- CAPIerr(CAPI_F_CAPI_LIST_CONTAINERS, ERR_R_MALLOC_FAILURE);
+ if (cname == NULL)
goto err;
- }
for (idx = 0;; idx++) {
clen = buflen;
NULL, &len))
return NULL;
pinfo = OPENSSL_malloc(len);
- if (pinfo == NULL) {
- CAPIerr(CAPI_F_CAPI_GET_PROV_INFO, ERR_R_MALLOC_FAILURE);
+ if (pinfo == NULL)
return NULL;
- }
if (!CertGetCertificateContextProperty(cert, CERT_KEY_PROV_INFO_PROP_ID,
pinfo, &len)) {
CAPIerr(CAPI_F_CAPI_GET_PROV_INFO,
{
CAPI_CTX *ctx = OPENSSL_zalloc(sizeof(*ctx));
- if (ctx == NULL) {
- CAPIerr(CAPI_F_CAPI_CTX_NEW, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL)
return NULL;
- }
ctx->csptype = PROV_RSA_FULL;
ctx->dump_flags = CAPI_DMP_SUMMARY | CAPI_DMP_FNAME;
ctx->keytype = AT_KEYEXCHANGE;
CryptReleaseContext(hprov, 0);
}
tmpcspname = OPENSSL_strdup(pname);
- if (tmpcspname == NULL) {
- CAPIerr(CAPI_F_CAPI_CTX_SET_PROVNAME, ERR_R_MALLOC_FAILURE);
+ if (tmpcspname == NULL)
return 0;
- }
OPENSSL_free(ctx->cspname);
ctx->cspname = tmpcspname;
ctx->csptype = type;
&& EVP_CIPHER_impl_ctx_size(cipher) != 0) {
pipe_ctx->inner_cipher_data = OPENSSL_zalloc(
EVP_CIPHER_impl_ctx_size(cipher));
- if (pipe_ctx->inner_cipher_data == NULL) {
- DASYNCerr(DASYNC_F_DASYNC_CIPHER_INIT_KEY_HELPER,
- ERR_R_MALLOC_FAILURE);
+ if (pipe_ctx->inner_cipher_data == NULL)
return 0;
- }
}
pipe_ctx->numpipes = 0;
char *prompt = NULL;
if (ui == NULL) {
- ATTICerr(0, ERR_R_MALLOC_FAILURE);
+ ATTICerr(0, ERR_R_UI_LIB);
return NULL;
}
UI_add_user_data(ui, data);
if ((prompt = UI_construct_prompt(ui, desc, info)) == NULL) {
- ATTICerr(0, ERR_R_MALLOC_FAILURE);
+ ATTICerr(0, ERR_R_UI_LIB);
pass = NULL;
} else if (UI_add_input_string(ui, prompt, UI_INPUT_FLAG_DEFAULT_PWD,
pass, 0, maxsize - 1) <= 0) {
OSSL_STORE_INFO *info = NULL;
struct embedded_st *data = NULL;
- if ((data = OPENSSL_zalloc(sizeof(*data))) == NULL
- || (info = OSSL_STORE_INFO_new(STORE_INFO_EMBEDDED, data)) == NULL) {
- ATTICerr(0, ERR_R_MALLOC_FAILURE);
+ if ((data = OPENSSL_zalloc(sizeof(*data))) == NULL)
+ return NULL;
+ if ((info = OSSL_STORE_INFO_new(STORE_INFO_EMBEDDED, data)) == NULL) {
+ ATTICerr(0, ERR_R_OSSL_STORE_LIB);
OPENSSL_free(data);
return NULL;
}
new_pem_name == NULL ? NULL : OPENSSL_strdup(new_pem_name);
if (new_pem_name != NULL && data->pem_name == NULL) {
- ATTICerr(0, ERR_R_MALLOC_FAILURE);
store_info_free(info);
info = NULL;
}
*matchcount = 1;
if ((mem = BUF_MEM_new()) == NULL) {
- ATTICerr(0, ERR_R_MALLOC_FAILURE);
+ ATTICerr(0, ERR_R_BUF_LIB);
goto nop8;
}
store_info = new_EMBEDDED(PEM_STRING_PKCS8INF, mem);
if (store_info == NULL) {
- ATTICerr(0, ERR_R_MALLOC_FAILURE);
+ ATTICerr(0, ERR_R_OSSL_STORE_LIB);
goto nop8;
}
/* Successfully found a working path */
ctx = OPENSSL_zalloc(sizeof(*ctx));
- if (ctx == NULL) {
- ATTICerr(0, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL)
return NULL;
- }
ctx->uri = OPENSSL_strdup(uri);
- if (ctx->uri == NULL) {
- ATTICerr(0, ERR_R_MALLOC_FAILURE);
+ if (ctx->uri == NULL)
goto err;
- }
if (S_ISDIR(st.st_mode)) {
ctx->type = is_dir;
}
if (propq != NULL) {
ctx->propq = OPENSSL_strdup(propq);
- if (ctx->propq == NULL) {
- ATTICerr(0, ERR_R_MALLOC_FAILURE);
+ if (ctx->propq == NULL)
goto err;
- }
}
ctx->libctx = libctx;
if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL
|| (propq != NULL && (ctx->propq = OPENSSL_strdup(propq)) == NULL)) {
- ATTICerr(0, ERR_R_MALLOC_FAILURE);
OSSL_STORE_LOADER_CTX_free(ctx);
return NULL;
}
OPENSSL_zalloc(sizeof(*matching_handlers)
* OSSL_NELEM(file_handlers));
- if (matching_handlers == NULL) {
- ATTICerr(0, ERR_R_MALLOC_FAILURE);
+ if (matching_handlers == NULL)
goto err;
- }
*matchcount = 0;
for (i = 0; i < OSSL_NELEM(file_handlers); i++) {
+ strlen(name) + 1 /* \0 */;
*data = OPENSSL_zalloc(calculated_length);
- if (*data == NULL) {
- ATTICerr(0, ERR_R_MALLOC_FAILURE);
+ if (*data == NULL)
return 0;
- }
OPENSSL_strlcat(*data, ctx->uri, calculated_length);
OPENSSL_strlcat(*data, pathsep, calculated_length);
/*
* Generated by util/mkerr.pl DO NOT EDIT
- * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2020-2022 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
/*
* Generated by util/mkerr.pl DO NOT EDIT
- * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
# define DH_R_INVALID_PARAMETER_NID 114
# define DH_R_INVALID_PUBKEY 102
# define DH_R_INVALID_SECRET 128
+# define DH_R_INVALID_SIZE 129
# define DH_R_KDF_PARAMETER_ERROR 112
# define DH_R_KEYS_NOT_SET 108
# define DH_R_MISSING_PUBKEY 125
# define ERR_R_DSA_LIB (ERR_LIB_DSA/* 10 */ | ERR_RFLAG_COMMON)
# define ERR_R_X509_LIB (ERR_LIB_X509/* 11 */ | ERR_RFLAG_COMMON)
# define ERR_R_ASN1_LIB (ERR_LIB_ASN1/* 13 */ | ERR_RFLAG_COMMON)
+# define ERR_R_CONF_LIB (ERR_LIB_CONF/* 14 */ | ERR_RFLAG_COMMON)
# define ERR_R_CRYPTO_LIB (ERR_LIB_CRYPTO/* 15 */ | ERR_RFLAG_COMMON)
# define ERR_R_EC_LIB (ERR_LIB_EC/* 16 */ | ERR_RFLAG_COMMON)
+# define ERR_R_SSL_LIB (ERR_LIB_SSL/* 20 */ | ERR_RFLAG_COMMON)
# define ERR_R_BIO_LIB (ERR_LIB_BIO/* 32 */ | ERR_RFLAG_COMMON)
# define ERR_R_PKCS7_LIB (ERR_LIB_PKCS7/* 33 */ | ERR_RFLAG_COMMON)
# define ERR_R_X509V3_LIB (ERR_LIB_X509V3/* 34 */ | ERR_RFLAG_COMMON)
+# define ERR_R_PKCS12_LIB (ERR_LIB_PKCS12/* 35 */ | ERR_RFLAG_COMMON)
+# define ERR_R_RAND_LIB (ERR_LIB_RAND/* 36 */ | ERR_RFLAG_COMMON)
+# define ERR_R_DSO_LIB (ERR_LIB_DSO/* 37 */ | ERR_RFLAG_COMMON)
# define ERR_R_ENGINE_LIB (ERR_LIB_ENGINE/* 38 */ | ERR_RFLAG_COMMON)
# define ERR_R_UI_LIB (ERR_LIB_UI/* 40 */ | ERR_RFLAG_COMMON)
# define ERR_R_ECDSA_LIB (ERR_LIB_ECDSA/* 42 */ | ERR_RFLAG_COMMON)
# define ERR_R_OSSL_STORE_LIB (ERR_LIB_OSSL_STORE/* 44 */ | ERR_RFLAG_COMMON)
+# define ERR_R_CMS_LIB (ERR_LIB_CMS/* 46 */ | ERR_RFLAG_COMMON)
+# define ERR_R_TS_LIB (ERR_LIB_TS/* 47 */ | ERR_RFLAG_COMMON)
+# define ERR_R_CT_LIB (ERR_LIB_CT/* 50 */ | ERR_RFLAG_COMMON)
+# define ERR_R_PROV_LIB (ERR_LIB_PROV/* 57 */ | ERR_RFLAG_COMMON)
+# define ERR_R_ESS_LIB (ERR_LIB_ESS/* 54 */ | ERR_RFLAG_COMMON)
+# define ERR_R_CMP_LIB (ERR_LIB_CMP/* 58 */ | ERR_RFLAG_COMMON)
+# define ERR_R_OSSL_ENCODER_LIB (ERR_LIB_OSSL_ENCODER/* 59 */ | ERR_RFLAG_COMMON)
# define ERR_R_OSSL_DECODER_LIB (ERR_LIB_OSSL_DECODER/* 60 */ | ERR_RFLAG_COMMON)
/* Other common error codes, range 256..2^ERR_RFLAGS_OFFSET-1 */
unsigned char **dest, size_t *dest_len)
{
if (src != NULL) {
- if ((*dest = OPENSSL_memdup(src, src_len)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((*dest = OPENSSL_memdup(src, src_len)) == NULL)
return 0;
- }
*dest_len = src_len;
} else {
*dest = NULL;
int rsasize = RSA_size(prsactx->rsa);
unsigned char *tbuf;
- if ((tbuf = OPENSSL_malloc(rsasize)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((tbuf = OPENSSL_malloc(rsasize)) == NULL)
return 0;
- }
if (prsactx->oaep_md == NULL) {
OPENSSL_free(tbuf);
prsactx->oaep_md = EVP_MD_fetch(prsactx->libctx, "SHA-1", NULL);
|| prsactx->pad_mode == RSA_PKCS1_WITH_TLS_PADDING) {
unsigned char *tbuf;
- if ((tbuf = OPENSSL_malloc(len)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((tbuf = OPENSSL_malloc(len)) == NULL)
return 0;
- }
ret = RSA_private_decrypt(inlen, in, tbuf, prsactx->rsa,
RSA_NO_PADDING);
/*
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
in->base.hw->copyctx(&ret->base, &in->base);
return ret;
return NULL;
ret = OPENSSL_memdup(in, sizeof(*in));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
/* NULL-out these things we create later */
ret->aad = NULL;
ret->ecb_ctx = NULL;
if (in->aad == NULL) {
- if ((ret->aad = OPENSSL_memdup(in->aad, UP16(ret->aad_len))) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((ret->aad = OPENSSL_memdup(in->aad, UP16(ret->aad_len))) == NULL)
goto err;
- }
}
if (!in->hw->dup_ctx(ret, in))
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
*ret = *in;
if (!aes_generic_ocb_copy_ctx(ret, in)) {
OPENSSL_free(ret);
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
if (!in->hw->dupctx(in, ret)) {
OPENSSL_free(ret);
ret = NULL;
return NULL;
}
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
in->base.hw->copyctx(&ret->base, &in->base);
return ret;
}
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
in->base.hw->copyctx(&ret->base, &in->base);
return ret;
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
*ret = *in;
return ret;
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
in->base.hw->copyctx(&ret->base, &in->base);
return ret;
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
*ret = *in;
return ret;
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
in->base.hw->copyctx(&ret->base, &in->base);
return ret;
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
*ret = *in;
return ret;
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
*ret = *in;
return ret;
return 0;
}
if ((type = ASN1_TYPE_new()) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_ASN1_LIB);
return 0;
}
if (!ASN1_TYPE_set_int_octetstring(type, num,
ctx->base.iv, ctx->base.ivlen)) {
ASN1_TYPE_free(type);
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_ASN1_LIB);
return 0;
}
/*
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
*ret = *in;
return ret;
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
*ret = *in;
return ret;
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
*ret = *in;
return ret;
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
in->base.hw->copyctx(&ret->base, &in->base);
return ret;
return NULL;
ret = OPENSSL_malloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
in->base.hw->copyctx(&ret->base, &in->base);
return ret;
goto next;
}
buf = OPENSSL_malloc(length);
- if (buf == NULL) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ if (buf == NULL)
goto end;
- }
p = buf;
if (BIO_read(in, buf, length) != (int)length) {
ERR_raise(ERR_LIB_PEM, PEM_R_KEYBLOB_TOO_SHORT);
|| (derlen = k2d(key, &der)) <= 0
|| !PKCS8_pkey_set0(p8info, OBJ_nid2obj(key_nid), 0,
params_type, params, der, derlen)) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_ASN1_LIB);
PKCS8_PRIV_KEY_INFO_free(p8info);
OPENSSL_free(der);
p8info = NULL;
|| (derlen = k2d(key, &der)) <= 0
|| !X509_PUBKEY_set0_param(xpk, OBJ_nid2obj(key_nid),
params_type, params, der, derlen)) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_X509_LIB);
X509_PUBKEY_free(xpk);
OPENSSL_free(der);
xpk = NULL;
int ret;
if ((derlen = k2d(key, &der)) <= 0) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_PROV_LIB);
return 0;
}
ASN1_STRING *params = ASN1_STRING_new();
if (params == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_ASN1_LIB);
return 0;
}
params->length = i2d_DHparams(dh, ¶ms->data);
if (params->length <= 0) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_ASN1_LIB);
ASN1_STRING_free(params);
return 0;
}
ASN1_STRING *params = ASN1_STRING_new();
if (params == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_ASN1_LIB);
return 0;
}
params->length = i2d_DSAparams(dsa, ¶ms->data);
if (params->length <= 0) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_ASN1_LIB);
ASN1_STRING_free(params);
return 0;
}
ASN1_STRING *params = ASN1_STRING_new();
if (params == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_ASN1_LIB);
return 0;
}
params->length = i2d_ECParameters(eckey, ¶ms->data);
if (params->length <= 0) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_ASN1_LIB);
ASN1_STRING_free(params);
return 0;
}
}
keyblob = OPENSSL_memdup(ecxkey->pubkey, ecxkey->keylen);
- if (keyblob == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (keyblob == NULL)
return 0;
- }
*pder = keyblob;
return ecxkey->keylen;
keybloblen = i2d_ASN1_OCTET_STRING(&oct, pder);
if (keybloblen < 0) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_ASN1_LIB);
return 0;
}
coeffs = sk_BIGNUM_const_new_null();
if (factors == NULL || exps == NULL || coeffs == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_CRYPTO_LIB);
goto err;
}
}
if (!dh_plain_derive(pdhctx, NULL, &stmplen, 0, 1))
return 0;
- if ((stmp = OPENSSL_secure_malloc(stmplen)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((stmp = OPENSSL_secure_malloc(stmplen)) == NULL)
return 0;
- }
if (!dh_plain_derive(pdhctx, stmp, &stmplen, stmplen, 1))
goto err;
ctx = BN_CTX_new_ex(ossl_ec_key_get_libctx(priv));
if (ctx == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_BN_LIB);
return 0;
}
ret = group_priv != NULL
}
if (!ecdh_plain_derive(vpecdhctx, NULL, &stmplen, 0))
return 0;
- if ((stmp = OPENSSL_secure_malloc(stmplen)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((stmp = OPENSSL_secure_malloc(stmplen)) == NULL)
return 0;
- }
if (!ecdh_plain_derive(vpecdhctx, stmp, &stmplen, stmplen))
goto err;
return NULL;
ctx = OPENSSL_zalloc(sizeof(PROV_ECX_CTX));
- if (ctx == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL)
return NULL;
- }
ctx->keylen = keylen;
return NULL;
dstctx = OPENSSL_zalloc(sizeof(*srcctx));
- if (dstctx == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (dstctx == NULL)
return NULL;
- }
*dstctx = *srcctx;
if (dstctx->key != NULL && !ossl_ecx_key_up_ref(dstctx->key)) {
if (!ossl_prov_is_running())
return NULL;
- if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
- else
+ if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) != NULL)
ctx->provctx = provctx;
return ctx;
}
return NULL;
ctx = OPENSSL_zalloc(sizeof(*ctx));
- if (ctx == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL)
return NULL;
- }
ctx->provctx = provctx;
init(ctx);
if (!ossl_prov_is_running())
return NULL;
- if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
return NULL;
- }
ctx->provctx = provctx;
return ctx;
}
ctx = EVP_MD_CTX_new();
if (ctx == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_EVP_LIB);
goto err;
}
return NULL;
ctx = OPENSSL_zalloc(sizeof(*ctx));
- if (ctx == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL)
return NULL;
- }
ctx->provctx = provctx;
return ctx;
}
*buflen = 0;
if (p->data_size == 0) {
- if ((*buffer = OPENSSL_malloc(1)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((*buffer = OPENSSL_malloc(1)) == NULL)
return 0;
- }
} else if (p->data != NULL) {
if (!OSSL_PARAM_get_octet_string(p, (void **)buffer, 0, buflen))
return 0;
return NULL;
ctx = OPENSSL_zalloc(sizeof(*ctx));
- if (ctx == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL)
return NULL;
- }
ctx->provctx = provctx;
return ctx;
}
*buflen = 0;
if (p->data_size == 0) {
- if ((*buffer = OPENSSL_malloc(1)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((*buffer = OPENSSL_malloc(1)) == NULL)
return 0;
- }
} else if (p->data != NULL) {
if (!OSSL_PARAM_get_octet_string(p, (void **)buffer, 0, buflen))
return 0;
ctx = EVP_MD_CTX_new();
if (ctx == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_EVP_LIB);
goto end;
}
vi = EVP_MD_get_block_size(md_type);
Plen = 0;
Ilen = Slen + Plen;
I = OPENSSL_malloc(Ilen);
- if (D == NULL || Ai == NULL || B == NULL || I == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (D == NULL || Ai == NULL || B == NULL || I == NULL)
goto end;
- }
for (i = 0; i < v; i++)
D[i] = id;
p = I;
return NULL;
ctx = OPENSSL_zalloc(sizeof(*ctx));
- if (ctx == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL)
return NULL;
- }
ctx->provctx = provctx;
return ctx;
}
*buflen = 0;
if (p->data_size == 0) {
- if ((*buffer = OPENSSL_malloc(1)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((*buffer = OPENSSL_malloc(1)) == NULL)
return 0;
- }
} else if (p->data != NULL) {
if (!OSSL_PARAM_get_octet_string(p, (void **)buffer, 0, buflen))
return 0;
return NULL;
ctx = OPENSSL_zalloc(sizeof(*ctx));
- if (ctx == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL)
return NULL;
- }
ctx->provctx = provctx;
kdf_pvk_init(ctx);
return ctx;
*buflen = 0;
if (p->data_size == 0) {
- if ((*buffer = OPENSSL_malloc(1)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((*buffer = OPENSSL_malloc(1)) == NULL)
return 0;
- }
} else if (p->data != NULL) {
if (!OSSL_PARAM_get_octet_string(p, (void **)buffer, 0, buflen))
return 0;
return NULL;
ctx = OPENSSL_zalloc(sizeof(*ctx));
- if (ctx == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ctx == NULL)
return NULL;
- }
ctx->libctx = libctx;
kdf_scrypt_init(ctx);
return ctx;
*buflen = 0;
if (p->data_size == 0) {
- if ((*buffer = OPENSSL_malloc(1)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((*buffer = OPENSSL_malloc(1)) == NULL)
return 0;
- }
} else if (p->data != NULL) {
if (!OSSL_PARAM_get_octet_string(p, (void **)buffer, 0, buflen))
return 0;
ctx->propq = NULL;
if (propq != NULL) {
ctx->propq = OPENSSL_strdup(propq);
- if (ctx->propq == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ctx->propq == NULL)
return 0;
- }
}
return 1;
}
return 1;
B = OPENSSL_malloc((size_t)(Blen + Vlen));
- if (B == NULL) {
- ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
+ if (B == NULL)
return 0;
- }
X = (uint32_t *)(B + Blen);
T = X + 32 * r;
V = T + 32 * r;
if (!ossl_prov_is_running())
return NULL;
- if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
- else
+ if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) != NULL)
ctx->provctx = provctx;
return ctx;
}
if (!ossl_prov_is_running())
return NULL;
- if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
- ctx->provctx = provctx;
+ if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) != NULL)
+ ctx->provctx = provctx;
return ctx;
}
/* If no salt is set then use a default_salt of zeros */
if (ctx->salt == NULL || ctx->salt_len <= 0) {
ctx->salt = OPENSSL_zalloc(default_salt_len);
- if (ctx->salt == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ctx->salt == NULL)
return 0;
- }
ctx->salt_len = default_salt_len;
}
ret = SSKDF_mac_kdm(ctx->macctx,
if (!ossl_prov_is_running())
return NULL;
- if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
- return NULL;
- }
- ctx->provctx = provctx;
+ if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) != NULL)
+ ctx->provctx = provctx;
return ctx;
}
seed, seed_len, out, olen))
return 0;
- if ((tmp = OPENSSL_malloc(olen)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((tmp = OPENSSL_malloc(olen)) == NULL)
return 0;
- }
if (!tls1_prf_P_hash(sha1ctx, sec + slen - L_S2, L_S2,
seed, seed_len, tmp, olen)) {
if (!ossl_prov_is_running())
return NULL;
- if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL)
return NULL;
- }
ctx->provctx = provctx;
ctx->use_keybits = 1;
return ctx;
return gctx;
if ((gctx->group_name = OPENSSL_strdup("sm2")) != NULL)
return gctx;
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
ec_gen_cleanup(gctx);
}
return NULL;
ecxkey->propq = NULL;
if (propq != NULL) {
ecxkey->propq = OPENSSL_strdup(propq);
- if (ecxkey->propq == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ecxkey->propq == NULL)
return 0;
- }
}
return 1;
}
return NULL;
if ((key = ossl_ecx_key_new(gctx->libctx, gctx->type, 0,
gctx->propq)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_EC_LIB);
return NULL;
}
return key;
if ((privkey = ossl_ecx_key_allocate_privkey(key)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_EC_LIB);
goto err;
}
#ifndef FIPS_MODULE
unsigned char *privkey = NULL, *pubkey;
if (key == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_EC_LIB);
goto err;
}
privkey = ossl_ecx_key_allocate_privkey(key);
if (privkey == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_EC_LIB);
goto err;
}
unsigned char *privkey = NULL, *pubkey;
if (key == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_EC_LIB);
goto err;
}
privkey = ossl_ecx_key_allocate_privkey(key);
if (privkey == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_EC_LIB);
goto err;
}
int j;
if (key == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_EC_LIB);
goto err;
}
privkey = ossl_ecx_key_allocate_privkey(key);
if (privkey == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_EC_LIB);
goto err;
}
EVP_MD *shake = NULL;
if (key == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_EC_LIB);
goto err;
}
privkey = ossl_ecx_key_allocate_privkey(key);
if (privkey == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_EC_LIB);
goto err;
}
OPENSSL_secure_clear_free(key->priv_key, key->priv_key_len);
/* allocate at least one byte to distinguish empty key from no key set */
key->priv_key = OPENSSL_secure_malloc(p->data_size > 0 ? p->data_size : 1);
- if (key->priv_key == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (key->priv_key == NULL)
return 0;
- }
memcpy(key->priv_key, p->data, p->data_size);
key->priv_key_len = p->data_size;
}
}
OPENSSL_free(key->properties);
key->properties = OPENSSL_strdup(p->data);
- if (key->properties == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (key->properties == NULL)
return 0;
- }
}
if (key->cmac && !ossl_prov_cipher_load_from_params(&key->cipher, params,
return 0;
}
gctx->priv_key = OPENSSL_secure_malloc(p->data_size);
- if (gctx->priv_key == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (gctx->priv_key == NULL)
return 0;
- }
memcpy(gctx->priv_key, p->data, p->data_size);
gctx->priv_key_len = p->data_size;
}
return NULL;
if ((key = ossl_mac_key_new(gctx->libctx, 0)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_PROV_LIB);
return NULL;
}
return 0;
}
out = OPENSSL_malloc(out_len);
- if (out == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (out == NULL)
return 0;
- }
res = bytepad(out, NULL, kmac_string, sizeof(kmac_string),
kctx->custom, kctx->custom_len, block_len)
&& EVP_DigestUpdate(ctx, out, out_len)
/* Allocate storage */
buffer = OPENSSL_secure_malloc(bytes_needed);
- if (buffer == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (buffer == NULL)
return 0;
- }
/*
* Get random data. Include our DRBG address as
return NULL;
drbg = OPENSSL_zalloc(sizeof(*drbg));
- if (drbg == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (drbg == NULL)
return NULL;
- }
drbg->provctx = provctx;
drbg->instantiate = instantiate;
if (ctr->ctx_ctr == NULL)
ctr->ctx_ctr = EVP_CIPHER_CTX_new();
if (ctr->ctx_ecb == NULL || ctr->ctx_ctr == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_EVP_LIB);
goto err;
}
if (ctr->ctx_df == NULL)
ctr->ctx_df = EVP_CIPHER_CTX_new();
if (ctr->ctx_df == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_EVP_LIB);
goto err;
}
/* Set key schedule for df_key */
PROV_DRBG_CTR *ctr;
ctr = OPENSSL_secure_zalloc(sizeof(*ctr));
- if (ctr == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (ctr == NULL)
return 0;
- }
ctr->use_df = 1;
drbg->data = ctr;
ERR_raise(ERR_LIB_PROV, PROV_R_REQUIRE_CTR_MODE_CIPHER);
return 0;
}
- if ((ecb = OPENSSL_strndup(base, p->data_size)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((ecb = OPENSSL_strndup(base, p->data_size)) == NULL)
return 0;
- }
strcpy(ecb + p->data_size - ecb_str_len, "ECB");
EVP_CIPHER_free(ctr->cipher_ecb);
EVP_CIPHER_free(ctr->cipher_ctr);
PROV_DRBG_HASH *hash;
hash = OPENSSL_secure_zalloc(sizeof(*hash));
- if (hash == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (hash == NULL)
return 0;
- }
ctx->data = hash;
ctx->seedlen = HASH_PRNG_MAX_SEEDLEN;
PROV_DRBG_HMAC *hmac;
hmac = OPENSSL_secure_zalloc(sizeof(*hmac));
- if (hmac == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (hmac == NULL)
return 0;
- }
drbg->data = hmac;
/* See SP800-57 Part1 Rev4 5.6.1 Table 3 */
}
s = OPENSSL_zalloc(sizeof(*s));
- if (s == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (s == NULL)
return NULL;
- }
s->provctx = provctx;
s->state = EVP_RAND_STATE_UNINITIALISED;
pool = ossl_rand_pool_new(strength, 1, outlen, outlen);
if (pool == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_RAND_LIB);
return 0;
}
}
p = OPENSSL_secure_malloc(bytes_needed);
- if (p == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (p == NULL)
return 0;
- }
if (seed_src_generate(vseed, p, bytes_needed, 0, prediction_resistance,
adin, adin_len) != 0) {
*pout = p;
if (propq != NULL && (pdsactx->propq = OPENSSL_strdup(propq)) == NULL) {
OPENSSL_free(pdsactx);
pdsactx = NULL;
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
}
return pdsactx;
}
if (propq != NULL && (ctx->propq = OPENSSL_strdup(propq)) == NULL) {
OPENSSL_free(ctx);
ctx = NULL;
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
}
return ctx;
}
return NULL;
peddsactx = OPENSSL_zalloc(sizeof(PROV_EDDSA_CTX));
- if (peddsactx == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (peddsactx == NULL)
return NULL;
- }
peddsactx->libctx = PROV_LIBCTX_OF(provctx);
return NULL;
pmacctx->libctx = PROV_LIBCTX_OF(provctx);
- if (propq != NULL && (pmacctx->propq = OPENSSL_strdup(propq)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (propq != NULL && (pmacctx->propq = OPENSSL_strdup(propq)) == NULL)
goto err;
- }
mac = EVP_MAC_fetch(pmacctx->libctx, macname, propq);
if (mac == NULL)
|| (propq != NULL
&& (propq_copy = OPENSSL_strdup(propq)) == NULL)) {
OPENSSL_free(prsactx);
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
return NULL;
}
int ret;
if (!WPACKET_init_der(&pkt, aid_buf, buf_len)) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_CRYPTO_LIB);
return NULL;
}
{
if (ctx->tbuf != NULL)
return 1;
- if ((ctx->tbuf = OPENSSL_malloc(RSA_size(ctx->rsa))) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if ((ctx->tbuf = OPENSSL_malloc(RSA_size(ctx->rsa))) == NULL)
return 0;
- }
return 1;
}
return 0;
}
if (!setup_tbuf(prsactx)) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_PROV_LIB);
return 0;
}
memcpy(prsactx->tbuf, tbs, tbslen);
return NULL;
dstctx = OPENSSL_zalloc(sizeof(*srcctx));
- if (dstctx == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (dstctx == NULL)
return NULL;
- }
*dstctx = *srcctx;
dstctx->rsa = NULL;
ctx->libctx = PROV_LIBCTX_OF(provctx);
if (propq != NULL && (ctx->propq = OPENSSL_strdup(propq)) == NULL) {
OPENSSL_free(ctx);
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
return NULL;
}
ctx->mdsize = SM3_DIGEST_LENGTH;
struct file_ctx_st *ctx;
if ((ctx = new_file_ctx(IS_FILE, uri, provctx)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_PROV_LIB);
goto err;
}
struct file_ctx_st *ctx;
if ((ctx = new_file_ctx(IS_DIR, uri, provctx)) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_PROV_LIB);
return NULL;
}
/* Setup for this session, so only if not already done */
if (ctx->_.file.decoderctx == NULL) {
if ((ctx->_.file.decoderctx = OSSL_DECODER_CTX_new()) == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_OSSL_DECODER_LIB);
goto err;
}
+ strlen(name) + 1 /* \0 */;
data = OPENSSL_zalloc(calculated_length);
- if (data == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ if (data == NULL)
return NULL;
- }
OPENSSL_strlcat(data, ctx->uri, calculated_length);
OPENSSL_strlcat(data, pathsep, calculated_length);
mem_want = 16; /* The size of the MSBLOB header */
if ((mem = BUF_MEM_new()) == NULL
|| !BUF_MEM_grow(mem, mem_want)) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PEM, ERR_R_BUF_LIB);
goto err;
}
ok = 0;
mem_want = ossl_blob_length(bitlen, isdss, ispub);
if (!BUF_MEM_grow(mem, mem_len + mem_want)) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PEM, ERR_R_BUF_LIB);
goto err;
}
mem_want = 24; /* The size of the PVK header */
if ((mem = BUF_MEM_new()) == NULL
|| !BUF_MEM_grow(mem, mem_want)) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PEM, ERR_R_BUF_LIB);
goto err;
}
ok = 0;
mem_want = saltlen + keylen;
if (!BUF_MEM_grow(mem, mem_len + mem_want)) {
- ERR_raise(ERR_LIB_PEM, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PEM, ERR_R_BUF_LIB);
goto err;
}
ctx->dctx = OSSL_DECODER_CTX_new();
if (ctx->dctx == NULL) {
- ERR_raise(ERR_LIB_PROV, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_PROV, ERR_R_OSSL_DECODER_LIB);
return 0;
}
{
BIO_SSL *bs = OPENSSL_zalloc(sizeof(*bs));
- if (bs == NULL) {
- ERR_raise(ERR_LIB_BIO, ERR_R_MALLOC_FAILURE);
+ if (bs == NULL)
return 0;
- }
BIO_set_init(bi, 0);
BIO_set_data(bi, bs);
/* Clear all flags */
return -1;
}
buf = OPENSSL_malloc(DTLS1_RT_HEADER_LENGTH + SSL3_RT_MAX_PLAIN_LENGTH);
- if (buf == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (buf == NULL)
return -1;
- }
wbuf = RECORD_LAYER_get_wbuf(&s->rlayer)[0].buf;
do {
s->msg_callback_arg);
if ((tmpclient = BIO_ADDR_new()) == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_BIO_LIB);
goto end;
}
{
pitem *item = OPENSSL_malloc(sizeof(*item));
- if (item == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (item == NULL)
return NULL;
- }
memcpy(item->priority, prio64be, sizeof(item->priority));
item->data = data;
{
pqueue *pq = OPENSSL_zalloc(sizeof(*pq));
- if (pq == NULL)
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
-
return pq;
}
}
h = OPENSSL_realloc(pq->heap, new_max * sizeof(*pq->heap));
- if (h == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (h == NULL)
return 0;
- }
pq->heap = h;
e = OPENSSL_realloc(pq->elements, new_max * sizeof(*pq->elements));
- if (e == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (e == NULL)
return 0;
- }
pq->elements = e;
pq->hmax = new_max;
return NULL;
pq = OPENSSL_malloc(sizeof(*pq));
- if (pq == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (pq == NULL)
return NULL;
- }
pq->compare = compare;
pq->hmax = min_nodes;
pq->htop = 0;
pq->elements = OPENSSL_malloc(sizeof(*pq->elements) * min_nodes);
if (pq->heap == NULL || pq->elements == NULL) {
ossl_pqueue_free(pq);
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
return NULL;
}
pqueue_add_freelist(pq, 0);
#ifdef HAVE_ATOMICS
refcount_lock = CRYPTO_THREAD_lock_new();
if (refcount_lock == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
return NULL;
}
#endif
if ((res = OPENSSL_zalloc(sizeof(*res))) == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
CRYPTO_THREAD_lock_free(refcount_lock);
return NULL;
}
|| (*retrl)->processed_rcds.q == NULL) {
dtls_free(*retrl);
*retrl = NULL;
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
return OSSL_RECORD_RETURN_FATAL;
}
return OSSL_RECORD_RETURN_FATAL;
if ((rl->enc_ctx = EVP_CIPHER_CTX_new()) == NULL) {
- RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
return OSSL_RECORD_RETURN_FATAL;
}
* buffers. We assume we're so doomed that we won't even be able
* to send an alert.
*/
- RLAYERfatal(rl, SSL_AD_NO_ALERT, ERR_R_MALLOC_FAILURE);
+ RLAYERfatal(rl, SSL_AD_NO_ALERT, ERR_R_CRYPTO_LIB);
return 0;
}
} else {
* We assume we're so doomed that we won't even be able to send an
* alert.
*/
- RLAYERfatal(rl, SSL_AD_NO_ALERT, ERR_R_MALLOC_FAILURE);
+ RLAYERfatal(rl, SSL_AD_NO_ALERT, ERR_R_CRYPTO_LIB);
return 0;
}
b->buf = p;
if (mac_size > 0) {
macbufs = OPENSSL_zalloc(sizeof(*macbufs) * num_recs);
if (macbufs == NULL) {
- RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
return OSSL_RECORD_RETURN_FATAL;
}
}
*retrl = NULL;
- if (rl == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (rl == NULL)
return OSSL_RECORD_RETURN_FATAL;
- }
/* Loop through all the settings since they must all be understood */
if (settings != NULL) {
{
DTLS_RECORD_LAYER *d;
- if ((d = OPENSSL_malloc(sizeof(*d))) == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if ((d = OPENSSL_malloc(sizeof(*d))) == NULL)
return 0;
- }
rl->d = d;
if (rdata->data == NULL) {
OPENSSL_free(rdata);
pitem_free(item);
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
return -1;
}
/*
* buffers. We assume we're so doomed that we won't even be able
* to send an alert.
*/
- SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_CRYPTO_LIB);
return 0;
}
} else {
m5 = EVP_MD_CTX_new();
s1 = EVP_MD_CTX_new();
if (md5 == NULL || sha1 == NULL || m5 == NULL || s1 == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
}
for (i = 0; (int)i < num; i += MD5_DIGEST_LENGTH) {
if (s->enc_write_ctx != NULL) {
reuse_dd = 1;
} else if ((s->enc_write_ctx = EVP_CIPHER_CTX_new()) == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
} else {
/* make sure it's initialised in case we exit later with an error */
}
dd = s->enc_write_ctx;
if (ssl_replace_hash(&s->write_hash, md) == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB);
goto err;
}
#ifndef OPENSSL_NO_COMP
ssl3_cleanup_key_block(s);
if ((p = OPENSSL_malloc(num)) == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
return 0;
}
BIO *buf = BIO_new(BIO_s_mem());
if (buf == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BIO_LIB);
return 0;
}
ssl3_free_digest_list(s);
s->s3.handshake_dgst = EVP_MD_CTX_new();
if (s->s3.handshake_dgst == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
return 0;
}
ctx = EVP_MD_CTX_new();
if (ctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
return 0;
}
if (!EVP_MD_CTX_copy_ex(ctx, s->s3.handshake_dgst)) {
size_t ret_secret_size = 0;
if (ctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
return 0;
}
for (i = 0; i < 3; i++) {
}
pkdh = ssl_dh_to_pkey(parg);
if (pkdh == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_DH_LIB);
return 0;
}
if (!SSL_set0_tmp_dh_pkey(s, pkdh)) {
}
pkdh = ssl_dh_to_pkey(parg);
if (pkdh == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_DH_LIB);
return 0;
}
if (!SSL_CTX_set0_tmp_dh_pkey(ctx, pkdh)) {
case SSL_CTRL_EXTRA_CHAIN_CERT:
if (ctx->extra_certs == NULL) {
if ((ctx->extra_certs = sk_X509_new_null()) == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
return 0;
}
}
if (!sk_X509_push(ctx->extra_certs, (X509 *)parg)) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
return 0;
}
break;
sctx->propq);
if (pctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
}
if (EVP_PKEY_keygen_init(pctx) <= 0) {
pms = OPENSSL_malloc(pmslen);
if (pms == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
pms = OPENSSL_malloc(pmslen);
if (pms == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
pms = OPENSSL_malloc(pmslen);
ct = OPENSSL_malloc(ctlen);
if (pms == NULL || ct == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
{
CERT *ret = OPENSSL_zalloc(sizeof(*ret));
- if (ret == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->key = &(ret->pkeys[SSL_PKEY_RSA]);
ret->references = 1;
ret->sec_ex = NULL;
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
OPENSSL_free(ret);
return NULL;
}
CERT *ret = OPENSSL_zalloc(sizeof(*ret));
int i;
- if (ret == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (ret == NULL)
return NULL;
- }
ret->references = 1;
ret->key = &ret->pkeys[cert->key - cert->pkeys];
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
OPENSSL_free(ret);
return NULL;
}
if (cpk->chain) {
rpk->chain = X509_chain_up_ref(cpk->chain);
if (!rpk->chain) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
goto err;
}
}
/* Just copy everything. */
ret->pkeys[i].serverinfo =
OPENSSL_malloc(cert->pkeys[i].serverinfo_length);
- if (ret->pkeys[i].serverinfo == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (ret->pkeys[i].serverinfo == NULL)
goto err;
- }
ret->pkeys[i].serverinfo_length = cert->pkeys[i].serverinfo_length;
memcpy(ret->pkeys[i].serverinfo,
cert->pkeys[i].serverinfo, cert->pkeys[i].serverinfo_length);
ctx = X509_STORE_CTX_new_ex(sctx->libctx, sctx->propq);
if (ctx == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
return 0;
}
if (X509_STORE_CTX_get0_chain(ctx) != NULL) {
s->verified_chain = X509_STORE_CTX_get1_chain(ctx);
if (s->verified_chain == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
i = 0;
}
}
ret = sk_X509_NAME_new_reserve(NULL, num);
if (ret == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
return NULL;
}
for (i = 0; i < num; i++) {
name = X509_NAME_dup(sk_X509_NAME_value(sk, i));
if (name == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
sk_X509_NAME_pop_free(ret, X509_NAME_free);
return NULL;
}
LHASH_OF(X509_NAME) *name_hash = lh_X509_NAME_new(xname_hash, xname_cmp);
OSSL_LIB_CTX *prev_libctx = NULL;
- if ((name_hash == NULL) || (in == NULL)) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (name_hash == NULL) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
+ goto err;
+ }
+ if (in == NULL) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_BIO_LIB);
goto err;
}
x = X509_new_ex(libctx, propq);
if (x == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
goto err;
}
if (BIO_read_filename(in, file) <= 0)
if (ret == NULL) {
ret = sk_X509_NAME_new_null();
if (ret == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
goto err;
}
}
in = BIO_new(BIO_s_file());
if (in == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_BIO_LIB);
goto err;
}
xs_ctx = X509_STORE_CTX_new_ex(real_ctx->libctx, real_ctx->propq);
if (xs_ctx == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
goto err;
}
if (!X509_STORE_CTX_init(xs_ctx, chain_store, cpk->x509, untrusted)) {
}
number_uses = OPENSSL_zalloc(sizeof(int) * (max_strength_bits + 1));
- if (number_uses == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (number_uses == NULL)
return 0;
- }
/*
* Now find the strength_bits values actually used
num_of_ciphers = ssl_method->num_ciphers();
co_list = OPENSSL_malloc(sizeof(*co_list) * num_of_ciphers);
- if (co_list == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (co_list == NULL)
return NULL; /* Failure */
- }
ssl_cipher_collect_ciphers(ssl_method, num_of_ciphers,
disabled_mkey, disabled_auth, disabled_enc,
ca_list = OPENSSL_malloc(sizeof(*ca_list) * num_of_alias_max);
if (ca_list == NULL) {
OPENSSL_free(co_list);
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
return NULL; /* Failure */
}
ssl_cipher_collect_aliases(ca_list, num_of_group_aliases,
if (buf == NULL) {
len = 128;
- if ((buf = OPENSSL_malloc(len)) == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if ((buf = OPENSSL_malloc(len)) == NULL)
return NULL;
- }
} else if (len < 128) {
return NULL;
}
}
comp = OPENSSL_malloc(sizeof(*comp));
- if (comp == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (comp == NULL)
return 1;
- }
comp->id = id;
comp->method = cm;
}
if (ssl_comp_methods == NULL || !sk_SSL_COMP_push(ssl_comp_methods, comp)) {
OPENSSL_free(comp);
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
return 1;
}
return 0;
if (mdord == NULL || mdevp == NULL) {
OPENSSL_free(mdord);
OPENSSL_free(mdevp);
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
return 0;
}
to->dane.trecs = sk_danetls_record_new_reserve(NULL, num);
if (to->dane.trecs == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
return 0;
}
int n = ((int)mtype) + 1;
mdevp = OPENSSL_realloc(dctx->mdevp, n * sizeof(*mdevp));
- if (mdevp == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (mdevp == NULL)
return -1;
- }
dctx->mdevp = mdevp;
mdord = OPENSSL_realloc(dctx->mdord, n * sizeof(*mdord));
- if (mdord == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (mdord == NULL)
return -1;
- }
dctx->mdord = mdord;
/* Zero-fill any gaps */
return 0;
}
- if ((t = OPENSSL_zalloc(sizeof(*t))) == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if ((t = OPENSSL_zalloc(sizeof(*t))) == NULL)
return -1;
- }
t->usage = usage;
t->selector = selector;
t->data = OPENSSL_malloc(dlen);
if (t->data == NULL) {
tlsa_free(t);
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
return -1;
}
memcpy(t->data, data, dlen);
if ((dane->certs == NULL &&
(dane->certs = sk_X509_new_null()) == NULL) ||
!sk_X509_push(dane->certs, cert)) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
X509_free(cert);
tlsa_free(t);
return -1;
if (!sk_danetls_record_insert(dane->trecs, t, i)) {
tlsa_free(t);
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
return -1;
}
dane->umask |= DANETLS_USAGE_BIT(usage);
if (!ossl_ssl_init(ssl, ctx, SSL_TYPE_SSL_CONNECTION)) {
OPENSSL_free(s);
s = NULL;
- goto err;
+ goto sslerr;
}
#ifndef OPENSSL_NO_QUIC
/* Shallow copy of the ciphersuites stack */
s->tls13_ciphersuites = sk_SSL_CIPHER_dup(ctx->tls13_ciphersuites);
if (s->tls13_ciphersuites == NULL)
- goto err;
+ goto cerr;
/*
* Earlier library versions used to copy the pointer to the CERT, not
*/
s->cert = ssl_cert_dup(ctx->cert);
if (s->cert == NULL)
- goto err;
+ goto sslerr;
RECORD_LAYER_set_read_ahead(&s->rlayer, ctx->read_ahead);
s->msg_callback = ctx->msg_callback;
s->param = X509_VERIFY_PARAM_new();
if (s->param == NULL)
- goto err;
+ goto asn1err;
X509_VERIFY_PARAM_inherit(s->param, ctx->param);
s->quiet_shutdown = ctx->quiet_shutdown;
s->allow_early_data_cb_data = ctx->allow_early_data_cb_data;
if (!ssl->method->ssl_init(ssl))
- goto err;
+ goto sslerr;
s->server = (ctx->method->ssl_accept == ssl_undefined_function) ? 0 : 1;
if (!SSL_clear(ssl))
- goto err;
+ goto sslerr;
#ifndef OPENSSL_NO_PSK
s->psk_client_callback = ctx->psk_client_callback;
#ifndef OPENSSL_NO_CT
if (!SSL_set_ct_validation_callback(ssl, ctx->ct_validation_callback,
ctx->ct_validation_callback_arg))
- goto err;
+ goto sslerr;
#endif
return ssl;
+ cerr:
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
+ goto err;
+ asn1err:
+ ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
+ goto err;
+ sslerr:
+ ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
err:
SSL_free(ssl);
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
return NULL;
}
dane->trecs = sk_danetls_record_new_null();
if (dane->trecs == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
return -1;
}
return 1;
return 1;
alpn = OPENSSL_memdup(protos, protos_len);
- if (alpn == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (alpn == NULL)
return 1;
- }
OPENSSL_free(ctx->ext.alpn);
ctx->ext.alpn = alpn;
ctx->ext.alpn_len = protos_len;
return 1;
alpn = OPENSSL_memdup(protos, protos_len);
- if (alpn == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (alpn == NULL)
return 1;
- }
OPENSSL_free(sc->ext.alpn);
sc->ext.alpn = alpn;
sc->ext.alpn_len = protos_len;
ret->references = 1;
ret->lock = CRYPTO_THREAD_lock_new();
if (ret->lock == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
- OPENSSL_free(ret);
- return NULL;
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
+ goto err;
}
#ifdef TSAN_REQUIRES_LOCKING
ret->tsan_lock = CRYPTO_THREAD_lock_new();
if (ret->tsan_lock == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
goto err;
}
#endif
ret->session_timeout = meth->get_timeout();
ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
ret->verify_mode = SSL_VERIFY_NONE;
- if ((ret->cert = ssl_cert_new()) == NULL)
+ if ((ret->cert = ssl_cert_new()) == NULL) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
goto err;
+ }
ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp);
- if (ret->sessions == NULL)
+ if (ret->sessions == NULL) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
goto err;
+ }
ret->cert_store = X509_STORE_new();
- if (ret->cert_store == NULL)
+ if (ret->cert_store == NULL) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
goto err;
+ }
#ifndef OPENSSL_NO_CT
ret->ctlog_store = CTLOG_STORE_new_ex(libctx, propq);
- if (ret->ctlog_store == NULL)
+ if (ret->ctlog_store == NULL) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_CT_LIB);
goto err;
+ }
#endif
/* initialize cipher/digest methods table */
if (!ssl_load_ciphers(ret))
- goto err2;
+ goto err;
/* initialise sig algs */
if (!ssl_setup_sig_algs(ret))
- goto err2;
-
+ goto err;
if (!ssl_load_groups(ret))
- goto err2;
+ goto err;
- if (!SSL_CTX_set_ciphersuites(ret, OSSL_default_ciphersuites()))
+ if (!SSL_CTX_set_ciphersuites(ret, OSSL_default_ciphersuites())) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
goto err;
+ }
if (!ssl_create_cipher_list(ret,
ret->tls13_ciphersuites,
OSSL_default_cipher_list(), ret->cert)
|| sk_SSL_CIPHER_num(ret->cipher_list) <= 0) {
ERR_raise(ERR_LIB_SSL, SSL_R_LIBRARY_HAS_NO_CIPHERS);
- goto err2;
+ goto err;
}
ret->param = X509_VERIFY_PARAM_new();
- if (ret->param == NULL)
+ if (ret->param == NULL) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
goto err;
+ }
/*
* If these aren't available from the provider we'll get NULL returns.
ret->md5 = ssl_evp_md_fetch(libctx, NID_md5, propq);
ret->sha1 = ssl_evp_md_fetch(libctx, NID_sha1, propq);
- if ((ret->ca_names = sk_X509_NAME_new_null()) == NULL)
+ if ((ret->ca_names = sk_X509_NAME_new_null()) == NULL) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
goto err;
+ }
- if ((ret->client_ca_names = sk_X509_NAME_new_null()) == NULL)
+ if ((ret->client_ca_names = sk_X509_NAME_new_null()) == NULL) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
goto err;
+ }
- if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data))
+ if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data)) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
goto err;
+ }
if ((ret->ext.secure = OPENSSL_secure_zalloc(sizeof(*ret->ext.secure))) == NULL)
goto err;
ret->options |= SSL_OP_NO_TICKET;
if (RAND_priv_bytes_ex(libctx, ret->ext.cookie_hmac_key,
- sizeof(ret->ext.cookie_hmac_key), 0) <= 0)
+ sizeof(ret->ext.cookie_hmac_key), 0) <= 0) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_RAND_LIB);
goto err;
+ }
#ifndef OPENSSL_NO_SRP
- if (!ssl_ctx_srp_ctx_init_intern(ret))
+ if (!ssl_ctx_srp_ctx_init_intern(ret)) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
goto err;
+ }
#endif
#ifndef OPENSSL_NO_ENGINE
# ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
return ret;
err:
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
- err2:
SSL_CTX_free(ret);
return NULL;
}
if (*dst == NULL) {
*dst = sk_SCT_new_null();
if (*dst == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
goto err;
}
}
ctx = CT_POLICY_EVAL_CTX_new_ex(SSL_CONNECTION_GET_CTX(s)->libctx,
SSL_CONNECTION_GET_CTX(s)->propq);
if (ctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CT_LIB);
goto end;
}
*outlen = 0;
return 1;
}
- if ((present = OPENSSL_malloc(sizeof(*present) * num)) == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if ((present = OPENSSL_malloc(sizeof(*present) * num)) == NULL)
return 0;
- }
for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) {
ext = sc->clienthello->pre_proc_exts + i;
if (ext->present) {
*/
prefix_len = strlen(prefix);
out_len = prefix_len + (2 * parameter_1_len) + (2 * parameter_2_len) + 3;
- if ((out = cursor = OPENSSL_malloc(out_len)) == NULL) {
- SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ if ((out = cursor = OPENSSL_malloc(out_len)) == NULL)
return 0;
- }
strcpy(cursor, prefix);
cursor += prefix_len;
raw = OPENSSL_malloc(numciphers * TLS_CIPHER_LEN);
s->s3.tmp.ciphers_raw = raw;
if (raw == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
return 0;
}
for (s->s3.tmp.ciphers_rawlen = 0;
scsvs = sk_SSL_CIPHER_new_null();
if (sk == NULL || scsvs == NULL) {
if (fatal)
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
else
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
goto err;
}
if ((c->valid && !sk_SSL_CIPHER_push(sk, c)) ||
(!c->valid && !sk_SSL_CIPHER_push(scsvs, c))) {
if (fatal)
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
else
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
goto err;
}
}
}
x = X509_new_ex(ssl->ctx->libctx, ssl->ctx->propq);
if (x == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
goto end;
}
if (type == SSL_FILETYPE_ASN1) {
x = X509_new_ex(ssl->ctx->libctx, ssl->ctx->propq);
if (x == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
return 0;
}
}
x = X509_new_ex(ctx->libctx, ctx->propq);
if (x == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
goto end;
}
if (type == SSL_FILETYPE_ASN1) {
x = X509_new_ex(ctx->libctx, ctx->propq);
if (x == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
return 0;
}
x = X509_new_ex(real_ctx->libctx, real_ctx->propq);
if (x == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
goto end;
}
if (PEM_read_bio_X509_AUX(in, &x, passwd_callback,
while (1) {
ca = X509_new_ex(real_ctx->libctx, real_ctx->propq);
if (ca == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
goto end;
}
if (PEM_read_bio_X509(in, &ca, passwd_callback,
int ret;
sinfo = OPENSSL_malloc(sinfo_length);
- if (sinfo == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (sinfo == NULL)
return 0;
- }
extension_append(SSL_SERVERINFOV1, serverinfo, serverinfo_length, sinfo);
}
new_serverinfo = OPENSSL_realloc(ctx->cert->key->serverinfo,
serverinfo_length);
- if (new_serverinfo == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (new_serverinfo == NULL)
return 0;
- }
ctx->cert->key->serverinfo = new_serverinfo;
memcpy(ctx->cert->key->serverinfo, serverinfo, serverinfo_length);
ctx->cert->key->serverinfo_length = serverinfo_length;
/* Append the decoded extension to the serverinfo buffer */
append_length = extension_append_length(version, extension_length);
tmp = OPENSSL_realloc(serverinfo, serverinfo_length + append_length);
- if (tmp == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (tmp == NULL)
goto end;
- }
serverinfo = tmp;
extension_append(version, extension, extension_length,
serverinfo + serverinfo_length);
if (chain != NULL) {
dup_chain = X509_chain_up_ref(chain);
if (dup_chain == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
goto out;
}
}
return NULL;
ss = OPENSSL_zalloc(sizeof(*ss));
- if (ss == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (ss == NULL)
return NULL;
- }
ss->verify_result = 1; /* avoid 0 (= X509_V_OK) just in case */
ss->references = 1;
ssl_session_calculate_timeout(ss);
ss->lock = CRYPTO_THREAD_lock_new();
if (ss->lock == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
OPENSSL_free(ss);
return NULL;
}
dest->references = 1;
dest->lock = CRYPTO_THREAD_lock_new();
- if (dest->lock == NULL)
+ if (dest->lock == NULL) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
goto err;
+ }
- if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, dest, &dest->ex_data))
+ if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, dest, &dest->ex_data)) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
goto err;
+ }
if (src->peer != NULL) {
- if (!X509_up_ref(src->peer))
+ if (!X509_up_ref(src->peer)) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
goto err;
+ }
dest->peer = src->peer;
}
if (src->peer_chain != NULL) {
dest->peer_chain = X509_chain_up_ref(src->peer_chain);
- if (dest->peer_chain == NULL)
+ if (dest->peer_chain == NULL) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
goto err;
+ }
}
#ifndef OPENSSL_NO_PSK
if (src->psk_identity_hint) {
dest->psk_identity_hint = OPENSSL_strdup(src->psk_identity_hint);
- if (dest->psk_identity_hint == NULL) {
+ if (dest->psk_identity_hint == NULL)
goto err;
- }
}
if (src->psk_identity) {
dest->psk_identity = OPENSSL_strdup(src->psk_identity);
- if (dest->psk_identity == NULL) {
+ if (dest->psk_identity == NULL)
goto err;
- }
}
#endif
if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL_SESSION,
&dest->ex_data, &src->ex_data)) {
+ ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
goto err;
}
if (src->ext.hostname) {
dest->ext.hostname = OPENSSL_strdup(src->ext.hostname);
- if (dest->ext.hostname == NULL) {
+ if (dest->ext.hostname == NULL)
goto err;
- }
}
if (ticket != 0 && src->ext.tick != NULL) {
#ifndef OPENSSL_NO_SRP
if (src->srp_username) {
dest->srp_username = OPENSSL_strdup(src->srp_username);
- if (dest->srp_username == NULL) {
+ if (dest->srp_username == NULL)
goto err;
- }
}
#endif
return dest;
err:
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
SSL_SESSION_free(dest);
return NULL;
}
SSL_SESSION *ss = NULL;
if ((ss = SSL_SESSION_new()) == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB);
return 0;
}
sc->ext.session_ticket = NULL;
sc->ext.session_ticket =
OPENSSL_malloc(sizeof(TLS_SESSION_TICKET_EXT) + ext_len);
- if (sc->ext.session_ticket == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (sc->ext.session_ticket == NULL)
return 0;
- }
if (ext_data != NULL) {
sc->ext.session_ticket->length = ext_len;
num_exts = OSSL_NELEM(ext_defs) + (exts != NULL ? exts->meths_count : 0);
raw_extensions = OPENSSL_zalloc(num_exts * sizeof(*raw_extensions));
if (raw_extensions == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
return 0;
}
s->ext.scts = OPENSSL_malloc(size);
if (s->ext.scts == NULL) {
s->ext.scts_len = 0;
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
return 0;
}
if (!PACKET_copy_bytes(pkt, s->ext.scts, size)) {
SSL_SESSION *new_sess;
if ((new_sess = ssl_session_dup(s->session, 0)) == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB);
return 0;
}
SSL_SESSION_free(s->session);
if (PACKET_remaining(&responder_id_list) > 0) {
s->ext.ocsp.ids = sk_OCSP_RESPID_new_null();
if (s->ext.ocsp.ids == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
return 0;
}
} else {
if (hctx == NULL || pkey == NULL) {
EVP_MD_CTX_free(hctx);
EVP_PKEY_free(pkey);
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
return 0;
}
/* Regular KEX */
skey = ssl_generate_pkey(s, ckey);
if (skey == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB);
return EXT_RETURN_FAIL;
}
s->session_ctx->ext.cookie_hmac_key,
sizeof(s->session_ctx->ext.cookie_hmac_key));
if (hctx == NULL || pkey == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
}
SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if ((s->session->peer_chain = sk_X509_new_null()) == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
certstart = certbytes;
x = X509_new_ex(sctx->libctx, sctx->propq);
if (x == NULL) {
- SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_MALLOC_FAILURE);
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_ASN1_LIB);
goto err;
}
if (d2i_X509(&x, (const unsigned char **)&certbytes,
}
if (!sk_X509_push(s->session->peer_chain, x)) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
x = NULL;
md_ctx = EVP_MD_CTX_new();
if (md_ctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
}
return MSG_PROCESS_ERROR;
}
if (!tls1_process_sigalgs(s)) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB);
return MSG_PROCESS_ERROR;
}
}
* one
*/
if ((new_sess = ssl_session_dup(s->session, 0)) == 0) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB);
goto err;
}
s->session->ext.tick = OPENSSL_malloc(ticklen);
if (s->session->ext.tick == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
if (!PACKET_copy_bytes(pkt, s->session->ext.tick, ticklen)) {
s->ext.ocsp.resp = OPENSSL_malloc(resplen);
if (s->ext.ocsp.resp == NULL) {
s->ext.ocsp.resp_len = 0;
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
return 0;
}
s->ext.ocsp.resp_len = resplen;
tmppsk = OPENSSL_memdup(psk, psklen);
tmpidentity = OPENSSL_strdup(identity);
if (tmppsk == NULL || tmpidentity == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
pmslen = SSL_MAX_MASTER_KEY_LENGTH;
pms = OPENSSL_malloc(pmslen);
if (pms == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
return 0;
}
pms[0] = s->client_version >> 8;
pms[1] = s->client_version & 0xff;
if (RAND_bytes_ex(sctx->libctx, pms + 2, pmslen - 2, 0) <= 0) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_RAND_LIB);
goto err;
}
ckey = ssl_generate_pkey(s, skey);
if (ckey == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB);
goto err;
}
X509_get0_pubkey(peer_cert),
sctx->propq);
if (pkey_ctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
return 0;
}
/*
pmslen = 32;
pms = OPENSSL_malloc(pmslen);
if (pms == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
pmslen = 32;
pms = OPENSSL_malloc(pmslen);
if (pms == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
X509_get0_pubkey(peer_cert),
sctx->propq);
if (pkey_ctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
}
OPENSSL_free(s->session->srp_username);
s->session->srp_username = OPENSSL_strdup(s->srp_ctx.login);
if (s->session->srp_username == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
return 0;
}
#endif
if (pms == NULL && !(s->s3.tmp.new_cipher->algorithm_mkey & SSL_kPSK)) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_PASSED_INVALID_ARGUMENT);
goto err;
}
if (!ssl_generate_master_secret(s, pms, pmslen, 1)) {
unsigned char *buf = NULL;
unsigned char *bitmask = NULL;
- if ((frag = OPENSSL_malloc(sizeof(*frag))) == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if ((frag = OPENSSL_malloc(sizeof(*frag))) == NULL)
return NULL;
- }
if (frag_len) {
if ((buf = OPENSSL_malloc(frag_len)) == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
OPENSSL_free(frag);
return NULL;
}
if (reassembly) {
bitmask = OPENSSL_zalloc(RSMBLY_BITMASK_SIZE(frag_len));
if (bitmask == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
OPENSSL_free(buf);
OPENSSL_free(frag);
return NULL;
mctx = EVP_MD_CTX_new();
if (mctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
}
SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
if (mctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
}
if (pktype == NID_id_GostR3410_2001
|| pktype == NID_id_GostR3410_2012_256
|| pktype == NID_id_GostR3410_2012_512) {
- if ((gost_data = OPENSSL_malloc(len)) == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ if ((gost_data = OPENSSL_malloc(len)) == NULL)
goto err;
- }
BUF_reverse(gost_data, data, len);
data = gost_data;
}
sctx->propq);
if (xs_ctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_X509_LIB);
return 0;
}
if (!X509_STORE_CTX_init(xs_ctx, chain_store, x, NULL)) {
PACKET cadns;
if (ca_sk == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
/* get the CA RDNs */
}
if (!sk_X509_NAME_push(ca_sk, xn)) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
xn = NULL;
unsigned char *tbs = OPENSSL_malloc(tbslen);
if (tbs == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
return 0;
}
memcpy(tbs, s->s3.client_random, SSL3_RANDOM_SIZE);
}
if (md_ctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
}
if (s->s3.tmp.psk == NULL) {
s->s3.tmp.psklen = 0;
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
return 0;
}
outlen = SSL_MAX_MASTER_KEY_LENGTH;
rsa_decrypt = OPENSSL_malloc(outlen);
if (rsa_decrypt == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
return 0;
}
ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, rsa, sctx->propq);
if (ctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
}
OPENSSL_free(s->session->srp_username);
s->session->srp_username = OPENSSL_strdup(s->srp_ctx.login);
if (s->session->srp_username == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
return 0;
}
pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pk, sctx->propq);
if (pkey_ctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
return 0;
}
if (EVP_PKEY_decrypt_init(pkey_ctx) <= 0) {
pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pk, sctx->propq);
if (pkey_ctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
}
if (EVP_PKEY_decrypt_init(pkey_ctx) <= 0) {
s->rlayer.rrlmethod->set_plain_alerts(s->rlayer.rrl, 0);
if ((sk = sk_X509_new_null()) == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
certstart = certbytes;
x = X509_new_ex(sctx->libctx, sctx->propq);
if (x == NULL) {
- SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_X509_LIB);
goto err;
}
if (d2i_X509(&x, (const unsigned char **)&certbytes, l) == NULL) {
}
if (!sk_X509_push(sk, x)) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
x = NULL;
if (s->post_handshake_auth == SSL_PHA_REQUESTED) {
if ((new_sess = ssl_session_dup(s->session, 0)) == 0) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB);
goto err;
}
}
senc = OPENSSL_malloc(slen_full);
if (senc == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
ctx = EVP_CIPHER_CTX_new();
+ if (ctx == NULL) {
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
+ goto err;
+ }
hctx = ssl_hmac_new(tctx);
- if (ctx == NULL || hctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ if (hctx == NULL) {
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB);
goto err;
}
OPENSSL_memdup(s->s3.alpn_selected, s->s3.alpn_selected_len);
if (s->session->ext.alpn_selected == NULL) {
s->session->ext.alpn_selected_len = 0;
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
s->session->ext.alpn_selected_len = s->s3.alpn_selected_len;
if (s->enc_write_ctx != NULL && !SSL_CONNECTION_IS_DTLS(s)) {
reuse_dd = 1;
} else if ((s->enc_write_ctx = EVP_CIPHER_CTX_new()) == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
}
dd = s->enc_write_ctx;
if (SSL_CONNECTION_IS_DTLS(s)) {
mac_ctx = EVP_MD_CTX_new();
if (mac_ctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
}
s->write_hash = mac_ctx;
} else {
mac_ctx = ssl_replace_hash(&s->write_hash, NULL);
if (mac_ctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB);
goto err;
}
}
ssl3_cleanup_key_block(s);
if ((p = OPENSSL_malloc(num)) == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
{
unsigned char *val = NULL;
size_t vallen = 0, currentvalpos;
- int rv;
+ int rv = 0;
/*
* construct PRF arguments we construct the PRF argument ourself rather
val = OPENSSL_malloc(vallen);
if (val == NULL)
- goto err2;
+ goto ret;
currentvalpos = 0;
memcpy(val + currentvalpos, (unsigned char *)label, llen);
currentvalpos += llen;
goto ret;
err1:
ERR_raise(ERR_LIB_SSL, SSL_R_TLS_ILLEGAL_EXPORTER_LABEL);
- rv = 0;
- goto ret;
- err2:
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
- rv = 0;
ret:
OPENSSL_clear_free(val, vallen);
return rv;
(ctx->group_list_max_len
+ TLS_GROUP_LIST_MALLOC_BLOCK_SIZE)
* sizeof(TLS_GROUP_INFO));
- if (tmp == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (tmp == NULL)
return 0;
- }
ctx->group_list = tmp;
memset(tmp + ctx->group_list_max_len,
0,
goto err;
}
ginf->tlsname = OPENSSL_strdup(p->data);
- if (ginf->tlsname == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (ginf->tlsname == NULL)
goto err;
- }
p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL);
if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING) {
goto err;
}
ginf->realname = OPENSSL_strdup(p->data);
- if (ginf->realname == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (ginf->realname == NULL)
goto err;
- }
p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_ID);
if (p == NULL || !OSSL_PARAM_get_uint(p, &gid) || gid > UINT16_MAX) {
goto err;
}
ginf->algorithm = OPENSSL_strdup(p->data);
- if (ginf->algorithm == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (ginf->algorithm == NULL)
goto err;
- }
p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS);
if (p == NULL || !OSSL_PARAM_get_uint(p, &ginf->secbits)) {
ctx->ext.supported_groups_default
= OPENSSL_malloc(sizeof(uint16_t) * num_deflt_grps);
- if (ctx->ext.supported_groups_default == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if (ctx->ext.supported_groups_default == NULL)
return 0;
- }
memcpy(ctx->ext.supported_groups_default,
tmp_supp_groups,
ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH);
return 0;
}
- if ((glist = OPENSSL_malloc(ngroups * sizeof(*glist))) == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if ((glist = OPENSSL_malloc(ngroups * sizeof(*glist))) == NULL)
return 0;
- }
for (i = 0; i < ngroups; i++) {
unsigned long idmask;
uint16_t id;
}
nmatch = tls12_shared_sigalgs(s, NULL, pref, preflen, allow, allowlen);
if (nmatch) {
- if ((salgs = OPENSSL_malloc(nmatch * sizeof(*salgs))) == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if ((salgs = OPENSSL_malloc(nmatch * sizeof(*salgs))) == NULL)
return 0;
- }
nmatch = tls12_shared_sigalgs(s, salgs, pref, preflen, allow, allowlen);
} else {
salgs = NULL;
size >>= 1;
- if ((buf = OPENSSL_malloc(size * sizeof(*buf))) == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if ((buf = OPENSSL_malloc(size * sizeof(*buf))) == NULL)
return 0;
- }
for (i = 0; i < size && PACKET_get_net_2(pkt, &stmp); i++)
buf[i] = stmp;
{
uint16_t *sigalgs;
- if ((sigalgs = OPENSSL_malloc(salglen * sizeof(*sigalgs))) == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if ((sigalgs = OPENSSL_malloc(salglen * sizeof(*sigalgs))) == NULL)
return 0;
- }
memcpy(sigalgs, psigs, salglen * sizeof(*sigalgs));
if (client) {
if (salglen & 1)
return 0;
- if ((sigalgs = OPENSSL_malloc((salglen / 2) * sizeof(*sigalgs))) == NULL) {
- ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
+ if ((sigalgs = OPENSSL_malloc((salglen / 2) * sizeof(*sigalgs))) == NULL)
return 0;
- }
for (i = 0, sptr = sigalgs; i < salglen; i += 2) {
size_t j;
const SIGALG_LOOKUP *curr;
} else {
s->enc_write_ctx = EVP_CIPHER_CTX_new();
if (s->enc_write_ctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
}
}
*/
mdctx = EVP_MD_CTX_new();
if (mdctx == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
goto err;
}
tmp_len = BN_num_bytes(K);
if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
BN_bn2bin(K, tmp);
tmp_len = BN_num_bytes(K);
if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) {
- SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE);
+ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
goto err;
}
BN_bn2bin(K, tmp);
projects / thirdparty / openssl.git / commitdiff
