Commit 6281abc7 authored by Matt Caswell's avatar Matt Caswell
Browse files

In certain situations the server provided certificate chain may no longer be 


valid. However the issuer of the leaf, or some intermediate cert is in fact
in the trust store.

When building a trust chain if the first attempt fails, then try to see if
alternate chains could be constructed that are trusted.

RT3637
RT3621

Reviewed-by: default avatarRich Salz <rsalz@openssl.org>
parent 3661bb4e

crypto/x509/x509_vfy.c

+105 −70
Original line number Diff line number Diff line
@@ -187,11 +187,11 @@ static X509 *lookup_cert_match(X509_STORE_CTX *ctx, X509 *x) 


int X509_verify_cert(X509_STORE_CTX *ctx)

{

    X509 *x, *xtmp, *chain_ss = NULL;

    X509 *x, *xtmp, *xtmp2, *chain_ss = NULL;

    int bad_chain = 0;

    X509_VERIFY_PARAM *param = ctx->param;

    int depth, i, ok = 0;

    int num;

    int num, j, retry;

    int (*cb) (int xok, X509_STORE_CTX *xctx);

    STACK_OF(X509) *sktmp = NULL;

    if (ctx->cert == NULL) {
@@ -276,25 +276,27 @@ int X509_verify_cert(X509_STORE_CTX *ctx) 
        break;

    }



    /* Remember how many untrusted certs we have */

    j = num;

    /*

     * at this point, chain should contain a list of untrusted certificates.

     * We now need to add at least one trusted one, if possible, otherwise we

     * complain.

     */



    do {

        /*

         * Examine last certificate in chain and see if it is self signed.

         */



        i = sk_X509_num(ctx->chain);

        x = sk_X509_value(ctx->chain, i - 1);

        if (cert_self_signed(x)) {

            /* we have a self signed certificate */

            if (sk_X509_num(ctx->chain) == 1) {

                /*

             * We have a single self signed certificate: see if we can find

             * it in the store. We must have an exact match to avoid possible

             * impersonation.

                 * We have a single self signed certificate: see if we can

                 * find it in the store. We must have an exact match to avoid

                 * possible impersonation.

                 */

                ok = ctx->get_issuer(&xtmp, ctx, x);

                if ((ok <= 0) || X509_cmp(x, xtmp)) {
@@ -309,8 +311,8 @@ int X509_verify_cert(X509_STORE_CTX *ctx) 
                        goto end;

                } else {

                    /*

                 * We have a match: replace certificate with store version so

                 * we get any trust settings.

                     * We have a match: replace certificate with store

                     * version so we get any trust settings.

                     */

                    X509_free(x);

                    x = xtmp;
@@ -324,27 +326,24 @@ int X509_verify_cert(X509_STORE_CTX *ctx) 
                chain_ss = sk_X509_pop(ctx->chain);

                ctx->last_untrusted--;

                num--;

                j--;

                x = sk_X509_value(ctx->chain, num - 1);

            }

        }



        /* We now lookup certs from the certificate store */

        for (;;) {

            /* If we have enough, we break */

            if (depth < num)

                break;



            /* If we are self signed, we break */

            if (cert_self_signed(x))

                break;



            ok = ctx->get_issuer(&xtmp, ctx, x);



            if (ok < 0)

                return ok;

            if (ok == 0)

                break;



            x = xtmp;

            if (!sk_X509_push(ctx->chain, x)) {

                X509_free(xtmp);
@@ -355,12 +354,48 @@ int X509_verify_cert(X509_STORE_CTX *ctx) 
        }



        /* we now have our chain, lets check it... */



        i = check_trust(ctx);



        /* If explicitly rejected error */

        if (i == X509_TRUST_REJECTED)

            goto end;

        /*

         * If it's not explicitly trusted then check if there is an alternative

         * chain that could be used. We only do this if we haven't already

         * checked via TRUSTED_FIRST

         */

        retry = 0;

        if (i != X509_TRUST_TRUSTED

            && !(ctx->param->flags & X509_V_FLAG_TRUSTED_FIRST)) {

            while (j-- > 1) {

                xtmp2 = sk_X509_value(ctx->chain, j - 1);

                ok = ctx->get_issuer(&xtmp, ctx, xtmp2);

                if (ok < 0)

                    goto end;

                /* Check if we found an alternate chain */

                if (ok > 0) {

                    /*

                     * Free up the found cert we'll add it again later

                     */

                    X509_free(xtmp);



                    /*

                     * Dump all the certs above this point - we've found an

                     * alternate chain

                     */

                    while (num > j) {

                        xtmp = sk_X509_pop(ctx->chain);

                        X509_free(xtmp);

                        num--;

                        ctx->last_untrusted--;

                    }

                    retry = 1;

                    break;

                }

            }

        }

    } while (retry);



    /*

     * If not explicitly trusted then indicate error unless it's a single

     * self signed certificate in which case we've indicated an error already