test/crltest.c

   1 /*
   2  * Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include "../e_os.h"
  12 #include <string.h>
  13 #include <openssl/bio.h>
  14 #include <openssl/crypto.h>
  15 #include <openssl/err.h>
  16 #include <openssl/pem.h>
  17 #include <openssl/x509.h>
  18
  19 #include "testutil.h"
  20 #include "test_main.h"
  21
  22 #define PARAM_TIME 1474934400 /* Sep 27th, 2016 */
  23
  24 static const char *kCRLTestRoot[] = {
  25     "-----BEGIN CERTIFICATE-----\n",
  26     "MIIDbzCCAlegAwIBAgIJAODri7v0dDUFMA0GCSqGSIb3DQEBCwUAME4xCzAJBgNV\n",
  27     "BAYTAlVTMRMwEQYDVQQIDApDYWxpZm9ybmlhMRYwFAYDVQQHDA1Nb3VudGFpbiBW\n",
  28     "aWV3MRIwEAYDVQQKDAlCb3JpbmdTU0wwHhcNMTYwOTI2MTUwNjI2WhcNMjYwOTI0\n",
  29     "MTUwNjI2WjBOMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQG\n",
  30     "A1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJQm9yaW5nU1NMMIIBIjANBgkq\n",
  31     "hkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAo16WiLWZuaymsD8n5SKPmxV1y6jjgr3B\n",
  32     "S/dUBpbrzd1aeFzNlI8l2jfAnzUyp+I21RQ+nh/MhqjGElkTtK9xMn1Y+S9GMRh+\n",
  33     "5R/Du0iCb1tCZIPY07Tgrb0KMNWe0v2QKVVruuYSgxIWodBfxlKO64Z8AJ5IbnWp\n",
  34     "uRqO6rctN9qUoMlTIAB6dL4G0tDJ/PGFWOJYwOMEIX54bly2wgyYJVBKiRRt4f7n\n",
  35     "8H922qmvPNA9idmX9G1VAtgV6x97XXi7ULORIQvn9lVQF6nTYDBJhyuPB+mLThbL\n",
  36     "P2o9orxGx7aCtnnBZUIxUvHNOI0FaSaZH7Fi0xsZ/GkG2HZe7ImPJwIDAQABo1Aw\n",
  37     "TjAdBgNVHQ4EFgQUWPt3N5cZ/CRvubbrkqfBnAqhq94wHwYDVR0jBBgwFoAUWPt3\n",
  38     "N5cZ/CRvubbrkqfBnAqhq94wDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOC\n",
  39     "AQEAORu6M0MOwXy+3VEBwNilfTxyqDfruQsc1jA4PT8Oe8zora1WxE1JB4q2FJOz\n",
  40     "EAuM3H/NXvEnBuN+ITvKZAJUfm4NKX97qmjMJwLKWe1gVv+VQTr63aR7mgWJReQN\n",
  41     "XdMztlVeZs2dppV6uEg3ia1X0G7LARxGpA9ETbMyCpb39XxlYuTClcbA5ftDN99B\n",
  42     "3Xg9KNdd++Ew22O3HWRDvdDpTO/JkzQfzi3sYwUtzMEonENhczJhGf7bQMmvL/w5\n",
  43     "24Wxj4Z7KzzWIHsNqE/RIs6RV3fcW61j/mRgW2XyoWnMVeBzvcJr9NXp4VQYmFPw\n",
  44     "amd8GKMZQvP0ufGnUn7D7uartA==\n",
  45     "-----END CERTIFICATE-----\n",
  46     NULL
  47 };
  48
  49 static const char *kCRLTestLeaf[] = {
  50     "-----BEGIN CERTIFICATE-----\n",
  51     "MIIDkDCCAnigAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwTjELMAkGA1UEBhMCVVMx\n",
  52     "EzARBgNVBAgMCkNhbGlmb3JuaWExFjAUBgNVBAcMDU1vdW50YWluIFZpZXcxEjAQ\n",
  53     "BgNVBAoMCUJvcmluZ1NTTDAeFw0xNjA5MjYxNTA4MzFaFw0xNzA5MjYxNTA4MzFa\n",
  54     "MEsxCzAJBgNVBAYTAlVTMRMwEQYDVQQIDApDYWxpZm9ybmlhMRIwEAYDVQQKDAlC\n",
  55     "b3JpbmdTU0wxEzARBgNVBAMMCmJvcmluZy5zc2wwggEiMA0GCSqGSIb3DQEBAQUA\n",
  56     "A4IBDwAwggEKAoIBAQDc5v1S1M0W+QWM+raWfO0LH8uvqEwuJQgODqMaGnSlWUx9\n",
  57     "8iQcnWfjyPja3lWg9K62hSOFDuSyEkysKHDxijz5R93CfLcfnVXjWQDJe7EJTTDP\n",
  58     "ozEvxN6RjAeYv7CF000euYr3QT5iyBjg76+bon1p0jHZBJeNPP1KqGYgyxp+hzpx\n",
  59     "e0gZmTlGAXd8JQK4v8kpdYwD6PPifFL/jpmQpqOtQmH/6zcLjY4ojmqpEdBqIKIX\n",
  60     "+saA29hMq0+NK3K+wgg31RU+cVWxu3tLOIiesETkeDgArjWRS1Vkzbi4v9SJxtNu\n",
  61     "OZuAxWiynRJw3JwH/OFHYZIvQqz68ZBoj96cepjPAgMBAAGjezB5MAkGA1UdEwQC\n",
  62     "MAAwLAYJYIZIAYb4QgENBB8WHU9wZW5TU0wgR2VuZXJhdGVkIENlcnRpZmljYXRl\n",
  63     "MB0GA1UdDgQWBBTGn0OVVh/aoYt0bvEKG+PIERqnDzAfBgNVHSMEGDAWgBRY+3c3\n",
  64     "lxn8JG+5tuuSp8GcCqGr3jANBgkqhkiG9w0BAQsFAAOCAQEAd2nM8gCQN2Dc8QJw\n",
  65     "XSZXyuI3DBGGCHcay/3iXu0JvTC3EiQo8J6Djv7WLI0N5KH8mkm40u89fJAB2lLZ\n",
  66     "ShuHVtcC182bOKnePgwp9CNwQ21p0rDEu/P3X46ZvFgdxx82E9xLa0tBB8PiPDWh\n",
  67     "lV16jbaKTgX5AZqjnsyjR5o9/mbZVupZJXx5Syq+XA8qiJfstSYJs4KyKK9UOjql\n",
  68     "ICkJVKpi2ahDBqX4MOH4SLfzVk8pqSpviS6yaA1RXqjpkxiN45WWaXDldVHMSkhC\n",
  69     "5CNXsXi4b1nAntu89crwSLA3rEwzCWeYj+BX7e1T9rr3oJdwOU/2KQtW1js1yQUG\n",
  70     "tjJMFw==\n",
  71     "-----END CERTIFICATE-----\n",
  72     NULL
  73 };
  74
  75 static const char *kBasicCRL[] = {
  76     "-----BEGIN X509 CRL-----\n",
  77     "MIIBpzCBkAIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE\n",
  78     "CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ\n",
  79     "Qm9yaW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaoA4wDDAKBgNV\n",
  80     "HRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAnrBKKgvd9x9zwK9rtUvVeFeJ7+LN\n",
  81     "ZEAc+a5oxpPNEsJx6hXoApYEbzXMxuWBQoCs5iEBycSGudct21L+MVf27M38KrWo\n",
  82     "eOkq0a2siqViQZO2Fb/SUFR0k9zb8xl86Zf65lgPplALun0bV/HT7MJcl04Tc4os\n",
  83     "dsAReBs5nqTGNEd5AlC1iKHvQZkM//MD51DspKnDpsDiUVi54h9C1SpfZmX8H2Vv\n",
  84     "diyu0fZ/bPAM3VAGawatf/SyWfBMyKpoPXEG39oAzmjjOj8en82psn7m474IGaho\n",
  85     "/vBbhl1ms5qQiLYPjm4YELtnXQoFyC72tBjbdFd/ZE9k4CNKDbxFUXFbkw==\n",
  86     "-----END X509 CRL-----\n",
  87     NULL
  88 };
  89
  90 static const char *kRevokedCRL[] = {
  91     "-----BEGIN X509 CRL-----\n",
  92     "MIIBvjCBpwIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE\n",
  93     "CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ\n",
  94     "Qm9yaW5nU1NMFw0xNjA5MjYxNTEyNDRaFw0xNjEwMjYxNTEyNDRaMBUwEwICEAAX\n",
  95     "DTE2MDkyNjE1MTIyNlqgDjAMMAoGA1UdFAQDAgECMA0GCSqGSIb3DQEBCwUAA4IB\n",
  96     "AQCUGaM4DcWzlQKrcZvI8TMeR8BpsvQeo5BoI/XZu2a8h//PyRyMwYeaOM+3zl0d\n",
  97     "sjgCT8b3C1FPgT+P2Lkowv7rJ+FHJRNQkogr+RuqCSPTq65ha4WKlRGWkMFybzVH\n",
  98     "NloxC+aU3lgp/NlX9yUtfqYmJek1CDrOOGPrAEAwj1l/BUeYKNGqfBWYJQtPJu+5\n",
  99     "OaSvIYGpETCZJscUWODmLEb/O3DM438vLvxonwGqXqS0KX37+CHpUlyhnSovxXxp\n",
 100     "Pz4aF+L7OtczxL0GYtD2fR9B7TDMqsNmHXgQrixvvOY7MUdLGbd4RfJL3yA53hyO\n",
 101     "xzfKY2TzxLiOmctG0hXFkH5J\n",
 102     "-----END X509 CRL-----\n",
 103     NULL
 104 };
 105
 106 static const char *kBadIssuerCRL[] = {
 107     "-----BEGIN X509 CRL-----\n",
 108     "MIIBwjCBqwIBATANBgkqhkiG9w0BAQsFADBSMQswCQYDVQQGEwJVUzETMBEGA1UE\n",
 109     "CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzEWMBQGA1UECgwN\n",
 110     "Tm90IEJvcmluZ1NTTBcNMTYwOTI2MTUxMjQ0WhcNMTYxMDI2MTUxMjQ0WjAVMBMC\n",
 111     "AhAAFw0xNjA5MjYxNTEyMjZaoA4wDDAKBgNVHRQEAwIBAjANBgkqhkiG9w0BAQsF\n",
 112     "AAOCAQEAlBmjOA3Fs5UCq3GbyPEzHkfAabL0HqOQaCP12btmvIf/z8kcjMGHmjjP\n",
 113     "t85dHbI4Ak/G9wtRT4E/j9i5KML+6yfhRyUTUJKIK/kbqgkj06uuYWuFipURlpDB\n",
 114     "cm81RzZaMQvmlN5YKfzZV/clLX6mJiXpNQg6zjhj6wBAMI9ZfwVHmCjRqnwVmCUL\n",
 115     "TybvuTmkryGBqREwmSbHFFjg5ixG/ztwzON/Ly78aJ8Bql6ktCl9+/gh6VJcoZ0q\n",
 116     "L8V8aT8+Ghfi+zrXM8S9BmLQ9n0fQe0wzKrDZh14EK4sb7zmOzFHSxm3eEXyS98g\n",
 117     "Od4cjsc3ymNk88S4jpnLRtIVxZB+SQ==\n",
 118     "-----END X509 CRL-----\n",
 119     NULL
 120 };
 121
 122 /*
 123  * This is kBasicCRL but with a critical issuing distribution point
 124  * extension.
 125  */
 126 static const char *kKnownCriticalCRL[] = {
 127     "-----BEGIN X509 CRL-----\n",
 128     "MIIBujCBowIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE\n",
 129     "CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ\n",
 130     "Qm9yaW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaoCEwHzAKBgNV\n",
 131     "HRQEAwIBATARBgNVHRwBAf8EBzAFoQMBAf8wDQYJKoZIhvcNAQELBQADggEBAA+3\n",
 132     "i+5e5Ub8sccfgOBs6WVJFI9c8gvJjrJ8/dYfFIAuCyeocs7DFXn1n13CRZ+URR/Q\n",
 133     "mVWgU28+xeusuSPYFpd9cyYTcVyNUGNTI3lwgcE/yVjPaOmzSZKdPakApRxtpKKQ\n",
 134     "NN/56aQz3bnT/ZSHQNciRB8U6jiD9V30t0w+FDTpGaG+7bzzUH3UVF9xf9Ctp60A\n",
 135     "3mfLe0scas7owSt4AEFuj2SPvcE7yvdOXbu+IEv21cEJUVExJAbhvIweHXh6yRW+\n",
 136     "7VVeiNzdIjkZjyTmAzoXGha4+wbxXyBRbfH+XWcO/H+8nwyG8Gktdu2QB9S9nnIp\n",
 137     "o/1TpfOMSGhMyMoyPrk=\n",
 138     "-----END X509 CRL-----\n",
 139     NULL
 140 };
 141
 142 /*
 143  * kUnknownCriticalCRL is kBasicCRL but with an unknown critical extension.
 144  */
 145 static const char *kUnknownCriticalCRL[] = {
 146     "-----BEGIN X509 CRL-----\n",
 147     "MIIBvDCBpQIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE\n",
 148     "CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ\n",
 149     "Qm9yaW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaoCMwITAKBgNV\n",
 150     "HRQEAwIBATATBgwqhkiG9xIEAYS3CQABAf8EADANBgkqhkiG9w0BAQsFAAOCAQEA\n",
 151     "GvBP0xqL509InMj/3493YVRV+ldTpBv5uTD6jewzf5XdaxEQ/VjTNe5zKnxbpAib\n",
 152     "Kf7cwX0PMSkZjx7k7kKdDlEucwVvDoqC+O9aJcqVmM6GDyNb9xENxd0XCXja6MZC\n",
 153     "yVgP4AwLauB2vSiEprYJyI1APph3iAEeDm60lTXX/wBM/tupQDDujKh2GPyvBRfJ\n",
 154     "+wEDwGg3ICwvu4gO4zeC5qnFR+bpL9t5tOMAQnVZ0NWv+k7mkd2LbHdD44dxrfXC\n",
 155     "nhtfERx99SDmC/jtUAJrGhtCO8acr7exCeYcduN7KKCm91OeCJKK6OzWst0Og1DB\n",
 156     "kwzzU2rL3G65CrZ7H0SZsQ==\n",
 157     "-----END X509 CRL-----\n",
 158     NULL
 159 };
 160
 161 /*
 162  * kUnknownCriticalCRL2 is kBasicCRL but with a critical issuing distribution
 163  * point extension followed by an unknown critical extension
 164  */
 165 static const char *kUnknownCriticalCRL2[] = {
 166     "-----BEGIN X509 CRL-----\n",
 167     "MIIBzzCBuAIBATANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJVUzETMBEGA1UE\n",
 168     "CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzESMBAGA1UECgwJ\n",
 169     "Qm9yaW5nU1NMFw0xNjA5MjYxNTEwNTVaFw0xNjEwMjYxNTEwNTVaoDYwNDAKBgNV\n",
 170     "HRQEAwIBATARBgNVHRwBAf8EBzAFoQMBAf8wEwYMKoZIhvcSBAGEtwkAAQH/BAAw\n",
 171     "DQYJKoZIhvcNAQELBQADggEBACTcpQC8jXL12JN5YzOcQ64ubQIe0XxRAd30p7qB\n",
 172     "BTXGpgqBjrjxRfLms7EBYodEXB2oXMsDq3km0vT1MfYdsDD05S+SQ9CDsq/pUfaC\n",
 173     "E2WNI5p8WircRnroYvbN2vkjlRbMd1+yNITohXYXCJwjEOAWOx3XIM10bwPYBv4R\n",
 174     "rDobuLHoMgL3yHgMHmAkP7YpkBucNqeBV8cCdeAZLuhXFWi6yfr3r/X18yWbC/r2\n",
 175     "2xXdkrSqXLFo7ToyP8YKTgiXpya4x6m53biEYwa2ULlas0igL6DK7wjYZX95Uy7H\n",
 176     "GKljn9weIYiMPV/BzGymwfv2EW0preLwtyJNJPaxbdin6Jc=\n",
 177     "-----END X509 CRL-----\n",
 178     NULL
 179 };
 180
 181
 182 /*
 183  * Glue an array of strings together.  Return a BIO and put the string
 184  * into |*out| so we can free it.
 185  */
 186 static BIO *glue(const char **pem, char **out)
 187 {
 188     char *dest;
 189     int i;
 190     size_t s = 0;
 191
 192     /* Glue the strings together. */
 193     for (i = 0; pem[i] != NULL; ++i)
 194         s += strlen(pem[i]);
 195     dest = *out = OPENSSL_malloc(s + 1);
 196     if (dest == NULL)
 197         return NULL;
 198     for (i = 0; pem[i] != NULL; ++i)
 199         dest += strlen(strcpy(dest, pem[i]));
 200     return BIO_new_mem_buf(*out, s);
 201 }
 202
 203 /*
 204  * Create a CRL from an array of strings.
 205  */
 206 static X509_CRL *CRL_from_strings(const char **pem)
 207 {
 208     char *p;
 209     BIO *b = glue(pem, &p);
 210     X509_CRL *crl = PEM_read_bio_X509_CRL(b, NULL, NULL, NULL);
 211
 212     OPENSSL_free(p);
 213     BIO_free(b);
 214     return crl;
 215 }
 216
 217 /*
 218  * Create an X509 from an array of strings.
 219  */
 220 static X509 *X509_from_strings(const char **pem)
 221 {
 222     char *p;
 223     BIO *b = glue(pem, &p);
 224     X509 *x = PEM_read_bio_X509(b, NULL, NULL, NULL);
 225
 226     OPENSSL_free(p);
 227     BIO_free(b);
 228     return x;
 229 }
 230
 231 /*
 232  * Verify |leaf| certificate (chained up to |root|).  |crls| if
 233  * not NULL, is a list of CRLs to include in the verification. It is
 234  * also free'd before returning, which is kinda yucky but convenient.
 235  * Returns a value from X509_V_ERR_xxx or X509_V_OK.
 236  */
 237 static int verify(X509 *leaf, X509 *root, STACK_OF(X509_CRL) *crls,
 238                   unsigned long flags)
 239 {
 240     X509_STORE_CTX *ctx = X509_STORE_CTX_new();
 241     X509_STORE *store = X509_STORE_new();
 242     X509_VERIFY_PARAM *param = X509_VERIFY_PARAM_new();
 243     STACK_OF(X509) *roots = sk_X509_new_null();
 244     int status = X509_V_ERR_UNSPECIFIED;
 245
 246     if (!TEST_ptr(ctx))
 247         goto err;
 248     if (!TEST_ptr(store))
 249         goto err;
 250     if (!TEST_ptr(param))
 251         goto err;
 252     if (!TEST_ptr(roots))
 253         goto err;
 254
 255     /* Create a stack; upref the cert because we free it below. */
 256     X509_up_ref(root);
 257     if (!TEST_true(sk_X509_push(roots, root)))
 258         goto err;
 259
 260     if (!TEST_true(X509_STORE_CTX_init(ctx, store, leaf, NULL)))
 261         goto err;
 262     X509_STORE_CTX_set0_trusted_stack(ctx, roots);
 263     X509_STORE_CTX_set0_crls(ctx, crls);
 264     X509_VERIFY_PARAM_set_time(param, PARAM_TIME);
 265     if (!TEST_long_eq(X509_VERIFY_PARAM_get_time(param), PARAM_TIME)) {
 266         TEST_info("set_time/get_time mismatch.");
 267         goto err;
 268     }
 269     X509_VERIFY_PARAM_set_depth(param, 16);
 270     if (flags)
 271         X509_VERIFY_PARAM_set_flags(param, flags);
 272     X509_STORE_CTX_set0_param(ctx, param);
 273
 274     ERR_clear_error();
 275     status = X509_verify_cert(ctx) == 1 ? X509_V_OK
 276                                         : X509_STORE_CTX_get_error(ctx);
 277 err:
 278     sk_X509_pop_free(roots, X509_free);
 279     sk_X509_CRL_pop_free(crls, X509_CRL_free);
 280     X509_STORE_CTX_free(ctx);
 281     X509_STORE_free(store);
 282     return status;
 283 }
 284
 285 /*
 286  * Create a stack of CRL's.  Upref each one because we call pop_free on
 287  * the stack and need to keep the CRL's around until the test exits.
 288  * Yes this crashes on malloc failure; it forces us to debug.
 289  */
 290 static STACK_OF(X509_CRL) *make_CRL_stack(X509_CRL *x1, X509_CRL *x2)
 291 {
 292     STACK_OF(X509_CRL) *sk = sk_X509_CRL_new_null();
 293
 294     sk_X509_CRL_push(sk, x1);
 295     X509_CRL_up_ref(x1);
 296     if (x2 != NULL) {
 297         sk_X509_CRL_push(sk, x2);
 298         X509_CRL_up_ref(x2);
 299     }
 300     return sk;
 301 }
 302
 303 static int test_crl()
 304 {
 305     X509 *root = X509_from_strings(kCRLTestRoot);
 306     X509 *leaf = X509_from_strings(kCRLTestLeaf);
 307     X509_CRL *basic_crl = CRL_from_strings(kBasicCRL);
 308     X509_CRL *revoked_crl = CRL_from_strings(kRevokedCRL);
 309     X509_CRL *bad_issuer_crl = CRL_from_strings(kBadIssuerCRL);
 310     X509_CRL *known_critical_crl = CRL_from_strings(kKnownCriticalCRL);
 311     X509_CRL *unknown_critical_crl = CRL_from_strings(kUnknownCriticalCRL);
 312     X509_CRL *unknown_critical_crl2 = CRL_from_strings(kUnknownCriticalCRL2);
 313     int status = 0;
 314
 315     if (!TEST_ptr(root))
 316         goto err;
 317     if (!TEST_ptr(leaf))
 318         goto err;
 319     if (!TEST_ptr(basic_crl))
 320         goto err;
 321     if (!TEST_ptr(revoked_crl))
 322         goto err;
 323     if (!TEST_ptr(bad_issuer_crl))
 324         goto err;
 325     if (!TEST_ptr(known_critical_crl))
 326         goto err;
 327     if (!TEST_ptr(unknown_critical_crl))
 328         goto err;
 329     if (!TEST_ptr(unknown_critical_crl2))
 330         goto err;
 331
 332     if (verify(leaf, root, make_CRL_stack(basic_crl, NULL),
 333                X509_V_FLAG_CRL_CHECK) != X509_V_OK) {
 334         TEST_info("Cert with CRL didn't verify.");
 335         goto err;
 336     }
 337
 338     if (verify(leaf, root, make_CRL_stack(basic_crl, revoked_crl),
 339                X509_V_FLAG_CRL_CHECK) != X509_V_ERR_CERT_REVOKED) {
 340         TEST_info("Revoked CRL wasn't checked.");
 341         goto err;
 342     }
 343
 344     if (verify(leaf, root, NULL,
 345                X509_V_FLAG_CRL_CHECK) != X509_V_ERR_UNABLE_TO_GET_CRL) {
 346         TEST_info("CRLs were not required.");
 347         goto err;
 348     }
 349
 350     if (verify(leaf, root, make_CRL_stack(bad_issuer_crl, NULL),
 351                X509_V_FLAG_CRL_CHECK) != X509_V_ERR_UNABLE_TO_GET_CRL) {
 352         TEST_info("Bad CRL issuer was unnoticed.");
 353         goto err;
 354     }
 355
 356     if (verify(leaf, root, make_CRL_stack(known_critical_crl, NULL),
 357                X509_V_FLAG_CRL_CHECK) != X509_V_OK) {
 358         TEST_info("CRL with known critical extension was rejected.");
 359         goto err;
 360     }
 361
 362     if (verify(leaf, root, make_CRL_stack(unknown_critical_crl, NULL),
 363                X509_V_FLAG_CRL_CHECK) !=
 364             X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION) {
 365         TEST_info("CRL with unknown critical extension was accepted.");
 366         goto err;
 367     }
 368
 369     if (verify(leaf, root, make_CRL_stack(unknown_critical_crl2, NULL),
 370                X509_V_FLAG_CRL_CHECK) !=
 371             X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION) {
 372         TEST_info("CRL with unknown critical extension (2) was accepted.");
 373         goto err;
 374     }
 375
 376     status = 1;
 377
 378 err:
 379     X509_free(root);
 380     X509_free(leaf);
 381     X509_CRL_free(basic_crl);
 382     X509_CRL_free(revoked_crl);
 383     X509_CRL_free(bad_issuer_crl);
 384     X509_CRL_free(known_critical_crl);
 385     X509_CRL_free(unknown_critical_crl);
 386     X509_CRL_free(unknown_critical_crl2);
 387     return status;
 388 }
 389
 390 void register_tests(void)
 391 {
 392     ADD_TEST(test_crl);
 393 }