Upgrade chrome's OpenSSL to same version Android ships with.

openssl/crypto/x509/x509_vfy.c

 /* crypto/x509/x509_vfy.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
  * This package is an SSL implementation written
  * by Eric Young (eay@cryptsoft.com).
  * The implementation was written so as to conform with Netscapes SSL.
  * 
  * This library is free for commercial and non-commercial use as long as
  * the following conditions are aheared to.  The following conditions
@@ skipping 52 matching lines @@
 #include "cryptlib.h"
 #include <openssl/crypto.h>
 #include <openssl/lhash.h>
 #include <openssl/buffer.h>
 #include <openssl/evp.h>
 #include <openssl/asn1.h>
 #include <openssl/x509.h>
 #include <openssl/x509v3.h>
 #include <openssl/objects.h>
 
+/* CRL score values */
+
+/* No unhandled critical extensions */
+
+#define CRL_SCORE_NOCRITICAL    0x100
+
+/* certificate is within CRL scope */
+
+#define CRL_SCORE_SCOPE         0x080
+
+/* CRL times valid */
+
+#define CRL_SCORE_TIME          0x040
+
+/* Issuer name matches certificate */
+
+#define CRL_SCORE_ISSUER_NAME   0x020
+
+/* If this score or above CRL is probably valid */
+
+#define CRL_SCORE_VALID (CRL_SCORE_NOCRITICAL|CRL_SCORE_TIME|CRL_SCORE_SCOPE)
+
+/* CRL issuer is certificate issuer */
+
+#define CRL_SCORE_ISSUER_CERT   0x018
+
+/* CRL issuer is on certificate path */
+
+#define CRL_SCORE_SAME_PATH     0x008
+
+/* CRL issuer matches CRL AKID */
+
+#define CRL_SCORE_AKID          0x004
+
+/* Have a delta CRL with valid times */
+
+#define CRL_SCORE_TIME_DELTA    0x002
+
 static int null_callback(int ok,X509_STORE_CTX *e);
 static int check_issued(X509_STORE_CTX *ctx, X509 *x, X509 *issuer);
 static X509 *find_issuer(X509_STORE_CTX *ctx, STACK_OF(X509) *sk, X509 *x);
 static int check_chain_extensions(X509_STORE_CTX *ctx);
+static int check_name_constraints(X509_STORE_CTX *ctx);
 static int check_trust(X509_STORE_CTX *ctx);
 static int check_revocation(X509_STORE_CTX *ctx);
 static int check_cert(X509_STORE_CTX *ctx);
 static int check_policy(X509_STORE_CTX *ctx);
+
+static int get_crl_score(X509_STORE_CTX *ctx, X509 **pissuer,
+                        unsigned int *preasons,
+                        X509_CRL *crl, X509 *x);
+static int get_crl_delta(X509_STORE_CTX *ctx,
+                                X509_CRL **pcrl, X509_CRL **pdcrl, X509 *x);
+static void get_delta_sk(X509_STORE_CTX *ctx, X509_CRL **dcrl, int *pcrl_score,
+                        X509_CRL *base, STACK_OF(X509_CRL) *crls);
+static void crl_akid_check(X509_STORE_CTX *ctx, X509_CRL *crl,
+                                X509 **pissuer, int *pcrl_score);
+static int crl_crldp_check(X509 *x, X509_CRL *crl, int crl_score,
+                                unsigned int *preasons);
+static int check_crl_path(X509_STORE_CTX *ctx, X509 *x);
+static int check_crl_chain(X509_STORE_CTX *ctx,
+                        STACK_OF(X509) *cert_path,
+                        STACK_OF(X509) *crl_path);
+
 static int internal_verify(X509_STORE_CTX *ctx);
 const char X509_version[]="X.509" OPENSSL_VERSION_PTEXT;
 
 
 static int null_callback(int ok, X509_STORE_CTX *e)
         {
         return ok;
         }
 
 #if 0
@@ skipping 191 matching lines @@
                 bad_chain = 1;
                 ok=cb(0,ctx);
                 if (!ok) goto end;
                 }
 
         /* We have the chain complete: now we need to check its purpose */
         ok = check_chain_extensions(ctx);
 
         if (!ok) goto end;
 
+        /* Check name constraints */
+
+        ok = check_name_constraints(ctx);
+        
+        if (!ok) goto end;
+
         /* The chain extensions are OK: check trust */
 
         if (param->trust > 0) ok = check_trust(ctx);
 
         if (!ok) goto end;
 
         /* We may as well copy down any DSA parameters that are required */
         X509_get_pubkey_parameters(NULL,ctx->chain);
 
         /* Check revocation status: we do this after copying parameters
@@ skipping 89 matching lines @@
 
 static int check_chain_extensions(X509_STORE_CTX *ctx)
 {
 #ifdef OPENSSL_NO_CHAIN_VERIFY
         return 1;
 #else
         int i, ok=0, must_be_ca, plen = 0;
         X509 *x;
         int (*cb)(int xok,X509_STORE_CTX *xctx);
         int proxy_path_length = 0;
-        int allow_proxy_certs =
-                !!(ctx->param->flags & X509_V_FLAG_ALLOW_PROXY_CERTS);
+        int purpose;
+        int allow_proxy_certs;
         cb=ctx->verify_cb;
 
         /* must_be_ca can have 1 of 3 values:
            -1: we accept both CA and non-CA certificates, to allow direct
                use of self-signed certificates (which are marked as CA).
            0:  we only accept non-CA certificates.  This is currently not
                used, but the possibility is present for future extensions.
            1:  we only accept CA certificates.  This is currently used for
                all certificates in the chain except the leaf certificate.
         */
         must_be_ca = -1;
 
-        /* A hack to keep people who don't want to modify their software
-           happy */
-        if (getenv("OPENSSL_ALLOW_PROXY_CERTS"))
-                allow_proxy_certs = 1;
+        /* CRL path validation */
+        if (ctx->parent)
+                {
+                allow_proxy_certs = 0;
+                purpose = X509_PURPOSE_CRL_SIGN;
+                }
+        else
+                {
+                allow_proxy_certs =
+                        !!(ctx->param->flags & X509_V_FLAG_ALLOW_PROXY_CERTS);
+                /* A hack to keep people who don't want to modify their
+                   software happy */
+                if (getenv("OPENSSL_ALLOW_PROXY_CERTS"))
+                        allow_proxy_certs = 1;
+                purpose = ctx->param->purpose;
+                }
 
         /* Check all untrusted certificates */
         for (i = 0; i < ctx->last_untrusted; i++)
                 {
                 int ret;
                 x = sk_X509_value(ctx->chain, i);
                 if (!(ctx->param->flags & X509_V_FLAG_IGNORE_CRITICAL)
                         && (x->ex_flags & EXFLAG_CRITICAL))
                         {
                         ctx->error = X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION;
@@ skipping 46 matching lines @@
                         }
                 if (ret == 0)
                         {
                         ctx->error_depth = i;
                         ctx->current_cert = x;
                         ok=cb(0,ctx);
                         if (!ok) goto end;
                         }
                 if (ctx->param->purpose > 0)
                         {
-                        ret = X509_check_purpose(x, ctx->param->purpose,
-                                must_be_ca > 0);
+                        ret = X509_check_purpose(x, purpose, must_be_ca > 0);
                         if ((ret == 0)
                                 || ((ctx->param->flags & X509_V_FLAG_X509_STRICT)
                                         && (ret != 1)))
                                 {
                                 ctx->error = X509_V_ERR_INVALID_PURPOSE;
                                 ctx->error_depth = i;
                                 ctx->current_cert = x;
                                 ok=cb(0,ctx);
                                 if (!ok) goto end;
                                 }
@@ skipping 32 matching lines @@
                         }
                 else
                         must_be_ca = 1;
                 }
         ok = 1;
  end:
         return ok;
 #endif
 }
 
+static int check_name_constraints(X509_STORE_CTX *ctx)
+        {
+        X509 *x;
+        int i, j, rv;
+        /* Check name constraints for all certificates */
+        for (i = sk_X509_num(ctx->chain) - 1; i >= 0; i--)
+                {
+                x = sk_X509_value(ctx->chain, i);
+                /* Ignore self issued certs unless last in chain */
+                if (i && (x->ex_flags & EXFLAG_SI))
+                        continue;
+                /* Check against constraints for all certificates higher in
+                 * chain including trust anchor. Trust anchor not strictly
+                 * speaking needed but if it includes constraints it is to be
+                 * assumed it expects them to be obeyed.
+                 */
+                for (j = sk_X509_num(ctx->chain) - 1; j > i; j--)
+                        {
+                        NAME_CONSTRAINTS *nc = sk_X509_value(ctx->chain, j)->nc;
+                        if (nc)
+                                {
+                                rv = NAME_CONSTRAINTS_check(x, nc);
+                                if (rv != X509_V_OK)
+                                        {
+                                        ctx->error = rv;
+                                        ctx->error_depth = i;
+                                        ctx->current_cert = x;
+                                        if (!ctx->verify_cb(0,ctx))
+                                                return 0;
+                                        }
+                                }
+                        }
+                }
+        return 1;
+        }
+
 static int check_trust(X509_STORE_CTX *ctx)
 {
 #ifdef OPENSSL_NO_CHAIN_VERIFY
         return 1;
 #else
         int i, ok;
         X509 *x;
         int (*cb)(int xok,X509_STORE_CTX *xctx);
         cb=ctx->verify_cb;
 /* For now just check the last certificate in the chain */
@@ skipping 14 matching lines @@
 }
 
 static int check_revocation(X509_STORE_CTX *ctx)
         {
         int i, last, ok;
         if (!(ctx->param->flags & X509_V_FLAG_CRL_CHECK))
                 return 1;
         if (ctx->param->flags & X509_V_FLAG_CRL_CHECK_ALL)
                 last = sk_X509_num(ctx->chain) - 1;
         else
+                {
+                /* If checking CRL paths this isn't the EE certificate */
+                if (ctx->parent)
+                        return 1;
                 last = 0;
+                }
         for(i = 0; i <= last; i++)
                 {
                 ctx->error_depth = i;
                 ok = check_cert(ctx);
                 if (!ok) return ok;
                 }
         return 1;
         }
 
 static int check_cert(X509_STORE_CTX *ctx)
         {
-        X509_CRL *crl = NULL;
+        X509_CRL *crl = NULL, *dcrl = NULL;
         X509 *x;
         int ok, cnum;
         cnum = ctx->error_depth;
         x = sk_X509_value(ctx->chain, cnum);
         ctx->current_cert = x;
-        /* Try to retrieve relevant CRL */
-        ok = ctx->get_crl(ctx, &crl, x);
-        /* If error looking up CRL, nothing we can do except
-         * notify callback
-         */
-        if(!ok)
+        ctx->current_issuer = NULL;
+        ctx->current_crl_score = 0;
+        ctx->current_reasons = 0;
+        while (ctx->current_reasons != CRLDP_ALL_REASONS)
                 {
-                ctx->error = X509_V_ERR_UNABLE_TO_GET_CRL;
-                ok = ctx->verify_cb(0, ctx);
-                goto err;
+                /* Try to retrieve relevant CRL */
+                if (ctx->get_crl)
+                        ok = ctx->get_crl(ctx, &crl, x);
+                else
+                        ok = get_crl_delta(ctx, &crl, &dcrl, x);
+                /* If error looking up CRL, nothing we can do except
+                 * notify callback
+                 */
+                if(!ok)
+                        {
+                        ctx->error = X509_V_ERR_UNABLE_TO_GET_CRL;
+                        ok = ctx->verify_cb(0, ctx);
+                        goto err;
+                        }
+                ctx->current_crl = crl;
+                ok = ctx->check_crl(ctx, crl);
+                if (!ok)
+                        goto err;
+
+                if (dcrl)
+                        {
+                        ok = ctx->check_crl(ctx, dcrl);
+                        if (!ok)
+                                goto err;
+                        ok = ctx->cert_crl(ctx, dcrl, x);
+                        if (!ok)
+                                goto err;
+                        }
+                else
+                        ok = 1;
+
+                /* Don't look in full CRL if delta reason is removefromCRL */
+                if (ok != 2)
+                        {
+                        ok = ctx->cert_crl(ctx, crl, x);
+                        if (!ok)
+                                goto err;
+                        }
+
+                X509_CRL_free(crl);
+                X509_CRL_free(dcrl);
+                crl = NULL;
+                dcrl = NULL;
                 }
-        ctx->current_crl = crl;
-        ok = ctx->check_crl(ctx, crl);
-        if (!ok) goto err;
-        ok = ctx->cert_crl(ctx, crl, x);
         err:
+        X509_CRL_free(crl);
+        X509_CRL_free(dcrl);
+
         ctx->current_crl = NULL;
-        X509_CRL_free(crl);
         return ok;
 
         }
 
 /* Check CRL times against values in X509_STORE_CTX */
 
 static int check_crl_time(X509_STORE_CTX *ctx, X509_CRL *crl, int notify)
         {
         time_t *ptime;
         int i;
-        ctx->current_crl = crl;
+        if (notify)
+                ctx->current_crl = crl;
         if (ctx->param->flags & X509_V_FLAG_USE_CHECK_TIME)
                 ptime = &ctx->param->check_time;
         else
                 ptime = NULL;
 
         i=X509_cmp_time(X509_CRL_get_lastUpdate(crl), ptime);
         if (i == 0)
                 {
+                if (!notify)
+                        return 0;
                 ctx->error=X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD;
-                if (!notify || !ctx->verify_cb(0, ctx))
+                if (!ctx->verify_cb(0, ctx))
                         return 0;
                 }
 
         if (i > 0)
                 {
+                if (!notify)
+                        return 0;
                 ctx->error=X509_V_ERR_CRL_NOT_YET_VALID;
-                if (!notify || !ctx->verify_cb(0, ctx))
+                if (!ctx->verify_cb(0, ctx))
                         return 0;
                 }
 
         if(X509_CRL_get_nextUpdate(crl))
                 {
                 i=X509_cmp_time(X509_CRL_get_nextUpdate(crl), ptime);
 
                 if (i == 0)
                         {
+                        if (!notify)
+                                return 0;
                         ctx->error=X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD;
-                        if (!notify || !ctx->verify_cb(0, ctx))
+                        if (!ctx->verify_cb(0, ctx))
                                 return 0;
                         }
-
-                if (i < 0)
-                        {
+                /* Ignore expiry of base CRL is delta is valid */
+                if ((i < 0) && !(ctx->current_crl_score & CRL_SCORE_TIME_DELTA))
+                        {
+                        if (!notify)
+                                return 0;
                         ctx->error=X509_V_ERR_CRL_HAS_EXPIRED;
-                        if (!notify || !ctx->verify_cb(0, ctx))
+                        if (!ctx->verify_cb(0, ctx))
                                 return 0;
                         }
                 }
 
-        ctx->current_crl = NULL;
+        if (notify)
+                ctx->current_crl = NULL;
 
         return 1;
         }
 
-/* Lookup CRLs from the supplied list. Look for matching isser name
- * and validity. If we can't find a valid CRL return the last one
- * with matching name. This gives more meaningful error codes. Otherwise
- * we'd get a CRL not found error if a CRL existed with matching name but
- * was invalid.
- */
-
-static int get_crl_sk(X509_STORE_CTX *ctx, X509_CRL **pcrl,
-                        X509_NAME *nm, STACK_OF(X509_CRL) *crls)
-        {
+static int get_crl_sk(X509_STORE_CTX *ctx, X509_CRL **pcrl, X509_CRL **pdcrl,
+                        X509 **pissuer, int *pscore, unsigned int *preasons,
+                        STACK_OF(X509_CRL) *crls)
+        {
+        int i, crl_score, best_score = *pscore;
+        unsigned int reasons, best_reasons = 0;
+        X509 *x = ctx->current_cert;
+        X509_CRL *crl, *best_crl = NULL;
+        X509 *crl_issuer = NULL, *best_crl_issuer = NULL;
+
+        for (i = 0; i < sk_X509_CRL_num(crls); i++)
+                {
+                crl = sk_X509_CRL_value(crls, i);
+                reasons = *preasons;
+                crl_score = get_crl_score(ctx, &crl_issuer, &reasons, crl, x);
+
+                if (crl_score > best_score)
+                        {
+                        best_crl = crl;
+                        best_crl_issuer = crl_issuer;
+                        best_score = crl_score;
+                        best_reasons = reasons;
+                        }
+                }
+
+        if (best_crl)
+                {
+                if (*pcrl)
+                        X509_CRL_free(*pcrl);
+                *pcrl = best_crl;
+                *pissuer = best_crl_issuer;
+                *pscore = best_score;
+                *preasons = best_reasons;
+                CRYPTO_add(&best_crl->references, 1, CRYPTO_LOCK_X509_CRL);
+                if (*pdcrl)
+                        {
+                        X509_CRL_free(*pdcrl);
+                        *pdcrl = NULL;
+                        }
+                get_delta_sk(ctx, pdcrl, pscore, best_crl, crls);
+                }
+
+        if (best_score >= CRL_SCORE_VALID)
+                return 1;
+
+        return 0;
+        }
+
+/* Compare two CRL extensions for delta checking purposes. They should be
+ * both present or both absent. If both present all fields must be identical.
+ */
+
+static int crl_extension_match(X509_CRL *a, X509_CRL *b, int nid)
+        {
+        ASN1_OCTET_STRING *exta, *extb;
         int i;
-        X509_CRL *crl, *best_crl = NULL;
+        i = X509_CRL_get_ext_by_NID(a, nid, 0);
+        if (i >= 0)
+                {
+                /* Can't have multiple occurrences */
+                if (X509_CRL_get_ext_by_NID(a, nid, i) != -1)
+                        return 0;
+                exta = X509_EXTENSION_get_data(X509_CRL_get_ext(a, i));
+                }
+        else
+                exta = NULL;
+
+        i = X509_CRL_get_ext_by_NID(b, nid, 0);
+
+        if (i >= 0)
+                {
+
+                if (X509_CRL_get_ext_by_NID(b, nid, i) != -1)
+                        return 0;
+                extb = X509_EXTENSION_get_data(X509_CRL_get_ext(b, i));
+                }
+        else
+                extb = NULL;
+
+        if (!exta && !extb)
+                return 1;
+
+        if (!exta || !extb)
+                return 0;
+
+
+        if (ASN1_OCTET_STRING_cmp(exta, extb))
+                return 0;
+
+        return 1;
+        }
+
+/* See if a base and delta are compatible */
+
+static int check_delta_base(X509_CRL *delta, X509_CRL *base)
+        {
+        /* Delta CRL must be a delta */
+        if (!delta->base_crl_number)
+                        return 0;
+        /* Base must have a CRL number */
+        if (!base->crl_number)
+                        return 0;
+        /* Issuer names must match */
+        if (X509_NAME_cmp(X509_CRL_get_issuer(base),
+                                X509_CRL_get_issuer(delta)))
+                return 0;
+        /* AKID and IDP must match */
+        if (!crl_extension_match(delta, base, NID_authority_key_identifier))
+                        return 0;
+        if (!crl_extension_match(delta, base, NID_issuing_distribution_point))
+                        return 0;
+        /* Delta CRL base number must not exceed Full CRL number. */
+        if (ASN1_INTEGER_cmp(delta->base_crl_number, base->crl_number) > 0)
+                        return 0;
+        /* Delta CRL number must exceed full CRL number */
+        if (ASN1_INTEGER_cmp(delta->crl_number, base->crl_number) > 0)
+                        return 1;
+        return 0;
+        }
+
+/* For a given base CRL find a delta... maybe extend to delta scoring
+ * or retrieve a chain of deltas...
+ */
+
+static void get_delta_sk(X509_STORE_CTX *ctx, X509_CRL **dcrl, int *pscore,
+                        X509_CRL *base, STACK_OF(X509_CRL) *crls)
+        {
+        X509_CRL *delta;
+        int i;
+        if (!(ctx->param->flags & X509_V_FLAG_USE_DELTAS))
+                return;
+        if (!((ctx->current_cert->ex_flags | base->flags) & EXFLAG_FRESHEST))
+                return;
         for (i = 0; i < sk_X509_CRL_num(crls); i++)
                 {
-                crl = sk_X509_CRL_value(crls, i);
-                if (X509_NAME_cmp(nm, X509_CRL_get_issuer(crl)))
+                delta = sk_X509_CRL_value(crls, i);
+                if (check_delta_base(delta, base))
+                        {
+                        if (check_crl_time(ctx, delta, 0))
+                                *pscore |= CRL_SCORE_TIME_DELTA;
+                        CRYPTO_add(&delta->references, 1, CRYPTO_LOCK_X509_CRL);
+                        *dcrl = delta;
+                        return;
+                        }
+                }
+        *dcrl = NULL;
+        }
+
+/* For a given CRL return how suitable it is for the supplied certificate 'x'.
+ * The return value is a mask of several criteria.
+ * If the issuer is not the certificate issuer this is returned in *pissuer.
+ * The reasons mask is also used to determine if the CRL is suitable: if
+ * no new reasons the CRL is rejected, otherwise reasons is updated.
+ */
+
+static int get_crl_score(X509_STORE_CTX *ctx, X509 **pissuer,
+                        unsigned int *preasons,
+                        X509_CRL *crl, X509 *x)
+        {
+
+        int crl_score = 0;
+        unsigned int tmp_reasons = *preasons, crl_reasons;
+
+        /* First see if we can reject CRL straight away */
+
+        /* Invalid IDP cannot be processed */
+        if (crl->idp_flags & IDP_INVALID)
+                return 0;
+        /* Reason codes or indirect CRLs need extended CRL support */
+        if (!(ctx->param->flags & X509_V_FLAG_EXTENDED_CRL_SUPPORT))
+                {
+                if (crl->idp_flags & (IDP_INDIRECT | IDP_REASONS))
+                        return 0;
+                }
+        else if (crl->idp_flags & IDP_REASONS)
+                {
+                /* If no new reasons reject */
+                if (!(crl->idp_reasons & ~tmp_reasons))
+                        return 0;
+                }
+        /* Don't process deltas at this stage */
+        else if (crl->base_crl_number)
+                return 0;
+        /* If issuer name doesn't match certificate need indirect CRL */
+        if (X509_NAME_cmp(X509_get_issuer_name(x), X509_CRL_get_issuer(crl)))
+                {
+                if (!(crl->idp_flags & IDP_INDIRECT))
+                        return 0;
+                }
+        else
+                crl_score |= CRL_SCORE_ISSUER_NAME;
+
+        if (!(crl->flags & EXFLAG_CRITICAL))
+                crl_score |= CRL_SCORE_NOCRITICAL;
+
+        /* Check expiry */
+        if (check_crl_time(ctx, crl, 0))
+                crl_score |= CRL_SCORE_TIME;
+
+        /* Check authority key ID and locate certificate issuer */
+        crl_akid_check(ctx, crl, pissuer, &crl_score);
+
+        /* If we can't locate certificate issuer at this point forget it */
+
+        if (!(crl_score & CRL_SCORE_AKID))
+                return 0;
+
+        /* Check cert for matching CRL distribution points */
+
+        if (crl_crldp_check(x, crl, crl_score, &crl_reasons))
+                {
+                /* If no new reasons reject */
+                if (!(crl_reasons & ~tmp_reasons))
+                        return 0;
+                tmp_reasons |= crl_reasons;
+                crl_score |= CRL_SCORE_SCOPE;
+                }
+
+        *preasons = tmp_reasons;
+
+        return crl_score;
+
+        }
+
+static void crl_akid_check(X509_STORE_CTX *ctx, X509_CRL *crl,
+                                X509 **pissuer, int *pcrl_score)
+        {
+        X509 *crl_issuer = NULL;
+        X509_NAME *cnm = X509_CRL_get_issuer(crl);
+        int cidx = ctx->error_depth;
+        int i;
+
+        if (cidx != sk_X509_num(ctx->chain) - 1)
+                cidx++;
+
+        crl_issuer = sk_X509_value(ctx->chain, cidx);
+
+        if (X509_check_akid(crl_issuer, crl->akid) == X509_V_OK)
+                {
+                if (*pcrl_score & CRL_SCORE_ISSUER_NAME)
+                        {
+                        *pcrl_score |= CRL_SCORE_AKID|CRL_SCORE_ISSUER_CERT;
+                        *pissuer = crl_issuer;
+                        return;
+                        }
+                }
+
+        for (cidx++; cidx < sk_X509_num(ctx->chain); cidx++)
+                {
+                crl_issuer = sk_X509_value(ctx->chain, cidx);
+                if (X509_NAME_cmp(X509_get_subject_name(crl_issuer), cnm))
                         continue;
-                if (check_crl_time(ctx, crl, 0))
-                        {
-                        *pcrl = crl;
-                        CRYPTO_add(&crl->references, 1, CRYPTO_LOCK_X509);
+                if (X509_check_akid(crl_issuer, crl->akid) == X509_V_OK)
+                        {
+                        *pcrl_score |= CRL_SCORE_AKID|CRL_SCORE_SAME_PATH;
+                        *pissuer = crl_issuer;
+                        return;
+                        }
+                }
+
+        /* Anything else needs extended CRL support */
+
+        if (!(ctx->param->flags & X509_V_FLAG_EXTENDED_CRL_SUPPORT))
+                return;
+
+        /* Otherwise the CRL issuer is not on the path. Look for it in the
+         * set of untrusted certificates.
+         */
+        for (i = 0; i < sk_X509_num(ctx->untrusted); i++)
+                {
+                crl_issuer = sk_X509_value(ctx->untrusted, i);
+                if (X509_NAME_cmp(X509_get_subject_name(crl_issuer), cnm))
+                        continue;
+                if (X509_check_akid(crl_issuer, crl->akid) == X509_V_OK)
+                        {
+                        *pissuer = crl_issuer;
+                        *pcrl_score |= CRL_SCORE_AKID;
+                        return;
+                        }
+                }
+        }
+
+/* Check the path of a CRL issuer certificate. This creates a new
+ * X509_STORE_CTX and populates it with most of the parameters from the
+ * parent. This could be optimised somewhat since a lot of path checking
+ * will be duplicated by the parent, but this will rarely be used in 
+ * practice.
+ */
+
+static int check_crl_path(X509_STORE_CTX *ctx, X509 *x)
+        {
+        X509_STORE_CTX crl_ctx;
+        int ret;
+        /* Don't allow recursive CRL path validation */
+        if (ctx->parent)
+                return 0;
+        if (!X509_STORE_CTX_init(&crl_ctx, ctx->ctx, x, ctx->untrusted))
+                return -1;
+
+        crl_ctx.crls = ctx->crls;
+        /* Copy verify params across */
+        X509_STORE_CTX_set0_param(&crl_ctx, ctx->param);
+
+        crl_ctx.parent = ctx;
+        crl_ctx.verify_cb = ctx->verify_cb;
+
+        /* Verify CRL issuer */
+        ret = X509_verify_cert(&crl_ctx);
+
+        if (ret <= 0)
+                goto err;
+
+        /* Check chain is acceptable */
+
+        ret = check_crl_chain(ctx, ctx->chain, crl_ctx.chain);
+        err:
+        X509_STORE_CTX_cleanup(&crl_ctx);
+        return ret;
+        }
+
+/* RFC3280 says nothing about the relationship between CRL path
+ * and certificate path, which could lead to situations where a
+ * certificate could be revoked or validated by a CA not authorised
+ * to do so. RFC5280 is more strict and states that the two paths must
+ * end in the same trust anchor, though some discussions remain...
+ * until this is resolved we use the RFC5280 version
+ */
+
+static int check_crl_chain(X509_STORE_CTX *ctx,
+                        STACK_OF(X509) *cert_path,
+                        STACK_OF(X509) *crl_path)
+        {
+        X509 *cert_ta, *crl_ta;
+        cert_ta = sk_X509_value(cert_path, sk_X509_num(cert_path) - 1);
+        crl_ta = sk_X509_value(crl_path, sk_X509_num(crl_path) - 1);
+        if (!X509_cmp(cert_ta, crl_ta))
+                return 1;
+        return 0;
+        }
+
+/* Check for match between two dist point names: three separate cases.
+ * 1. Both are relative names and compare X509_NAME types.
+ * 2. One full, one relative. Compare X509_NAME to GENERAL_NAMES.
+ * 3. Both are full names and compare two GENERAL_NAMES.
+ * 4. One is NULL: automatic match.
+ */
+
+
+static int idp_check_dp(DIST_POINT_NAME *a, DIST_POINT_NAME *b)
+        {
+        X509_NAME *nm = NULL;
+        GENERAL_NAMES *gens = NULL;
+        GENERAL_NAME *gena, *genb;
+        int i, j;
+        if (!a || !b)
+                return 1;
+        if (a->type == 1)
+                {
+                if (!a->dpname)
+                        return 0;
+                /* Case 1: two X509_NAME */
+                if (b->type == 1)
+                        {
+                        if (!b->dpname)
+                                return 0;
+                        if (!X509_NAME_cmp(a->dpname, b->dpname))
+                                return 1;
+                        else
+                                return 0;
+                        }
+                /* Case 2: set name and GENERAL_NAMES appropriately */
+                nm = a->dpname;
+                gens = b->name.fullname;
+                }
+        else if (b->type == 1)
+                {
+                if (!b->dpname)
+                        return 0;
+                /* Case 2: set name and GENERAL_NAMES appropriately */
+                gens = a->name.fullname;
+                nm = b->dpname;
+                }
+
+        /* Handle case 2 with one GENERAL_NAMES and one X509_NAME */
+        if (nm)
+                {
+                for (i = 0; i < sk_GENERAL_NAME_num(gens); i++)
+                        {
+                        gena = sk_GENERAL_NAME_value(gens, i);  
+                        if (gena->type != GEN_DIRNAME)
+                                continue;
+                        if (!X509_NAME_cmp(nm, gena->d.directoryName))
+                                return 1;
+                        }
+                return 0;
+                }
+
+        /* Else case 3: two GENERAL_NAMES */
+
+        for (i = 0; i < sk_GENERAL_NAME_num(a->name.fullname); i++)
+                {
+                gena = sk_GENERAL_NAME_value(a->name.fullname, i);
+                for (j = 0; j < sk_GENERAL_NAME_num(b->name.fullname); j++)
+                        {
+                        genb = sk_GENERAL_NAME_value(b->name.fullname, j);
+                        if (!GENERAL_NAME_cmp(gena, genb))
+                                return 1;
+                        }
+                }
+
+        return 0;
+
+        }
+
+static int crldp_check_crlissuer(DIST_POINT *dp, X509_CRL *crl, int crl_score)
+        {
+        int i;
+        X509_NAME *nm = X509_CRL_get_issuer(crl);
+        /* If no CRLissuer return is successful iff don't need a match */
+        if (!dp->CRLissuer)
+                return !!(crl_score & CRL_SCORE_ISSUER_NAME);
+        for (i = 0; i < sk_GENERAL_NAME_num(dp->CRLissuer); i++)
+                {
+                GENERAL_NAME *gen = sk_GENERAL_NAME_value(dp->CRLissuer, i);
+                if (gen->type != GEN_DIRNAME)
+                        continue;
+                if (!X509_NAME_cmp(gen->d.directoryName, nm))
                         return 1;
-                        }
-                best_crl = crl;
-                }
-        if (best_crl)
-                {
-                *pcrl = best_crl;
-                CRYPTO_add(&best_crl->references, 1, CRYPTO_LOCK_X509);
-                }
-                
-        return 0;
-        }
-
-/* Retrieve CRL corresponding to certificate: currently just a
- * subject lookup: maybe use AKID later...
- */
-static int get_crl(X509_STORE_CTX *ctx, X509_CRL **pcrl, X509 *x)
+                }
+        return 0;
+        }
+
+/* Check CRLDP and IDP */
+
+static int crl_crldp_check(X509 *x, X509_CRL *crl, int crl_score,
+                                unsigned int *preasons)
+        {
+        int i;
+        if (crl->idp_flags & IDP_ONLYATTR)
+                return 0;
+        if (x->ex_flags & EXFLAG_CA)
+                {
+                if (crl->idp_flags & IDP_ONLYUSER)
+                        return 0;
+                }
+        else
+                {
+                if (crl->idp_flags & IDP_ONLYCA)
+                        return 0;
+                }
+        *preasons = crl->idp_reasons;
+        for (i = 0; i < sk_DIST_POINT_num(x->crldp); i++)
+                {
+                DIST_POINT *dp = sk_DIST_POINT_value(x->crldp, i);
+                if (crldp_check_crlissuer(dp, crl, crl_score))
+                        {
+                        if (!crl->idp ||
+                             idp_check_dp(dp->distpoint, crl->idp->distpoint))
+                                {
+                                *preasons &= dp->dp_reasons;
+                                return 1;
+                                }
+                        }
+                }
+        if ((!crl->idp || !crl->idp->distpoint) && (crl_score & CRL_SCORE_ISSUER_NAME))
+                return 1;
+        return 0;
+        }
+
+/* Retrieve CRL corresponding to current certificate.
+ * If deltas enabled try to find a delta CRL too
+ */
+        
+static int get_crl_delta(X509_STORE_CTX *ctx,
+                                X509_CRL **pcrl, X509_CRL **pdcrl, X509 *x)
         {
         int ok;
-        X509_CRL *crl = NULL;
-        X509_OBJECT xobj;
-        X509_NAME *nm;
-        nm = X509_get_issuer_name(x);
-        ok = get_crl_sk(ctx, &crl, nm, ctx->crls);
+        X509 *issuer = NULL;
+        int crl_score = 0;
+        unsigned int reasons;
+        X509_CRL *crl = NULL, *dcrl = NULL;
+        STACK_OF(X509_CRL) *skcrl;
+        X509_NAME *nm = X509_get_issuer_name(x);
+        reasons = ctx->current_reasons;
+        ok = get_crl_sk(ctx, &crl, &dcrl, 
+                                &issuer, &crl_score, &reasons, ctx->crls);
+
         if (ok)
-                {
+                goto done;
+
+        /* Lookup CRLs from store */
+
+        skcrl = ctx->lookup_crls(ctx, nm);
+
+        /* If no CRLs found and a near match from get_crl_sk use that */
+        if (!skcrl && crl)
+                goto done;
+
+        get_crl_sk(ctx, &crl, &dcrl, &issuer, &crl_score, &reasons, skcrl);
+
+        sk_X509_CRL_pop_free(skcrl, X509_CRL_free);
+
+        done:
+
+        /* If we got any kind of CRL use it and return success */
+        if (crl)
+                {
+                ctx->current_issuer = issuer;
+                ctx->current_crl_score = crl_score;
+                ctx->current_reasons = reasons;
                 *pcrl = crl;
+                *pdcrl = dcrl;
                 return 1;
                 }
 
-        ok = X509_STORE_get_by_subject(ctx, X509_LU_CRL, nm, &xobj);
-
-        if (!ok)
-                {
-                /* If we got a near match from get_crl_sk use that */
-                if (crl)
-                        {
-                        *pcrl = crl;
-                        return 1;
-                        }
-                return 0;
-                }
-
-        *pcrl = xobj.data.crl;
-        if (crl)
-                X509_CRL_free(crl);
-        return 1;
+        return 0;
         }
 
 /* Check CRL validity */
 static int check_crl(X509_STORE_CTX *ctx, X509_CRL *crl)
         {
         X509 *issuer = NULL;
         EVP_PKEY *ikey = NULL;
         int ok = 0, chnum, cnum;
         cnum = ctx->error_depth;
         chnum = sk_X509_num(ctx->chain) - 1;
-        /* Find CRL issuer: if not last certificate then issuer
+        /* if we have an alternative CRL issuer cert use that */
+        if (ctx->current_issuer)
+                issuer = ctx->current_issuer;
+
+        /* Else find CRL issuer: if not last certificate then issuer
          * is next certificate in chain.
          */
-        if(cnum < chnum)
+        else if (cnum < chnum)
                 issuer = sk_X509_value(ctx->chain, cnum + 1);
         else
                 {
                 issuer = sk_X509_value(ctx->chain, chnum);
                 /* If not self signed, can't check signature */
                 if(!ctx->check_issued(ctx, issuer, issuer))
                         {
                         ctx->error = X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER;
                         ok = ctx->verify_cb(0, ctx);
                         if(!ok) goto err;
                         }
                 }
 
         if(issuer)
                 {
-                /* Check for cRLSign bit if keyUsage present */
-                if ((issuer->ex_flags & EXFLAG_KUSAGE) &&
-                        !(issuer->ex_kusage & KU_CRL_SIGN))
+                /* Skip most tests for deltas because they have already
+                 * been done
+                 */
+                if (!crl->base_crl_number)
                         {
-                        ctx->error = X509_V_ERR_KEYUSAGE_NO_CRL_SIGN;
-                        ok = ctx->verify_cb(0, ctx);
-                        if(!ok) goto err;
+                        /* Check for cRLSign bit if keyUsage present */
+                        if ((issuer->ex_flags & EXFLAG_KUSAGE) &&
+                                !(issuer->ex_kusage & KU_CRL_SIGN))
+                                {
+                                ctx->error = X509_V_ERR_KEYUSAGE_NO_CRL_SIGN;
+                                ok = ctx->verify_cb(0, ctx);
+                                if(!ok) goto err;
+                                }
+
+                        if (!(ctx->current_crl_score & CRL_SCORE_SCOPE))
+                                {
+                                ctx->error = X509_V_ERR_DIFFERENT_CRL_SCOPE;
+                                ok = ctx->verify_cb(0, ctx);
+                                if(!ok) goto err;
+                                }
+
+                        if (!(ctx->current_crl_score & CRL_SCORE_SAME_PATH))
+                                {
+                                if (check_crl_path(ctx, ctx->current_issuer) <= 0)
+                                        {
+                                        ctx->error = X509_V_ERR_CRL_PATH_VALIDATION_ERROR;
+                                        ok = ctx->verify_cb(0, ctx);
+                                        if(!ok) goto err;
+                                        }
+                                }
+
+                        if (crl->idp_flags & IDP_INVALID)
+                                {
+                                ctx->error = X509_V_ERR_INVALID_EXTENSION;
+                                ok = ctx->verify_cb(0, ctx);
+                                if(!ok) goto err;
+                                }
+
+
+                        }
+
+                if (!(ctx->current_crl_score & CRL_SCORE_TIME))
+                        {
+                        ok = check_crl_time(ctx, crl, 1);
+                        if (!ok)
+                                goto err;
                         }
 
                 /* Attempt to get issuer certificate public key */
                 ikey = X509_get_pubkey(issuer);
 
                 if(!ikey)
                         {
                         ctx->error=X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY;
                         ok = ctx->verify_cb(0, ctx);
                         if (!ok) goto err;
                         }
                 else
                         {
                         /* Verify CRL signature */
                         if(X509_CRL_verify(crl, ikey) <= 0)
                                 {
                                 ctx->error=X509_V_ERR_CRL_SIGNATURE_FAILURE;
                                 ok = ctx->verify_cb(0, ctx);
                                 if (!ok) goto err;
                                 }
                         }
                 }
 
-        ok = check_crl_time(ctx, crl, 1);
-        if (!ok)
-                goto err;
-
         ok = 1;
 
         err:
         EVP_PKEY_free(ikey);
         return ok;
         }
 
 /* Check certificate against CRL */
 static int cert_crl(X509_STORE_CTX *ctx, X509_CRL *crl, X509 *x)
         {
-        int idx, ok;
-        X509_REVOKED rtmp;
-        STACK_OF(X509_EXTENSION) *exts;
-        X509_EXTENSION *ext;
-        /* Look for serial number of certificate in CRL */
-        rtmp.serialNumber = X509_get_serialNumber(x);
-        /* Sort revoked into serial number order if not already sorted.
-         * Do this under a lock to avoid race condition.
-         */
-        if (!sk_X509_REVOKED_is_sorted(crl->crl->revoked))
+        int ok;
+        X509_REVOKED *rev;
+        /* The rules changed for this... previously if a CRL contained
+         * unhandled critical extensions it could still be used to indicate
+         * a certificate was revoked. This has since been changed since 
+         * critical extension can change the meaning of CRL entries.
+         */
+        if (crl->flags & EXFLAG_CRITICAL)
                 {
-                CRYPTO_w_lock(CRYPTO_LOCK_X509_CRL);
-                sk_X509_REVOKED_sort(crl->crl->revoked);
-                CRYPTO_w_unlock(CRYPTO_LOCK_X509_CRL);
+                if (ctx->param->flags & X509_V_FLAG_IGNORE_CRITICAL)
+                        return 1;
+                ctx->error = X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION;
+                ok = ctx->verify_cb(0, ctx);
+                if(!ok)
+                        return 0;
                 }
-        idx = sk_X509_REVOKED_find(crl->crl->revoked, &rtmp);
-        /* If found assume revoked: want something cleverer than
-         * this to handle entry extensions in V2 CRLs.
+        /* Look for serial number of certificate in CRL
+         * If found make sure reason is not removeFromCRL.
          */
-        if(idx >= 0)
+        if (X509_CRL_get0_by_cert(crl, &rev, x))
                 {
+                if (rev->reason == CRL_REASON_REMOVE_FROM_CRL)
+                        return 2;
                 ctx->error = X509_V_ERR_CERT_REVOKED;
                 ok = ctx->verify_cb(0, ctx);
-                if (!ok) return 0;
+                if (!ok)
+                        return 0;
                 }
 
-        if (ctx->param->flags & X509_V_FLAG_IGNORE_CRITICAL)
-                return 1;
-
-        /* See if we have any critical CRL extensions: since we
-         * currently don't handle any CRL extensions the CRL must be
-         * rejected. 
-         * This code accesses the X509_CRL structure directly: applications
-         * shouldn't do this.
-         */
-
-        exts = crl->crl->extensions;
-
-        for (idx = 0; idx < sk_X509_EXTENSION_num(exts); idx++)
-                {
-                ext = sk_X509_EXTENSION_value(exts, idx);
-                if (ext->critical > 0)
-                        {
-                        ctx->error =
-                                X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION;
-                        ok = ctx->verify_cb(0, ctx);
-                        if(!ok) return 0;
-                        break;
-                        }
-                }
         return 1;
         }
 
 static int check_policy(X509_STORE_CTX *ctx)
         {
         int ret;
+        if (ctx->parent)
+                return 1;
         ret = X509_policy_check(&ctx->tree, &ctx->explicit_policy, ctx->chain,
                                 ctx->param->policies, ctx->param->flags);
         if (ret == 0)
                 {
                 X509err(X509_F_CHECK_POLICY,ERR_R_MALLOC_FAILURE);
                 return 0;
                 }
         /* Invalid or inconsistent extensions */
         if (ret == -1)
                 {
                 /* Locate certificates with bad extensions and notify
                  * callback.
                  */
                 X509 *x;
                 int i;
                 for (i = 1; i < sk_X509_num(ctx->chain); i++)
                         {
                         x = sk_X509_value(ctx->chain, i);
                         if (!(x->ex_flags & EXFLAG_INVALID_POLICY))
                                 continue;
                         ctx->current_cert = x;
                         ctx->error = X509_V_ERR_INVALID_POLICY_EXTENSION;
-                        ret = ctx->verify_cb(0, ctx);
+                        if(!ctx->verify_cb(0, ctx))
+                                return 0;
                         }
                 return 1;
                 }
         if (ret == -2)
                 {
                 ctx->current_cert = NULL;
                 ctx->error = X509_V_ERR_NO_EXPLICIT_POLICY;
                 return ctx->verify_cb(0, ctx);
                 }
 
@@ skipping 138 matching lines @@
                         {
                         xi=xs;
                         xs=sk_X509_value(ctx->chain,n);
                         }
                 }
         ok=1;
 end:
         return ok;
         }
 
-int X509_cmp_current_time(ASN1_TIME *ctm)
+int X509_cmp_current_time(const ASN1_TIME *ctm)
 {
         return X509_cmp_time(ctm, NULL);
 }
 
-int X509_cmp_time(ASN1_TIME *ctm, time_t *cmp_time)
+int X509_cmp_time(const ASN1_TIME *ctm, time_t *cmp_time)
         {
         char *str;
         ASN1_TIME atm;
         long offset;
         char buff1[24],buff2[24],*p;
         int i,j;
 
         p=buff1;
         i=ctm->length;
         str=(char *)ctm->data;
@@ skipping 34 matching lines @@
         else
                 {
                 if ((*str != '+') && (*str != '-'))
                         return 0;
                 offset=((str[1]-'0')*10+(str[2]-'0'))*60;
                 offset+=(str[3]-'0')*10+(str[4]-'0');
                 if (*str == '-')
                         offset= -offset;
                 }
         atm.type=ctm->type;
+        atm.flags = 0;
         atm.length=sizeof(buff2);
         atm.data=(unsigned char *)buff2;
 
-        if (X509_time_adj(&atm,-offset*60, cmp_time) == NULL)
+        if (X509_time_adj(&atm, offset*60, cmp_time) == NULL)
                 return 0;
 
         if (ctm->type == V_ASN1_UTCTIME)
                 {
                 i=(buff1[0]-'0')*10+(buff1[1]-'0');
                 if (i < 50) i+=100; /* cf. RFC 2459 */
                 j=(buff2[0]-'0')*10+(buff2[1]-'0');
                 if (j < 50) j+=100;
 
                 if (i < j) return -1;
                 if (i > j) return 1;
                 }
         i=strcmp(buff1,buff2);
         if (i == 0) /* wait a second then return younger :-) */
                 return -1;
         else
                 return i;
         }
 
 ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj)
 {
         return X509_time_adj(s, adj, NULL);
 }
 
-ASN1_TIME *X509_time_adj(ASN1_TIME *s, long adj, time_t *in_tm)
+ASN1_TIME *X509_time_adj(ASN1_TIME *s, long offset_sec, time_t *in_tm)
+        {
+        return X509_time_adj_ex(s, 0, offset_sec, in_tm);
+        }
+
+ASN1_TIME *X509_time_adj_ex(ASN1_TIME *s,
+                                int offset_day, long offset_sec, time_t *in_tm)
         {
         time_t t;
-        int type = -1;
 
         if (in_tm) t = *in_tm;
         else time(&t);
 
-        t+=adj;
-        if (s) type = s->type;
-        if (type == V_ASN1_UTCTIME) return ASN1_UTCTIME_set(s,t);
-        if (type == V_ASN1_GENERALIZEDTIME) return ASN1_GENERALIZEDTIME_set(s, t);
-        return ASN1_TIME_set(s, t);
+        if (s && !(s->flags & ASN1_STRING_FLAG_MSTRING))
+                {
+                if (s->type == V_ASN1_UTCTIME)
+                        return ASN1_UTCTIME_adj(s,t, offset_day, offset_sec);
+                if (s->type == V_ASN1_GENERALIZEDTIME)
+                        return ASN1_GENERALIZEDTIME_adj(s, t, offset_day,
+                                                                offset_sec);
+                }
+        return ASN1_TIME_adj(s, t, offset_day, offset_sec);
         }
 
 int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain)
         {
         EVP_PKEY *ktmp=NULL,*ktmp2;
         int i,j;
 
         if ((pkey != NULL) && !EVP_PKEY_missing_parameters(pkey)) return 1;
 
         for (i=0; i<sk_X509_num(chain); i++)
@@ skipping 82 matching lines @@
         STACK_OF(X509) *chain;
         if (!ctx->chain || !(chain = sk_X509_dup(ctx->chain))) return NULL;
         for (i = 0; i < sk_X509_num(chain); i++)
                 {
                 x = sk_X509_value(chain, i);
                 CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
                 }
         return chain;
         }
 
+X509 *X509_STORE_CTX_get0_current_issuer(X509_STORE_CTX *ctx)
+        {
+        return ctx->current_issuer;
+        }
+
+X509_CRL *X509_STORE_CTX_get0_current_crl(X509_STORE_CTX *ctx)
+        {
+        return ctx->current_crl;
+        }
+
+X509_STORE_CTX *X509_STORE_CTX_get0_parent_ctx(X509_STORE_CTX *ctx)
+        {
+        return ctx->parent;
+        }
+
 void X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *x)
         {
         ctx->cert=x;
         }
 
 void X509_STORE_CTX_set_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
         {
         ctx->untrusted=sk;
         }
 
@@ skipping 100 matching lines @@
         ctx->crls = NULL;
         ctx->last_untrusted=0;
         ctx->other_ctx=NULL;
         ctx->valid=0;
         ctx->chain=NULL;
         ctx->error=0;
         ctx->explicit_policy=0;
         ctx->error_depth=0;
         ctx->current_cert=NULL;
         ctx->current_issuer=NULL;
+        ctx->current_crl=NULL;
+        ctx->current_crl_score=0;
+        ctx->current_reasons=0;
         ctx->tree = NULL;
+        ctx->parent = NULL;
 
         ctx->param = X509_VERIFY_PARAM_new();
 
         if (!ctx->param)
                 {
                 X509err(X509_F_X509_STORE_CTX_INIT,ERR_R_MALLOC_FAILURE);
                 return 0;
                 }
 
         /* Inherit callbacks and flags from X509_STORE if not set
          * use defaults.
          */
 
 
         if (store)
                 ret = X509_VERIFY_PARAM_inherit(ctx->param, store->param);
         else
-                ctx->param->flags |= X509_VP_FLAG_DEFAULT|X509_VP_FLAG_ONCE;
+                ctx->param->inh_flags |= X509_VP_FLAG_DEFAULT|X509_VP_FLAG_ONCE;
 
         if (store)
                 {
                 ctx->verify_cb = store->verify_cb;
                 ctx->cleanup = store->cleanup;
                 }
         else
                 ctx->cleanup = 0;
 
         if (ret)
@@ skipping 27 matching lines @@
                 ctx->verify = internal_verify;
 
         if (store && store->check_revocation)
                 ctx->check_revocation = store->check_revocation;
         else
                 ctx->check_revocation = check_revocation;
 
         if (store && store->get_crl)
                 ctx->get_crl = store->get_crl;
         else
-                ctx->get_crl = get_crl;
+                ctx->get_crl = NULL;
 
         if (store && store->check_crl)
                 ctx->check_crl = store->check_crl;
         else
                 ctx->check_crl = check_crl;
 
         if (store && store->cert_crl)
                 ctx->cert_crl = store->cert_crl;
         else
                 ctx->cert_crl = cert_crl;
 
+        if (store && store->lookup_certs)
+                ctx->lookup_certs = store->lookup_certs;
+        else
+                ctx->lookup_certs = X509_STORE_get1_certs;
+
+        if (store && store->lookup_crls)
+                ctx->lookup_crls = store->lookup_crls;
+        else
+                ctx->lookup_crls = X509_STORE_get1_crls;
+
         ctx->check_policy = check_policy;
 
 
         /* This memset() can't make any sense anyway, so it's removed. As
          * X509_STORE_CTX_cleanup does a proper "free" on the ex_data, we put a
          * corresponding "new" here and remove this bogus initialisation. */
         /* memset(&(ctx->ex_data),0,sizeof(CRYPTO_EX_DATA)); */
         if(!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509_STORE_CTX, ctx,
                                 &(ctx->ex_data)))
                 {
@@ skipping 12 matching lines @@
 {
         ctx->other_ctx = sk;
         ctx->get_issuer = get_issuer_sk;
 }
 
 void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx)
         {
         if (ctx->cleanup) ctx->cleanup(ctx);
         if (ctx->param != NULL)
                 {
-                X509_VERIFY_PARAM_free(ctx->param);
+                if (ctx->parent == NULL)
+                        X509_VERIFY_PARAM_free(ctx->param);
                 ctx->param=NULL;
                 }
         if (ctx->tree != NULL)
                 {
                 X509_policy_tree_free(ctx->tree);
                 ctx->tree=NULL;
                 }
         if (ctx->chain != NULL)
                 {
                 sk_X509_pop_free(ctx->chain,X509_free);
@@ skipping 55 matching lines @@
         ctx->param = param;
         }
 
 IMPLEMENT_STACK_OF(X509)
 IMPLEMENT_ASN1_SET_OF(X509)
 
 IMPLEMENT_STACK_OF(X509_NAME)
 
 IMPLEMENT_STACK_OF(X509_ATTRIBUTE)
 IMPLEMENT_ASN1_SET_OF(X509_ATTRIBUTE)