Commit 7fcdbd83 authored by FdaSilvaYY's avatar FdaSilvaYY Committed by Dr. Matthias St. Pierre
Browse files

X509: add more error codes on malloc or sk_TYP_push failure 



Reviewed-by: default avatarRich Salz <rsalz@openssl.org>
Reviewed-by: default avatarMatthias St. Pierre <Matthias.St.Pierre@ncp-e.com>
(Merged from https://github.com/openssl/openssl/pull/5837)
parent d8f436f3

crypto/err/openssl.txt

+12 −0
Original line number Diff line number Diff line
@@ -1587,8 +1587,12 @@ X509V3_F_I2S_ASN1_ENUMERATED:121:i2s_ASN1_ENUMERATED 
X509V3_F_I2S_ASN1_IA5STRING:149:i2s_ASN1_IA5STRING

X509V3_F_I2S_ASN1_INTEGER:120:i2s_ASN1_INTEGER

X509V3_F_I2V_AUTHORITY_INFO_ACCESS:138:i2v_AUTHORITY_INFO_ACCESS

X509V3_F_LEVEL_ADD_NODE:168:level_add_node

X509V3_F_NOTICE_SECTION:132:notice_section

X509V3_F_NREF_NOS:133:nref_nos

X509V3_F_POLICY_CACHE_CREATE:169:policy_cache_create

X509V3_F_POLICY_CACHE_NEW:170:policy_cache_new

X509V3_F_POLICY_DATA_NEW:171:policy_data_new

X509V3_F_POLICY_SECTION:131:policy_section

X509V3_F_PROCESS_PCI_VALUE:150:process_pci_value

X509V3_F_R2I_CERTPOL:130:r2i_certpol
@@ -1641,8 +1645,11 @@ X509_F_CHECK_POLICY:145:check_policy 
X509_F_DANE_I2D:107:dane_i2d

X509_F_DIR_CTRL:102:dir_ctrl

X509_F_GET_CERT_BY_SUBJECT:103:get_cert_by_subject

X509_F_I2D_X509_AUX:151:i2d_X509_AUX

X509_F_LOOKUP_CERTS_SK:152:lookup_certs_sk

X509_F_NETSCAPE_SPKI_B64_DECODE:129:NETSCAPE_SPKI_b64_decode

X509_F_NETSCAPE_SPKI_B64_ENCODE:130:NETSCAPE_SPKI_b64_encode

X509_F_NEW_DIR:153:new_dir

X509_F_X509AT_ADD1_ATTR:135:X509at_add1_attr

X509_F_X509V3_ADD_EXT:104:X509v3_add_ext

X509_F_X509_ATTRIBUTE_CREATE_BY_NID:136:X509_ATTRIBUTE_create_by_NID
@@ -1652,6 +1659,7 @@ X509_F_X509_ATTRIBUTE_GET0_DATA:139:X509_ATTRIBUTE_get0_data 
X509_F_X509_ATTRIBUTE_SET1_DATA:138:X509_ATTRIBUTE_set1_data

X509_F_X509_CHECK_PRIVATE_KEY:128:X509_check_private_key

X509_F_X509_CRL_DIFF:105:X509_CRL_diff

X509_F_X509_CRL_METHOD_NEW:154:X509_CRL_METHOD_new

X509_F_X509_CRL_PRINT_FP:147:X509_CRL_print_fp

X509_F_X509_EXTENSION_CREATE_BY_NID:108:X509_EXTENSION_create_by_NID

X509_F_X509_EXTENSION_CREATE_BY_OBJ:109:X509_EXTENSION_create_by_OBJ
@@ -1659,7 +1667,9 @@ X509_F_X509_GET_PUBKEY_PARAMETERS:110:X509_get_pubkey_parameters 
X509_F_X509_LOAD_CERT_CRL_FILE:132:X509_load_cert_crl_file

X509_F_X509_LOAD_CERT_FILE:111:X509_load_cert_file

X509_F_X509_LOAD_CRL_FILE:112:X509_load_crl_file

X509_F_X509_LOOKUP_NEW:155:X509_LOOKUP_new

X509_F_X509_NAME_ADD_ENTRY:113:X509_NAME_add_entry

X509_F_X509_NAME_CANON:156:x509_name_canon

X509_F_X509_NAME_ENTRY_CREATE_BY_NID:114:X509_NAME_ENTRY_create_by_NID

X509_F_X509_NAME_ENTRY_CREATE_BY_TXT:131:X509_NAME_ENTRY_create_by_txt

X509_F_X509_NAME_ENTRY_SET_OBJECT:115:X509_NAME_ENTRY_set_object
@@ -1676,10 +1686,12 @@ X509_F_X509_REQ_PRINT_FP:122:X509_REQ_print_fp 
X509_F_X509_REQ_TO_X509:123:X509_REQ_to_X509

X509_F_X509_STORE_ADD_CERT:124:X509_STORE_add_cert

X509_F_X509_STORE_ADD_CRL:125:X509_STORE_add_crl

X509_F_X509_STORE_ADD_LOOKUP:157:X509_STORE_add_lookup

X509_F_X509_STORE_CTX_GET1_ISSUER:146:X509_STORE_CTX_get1_issuer

X509_F_X509_STORE_CTX_INIT:143:X509_STORE_CTX_init

X509_F_X509_STORE_CTX_NEW:142:X509_STORE_CTX_new

X509_F_X509_STORE_CTX_PURPOSE_INHERIT:134:X509_STORE_CTX_purpose_inherit

X509_F_X509_STORE_NEW:158:X509_STORE_new

X509_F_X509_TO_X509_REQ:126:X509_to_X509_REQ

X509_F_X509_TRUST_ADD:133:X509_TRUST_add

X509_F_X509_TRUST_SET:141:X509_TRUST_set

crypto/x509/by_dir.c

+26 −16
Original line number Diff line number Diff line
@@ -48,7 +48,7 @@ static int get_cert_by_subject(X509_LOOKUP *xl, X509_LOOKUP_TYPE type, 
                               X509_NAME *name, X509_OBJECT *ret);

static X509_LOOKUP_METHOD x509_dir_lookup = {

    "Load certs from files in a directory",

    new_dir,                    /* new */

    new_dir,                    /* new_item */

    free_dir,                   /* free */

    NULL,                       /* init */

    NULL,                       /* shutdown */
@@ -68,15 +68,13 @@ static int dir_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl, 
                    char **retp)

{

    int ret = 0;

    BY_DIR *ld;

    char *dir = NULL;



    ld = (BY_DIR *)ctx->method_data;

    BY_DIR *ld = (BY_DIR *)ctx->method_data;



    switch (cmd) {

    case X509_L_ADD_DIR:

        if (argl == X509_FILETYPE_DEFAULT) {

            dir = (char *)getenv(X509_get_default_cert_dir_env());

            const char *dir = getenv(X509_get_default_cert_dir_env());



            if (dir)

                ret = add_cert_dir(ld, dir, X509_FILETYPE_PEM);

            else
@@ -94,23 +92,30 @@ static int dir_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl, 


static int new_dir(X509_LOOKUP *lu)

{

    BY_DIR *a;

    BY_DIR *a = OPENSSL_malloc(sizeof(*a));



    if ((a = OPENSSL_malloc(sizeof(*a))) == NULL)

    if (a == NULL) {

        X509err(X509_F_NEW_DIR, ERR_R_MALLOC_FAILURE);

        return 0;

    }



    if ((a->buffer = BUF_MEM_new()) == NULL) {

        OPENSSL_free(a);

        return 0;

        X509err(X509_F_NEW_DIR, ERR_R_MALLOC_FAILURE);

        goto err;

    }

    a->dirs = NULL;

    a->lock = CRYPTO_THREAD_lock_new();

    if (a->lock == NULL) {

        BUF_MEM_free(a->buffer);

        OPENSSL_free(a);

        return 0;

        X509err(X509_F_NEW_DIR, ERR_R_MALLOC_FAILURE);

        goto err;

    }

    lu->method_data = (char *)a;

    return 1;



 err:

    OPENSSL_free(a);

    return 0;

}



static void by_dir_hash_free(BY_DIR_HASH *hash)
@@ -137,9 +142,8 @@ static void by_dir_entry_free(BY_DIR_ENTRY *ent) 


static void free_dir(X509_LOOKUP *lu)

{

    BY_DIR *a;

    BY_DIR *a = (BY_DIR *)lu->method_data;



    a = (BY_DIR *)lu->method_data;

    sk_BY_DIR_ENTRY_pop_free(a->dirs, by_dir_entry_free);

    BUF_MEM_free(a->buffer);

    CRYPTO_THREAD_lock_free(a->lock);
@@ -162,6 +166,7 @@ static int add_cert_dir(BY_DIR *ctx, const char *dir, int type) 
    do {

        if ((*p == LIST_SEPARATOR_CHAR) || (*p == '\0')) {

            BY_DIR_ENTRY *ent;



            ss = s;

            s = p + 1;

            len = p - ss;
@@ -182,8 +187,10 @@ static int add_cert_dir(BY_DIR *ctx, const char *dir, int type) 
                }

            }

            ent = OPENSSL_malloc(sizeof(*ent));

            if (ent == NULL)

            if (ent == NULL) {

                X509err(X509_F_ADD_CERT_DIR, ERR_R_MALLOC_FAILURE);

                return 0;

            }

            ent->dir_type = type;

            ent->hashes = sk_BY_DIR_HASH_new(by_dir_hash_cmp);

            ent->dir = OPENSSL_strndup(ss, len);
@@ -193,6 +200,7 @@ static int add_cert_dir(BY_DIR *ctx, const char *dir, int type) 
            }

            if (!sk_BY_DIR_ENTRY_push(ctx->dirs, ent)) {

                by_dir_entry_free(ent);

                X509err(X509_F_ADD_CERT_DIR, ERR_R_MALLOC_FAILURE);

                return 0;

            }

        }
@@ -244,6 +252,7 @@ static int get_cert_by_subject(X509_LOOKUP *xl, X509_LOOKUP_TYPE type, 
        BY_DIR_ENTRY *ent;

        int idx;

        BY_DIR_HASH htmp, *hent;



        ent = sk_BY_DIR_ENTRY_value(ctx->dirs, i);

        j = strlen(ent->dir) + 1 + 8 + 6 + 1 + 1;

        if (!BUF_MEM_grow(b, j)) {
@@ -340,7 +349,7 @@ static int get_cert_by_subject(X509_LOOKUP *xl, X509_LOOKUP_TYPE type, 
                if (idx >= 0)

                    hent = sk_BY_DIR_HASH_value(ent->hashes, idx);

            }

            if (!hent) {

            if (hent == NULL) {

                hent = OPENSSL_malloc(sizeof(*hent));

                if (hent == NULL) {

                    CRYPTO_THREAD_unlock(ctx->lock);
@@ -353,6 +362,7 @@ static int get_cert_by_subject(X509_LOOKUP *xl, X509_LOOKUP_TYPE type, 
                if (!sk_BY_DIR_HASH_push(ent->hashes, hent)) {

                    CRYPTO_THREAD_unlock(ctx->lock);

                    OPENSSL_free(hent);

                    X509err(X509_F_GET_CERT_BY_SUBJECT, ERR_R_MALLOC_FAILURE);

                    ok = 0;

                    goto finish;

                }

crypto/x509/by_file.c

+1 −1
Original line number Diff line number Diff line
@@ -21,7 +21,7 @@ static int by_file_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, 
                        long argl, char **ret);

static X509_LOOKUP_METHOD x509_file_lookup = {

    "Load file into cache",

    NULL,                       /* new */

    NULL,                       /* new_item */

    NULL,                       /* free */

    NULL,                       /* init */

    NULL,                       /* shutdown */

crypto/x509/x509_err.c

+11 −1
Original line number Diff line number Diff line 
/*

 * Generated by util/mkerr.pl DO NOT EDIT

 * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.

 * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.

 *

 * Licensed under the OpenSSL license (the "License").  You may not use

 * this file except in compliance with the License.  You can obtain a copy
@@ -24,10 +24,13 @@ static const ERR_STRING_DATA X509_str_functs[] = { 
    {ERR_PACK(ERR_LIB_X509, X509_F_DIR_CTRL, 0), "dir_ctrl"},

    {ERR_PACK(ERR_LIB_X509, X509_F_GET_CERT_BY_SUBJECT, 0),

     "get_cert_by_subject"},

    {ERR_PACK(ERR_LIB_X509, X509_F_I2D_X509_AUX, 0), "i2d_X509_AUX"},

    {ERR_PACK(ERR_LIB_X509, X509_F_LOOKUP_CERTS_SK, 0), "lookup_certs_sk"},

    {ERR_PACK(ERR_LIB_X509, X509_F_NETSCAPE_SPKI_B64_DECODE, 0),

     "NETSCAPE_SPKI_b64_decode"},

    {ERR_PACK(ERR_LIB_X509, X509_F_NETSCAPE_SPKI_B64_ENCODE, 0),

     "NETSCAPE_SPKI_b64_encode"},

    {ERR_PACK(ERR_LIB_X509, X509_F_NEW_DIR, 0), "new_dir"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509AT_ADD1_ATTR, 0), "X509at_add1_attr"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509V3_ADD_EXT, 0), "X509v3_add_ext"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_ATTRIBUTE_CREATE_BY_NID, 0),
@@ -43,6 +46,8 @@ static const ERR_STRING_DATA X509_str_functs[] = { 
    {ERR_PACK(ERR_LIB_X509, X509_F_X509_CHECK_PRIVATE_KEY, 0),

     "X509_check_private_key"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_CRL_DIFF, 0), "X509_CRL_diff"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_CRL_METHOD_NEW, 0),

     "X509_CRL_METHOD_new"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_CRL_PRINT_FP, 0), "X509_CRL_print_fp"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_EXTENSION_CREATE_BY_NID, 0),

     "X509_EXTENSION_create_by_NID"},
@@ -56,8 +61,10 @@ static const ERR_STRING_DATA X509_str_functs[] = { 
     "X509_load_cert_file"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_LOAD_CRL_FILE, 0),

     "X509_load_crl_file"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_LOOKUP_NEW, 0), "X509_LOOKUP_new"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_NAME_ADD_ENTRY, 0),

     "X509_NAME_add_entry"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_NAME_CANON, 0), "x509_name_canon"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_NAME_ENTRY_CREATE_BY_NID, 0),

     "X509_NAME_ENTRY_create_by_NID"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_NAME_ENTRY_CREATE_BY_TXT, 0),
@@ -81,6 +88,8 @@ static const ERR_STRING_DATA X509_str_functs[] = { 
     "X509_STORE_add_cert"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_STORE_ADD_CRL, 0),

     "X509_STORE_add_crl"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_STORE_ADD_LOOKUP, 0),

     "X509_STORE_add_lookup"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_STORE_CTX_GET1_ISSUER, 0),

     "X509_STORE_CTX_get1_issuer"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_STORE_CTX_INIT, 0),
@@ -89,6 +98,7 @@ static const ERR_STRING_DATA X509_str_functs[] = { 
     "X509_STORE_CTX_new"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_STORE_CTX_PURPOSE_INHERIT, 0),

     "X509_STORE_CTX_purpose_inherit"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_STORE_NEW, 0), "X509_STORE_new"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_TO_X509_REQ, 0), "X509_to_X509_REQ"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_TRUST_ADD, 0), "X509_TRUST_add"},

    {ERR_PACK(ERR_LIB_X509, X509_F_X509_TRUST_SET, 0), "X509_TRUST_set"},

crypto/x509/x509_lu.c

+34 −21
Original line number Diff line number Diff line
@@ -17,14 +17,15 @@ 


X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method)

{

    X509_LOOKUP *ret;

    X509_LOOKUP *ret = OPENSSL_zalloc(sizeof(*ret));



    ret = OPENSSL_zalloc(sizeof(*ret));

    if (ret == NULL)

    if (ret == NULL) {

        X509err(X509_F_X509_LOOKUP_NEW, ERR_R_MALLOC_FAILURE);

        return NULL;

    }



    ret->method = method;

    if ((method->new_item != NULL) && !method->new_item(ret)) {

    if (method->new_item != NULL && method->new_item(ret) == 0) {

        OPENSSL_free(ret);

        return NULL;

    }
@@ -141,25 +142,36 @@ static int x509_object_cmp(const X509_OBJECT *const *a, 


X509_STORE *X509_STORE_new(void)

{

    X509_STORE *ret;

    X509_STORE *ret = OPENSSL_zalloc(sizeof(*ret));



    if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)

    if (ret == NULL) {

        X509err(X509_F_X509_STORE_NEW, ERR_R_MALLOC_FAILURE);

        return NULL;

    if ((ret->objs = sk_X509_OBJECT_new(x509_object_cmp)) == NULL)

    }

    if ((ret->objs = sk_X509_OBJECT_new(x509_object_cmp)) == NULL) {

        X509err(X509_F_X509_STORE_NEW, ERR_R_MALLOC_FAILURE);

        goto err;

    }

    ret->cache = 1;

    if ((ret->get_cert_methods = sk_X509_LOOKUP_new_null()) == NULL)

    if ((ret->get_cert_methods = sk_X509_LOOKUP_new_null()) == NULL) {

        X509err(X509_F_X509_STORE_NEW, ERR_R_MALLOC_FAILURE);

        goto err;

    }



    if ((ret->param = X509_VERIFY_PARAM_new()) == NULL)

    if ((ret->param = X509_VERIFY_PARAM_new()) == NULL) {

        X509err(X509_F_X509_STORE_NEW, ERR_R_MALLOC_FAILURE);

        goto err;



    if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509_STORE, ret, &ret->ex_data))

    }

    if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509_STORE, ret, &ret->ex_data)) {

        X509err(X509_F_X509_STORE_NEW, ERR_R_MALLOC_FAILURE);

        goto err;

    }



    ret->lock = CRYPTO_THREAD_lock_new();

    if (ret->lock == NULL)

    if (ret->lock == NULL) {

        X509err(X509_F_X509_STORE_NEW, ERR_R_MALLOC_FAILURE);

        goto err;

    }



    ret->references = 1;

    return ret;
@@ -228,18 +240,19 @@ X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m) 
    }

    /* a new one */

    lu = X509_LOOKUP_new(m);

    if (lu == NULL)

    if (lu == NULL) {

        X509err(X509_F_X509_STORE_ADD_LOOKUP, ERR_R_MALLOC_FAILURE);

        return NULL;

    else {

    }



    lu->store_ctx = v;

    if (sk_X509_LOOKUP_push(v->get_cert_methods, lu))

        return lu;

        else {

    /* malloc failed */

    X509err(X509_F_X509_STORE_ADD_LOOKUP, ERR_R_MALLOC_FAILURE);

    X509_LOOKUP_free(lu);

    return NULL;

}

    }

}



X509_OBJECT *X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *vs,

                                               X509_LOOKUP_TYPE type,