1/*
2 * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (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 "internal/cryptlib.h"
12#include <openssl/asn1t.h>
13#include <openssl/x509.h>
14#include "crypto/x509.h"
15#include <openssl/x509v3.h>
16#include "x509_local.h"
17
18static int X509_REVOKED_cmp(const X509_REVOKED *const *a,
19                            const X509_REVOKED *const *b);
20static int setup_idp(X509_CRL *crl, ISSUING_DIST_POINT *idp);
21
22ASN1_SEQUENCE(X509_REVOKED) = {
23        ASN1_EMBED(X509_REVOKED,serialNumber, ASN1_INTEGER),
24        ASN1_SIMPLE(X509_REVOKED,revocationDate, ASN1_TIME),
25        ASN1_SEQUENCE_OF_OPT(X509_REVOKED,extensions, X509_EXTENSION)
26} ASN1_SEQUENCE_END(X509_REVOKED)
27
28static int def_crl_verify(X509_CRL *crl, EVP_PKEY *r);
29static int def_crl_lookup(X509_CRL *crl,
30                          X509_REVOKED **ret, const ASN1_INTEGER *serial,
31                          const X509_NAME *issuer);
32
33static X509_CRL_METHOD int_crl_meth = {
34    0,
35    0, 0,
36    def_crl_lookup,
37    def_crl_verify
38};
39
40static const X509_CRL_METHOD *default_crl_method = &int_crl_meth;
41
42/*
43 * The X509_CRL_INFO structure needs a bit of customisation. Since we cache
44 * the original encoding the signature won't be affected by reordering of the
45 * revoked field.
46 */
47static int crl_inf_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
48                      void *exarg)
49{
50    X509_CRL_INFO *a = (X509_CRL_INFO *)*pval;
51
52    if (!a || !a->revoked)
53        return 1;
54    switch (operation) {
55        /*
56         * Just set cmp function here. We don't sort because that would
57         * affect the output of X509_CRL_print().
58         */
59    case ASN1_OP_D2I_POST:
60        (void)sk_X509_REVOKED_set_cmp_func(a->revoked, X509_REVOKED_cmp);
61        break;
62    }
63    return 1;
64}
65
66
67ASN1_SEQUENCE_enc(X509_CRL_INFO, enc, crl_inf_cb) = {
68        ASN1_OPT(X509_CRL_INFO, version, ASN1_INTEGER),
69        ASN1_EMBED(X509_CRL_INFO, sig_alg, X509_ALGOR),
70        ASN1_SIMPLE(X509_CRL_INFO, issuer, X509_NAME),
71        ASN1_SIMPLE(X509_CRL_INFO, lastUpdate, ASN1_TIME),
72        ASN1_OPT(X509_CRL_INFO, nextUpdate, ASN1_TIME),
73        ASN1_SEQUENCE_OF_OPT(X509_CRL_INFO, revoked, X509_REVOKED),
74        ASN1_EXP_SEQUENCE_OF_OPT(X509_CRL_INFO, extensions, X509_EXTENSION, 0)
75} ASN1_SEQUENCE_END_enc(X509_CRL_INFO, X509_CRL_INFO)
76
77/*
78 * Set CRL entry issuer according to CRL certificate issuer extension. Check
79 * for unhandled critical CRL entry extensions.
80 */
81
82static int crl_set_issuers(X509_CRL *crl)
83{
84
85    int i, j;
86    GENERAL_NAMES *gens, *gtmp;
87    STACK_OF(X509_REVOKED) *revoked;
88
89    revoked = X509_CRL_get_REVOKED(crl);
90
91    gens = NULL;
92    for (i = 0; i < sk_X509_REVOKED_num(revoked); i++) {
93        X509_REVOKED *rev = sk_X509_REVOKED_value(revoked, i);
94        STACK_OF(X509_EXTENSION) *exts;
95        ASN1_ENUMERATED *reason;
96        X509_EXTENSION *ext;
97        gtmp = X509_REVOKED_get_ext_d2i(rev,
98                                        NID_certificate_issuer, &j, NULL);
99        if (!gtmp && (j != -1)) {
100            crl->flags |= EXFLAG_INVALID;
101            return 1;
102        }
103
104        if (gtmp) {
105            gens = gtmp;
106            if (crl->issuers == NULL) {
107                crl->issuers = sk_GENERAL_NAMES_new_null();
108                if (crl->issuers == NULL) {
109                    GENERAL_NAMES_free(gtmp);
110                    return 0;
111                }
112            }
113            if (!sk_GENERAL_NAMES_push(crl->issuers, gtmp)) {
114                GENERAL_NAMES_free(gtmp);
115                return 0;
116            }
117        }
118        rev->issuer = gens;
119
120        reason = X509_REVOKED_get_ext_d2i(rev, NID_crl_reason, &j, NULL);
121        if (!reason && (j != -1)) {
122            crl->flags |= EXFLAG_INVALID;
123            return 1;
124        }
125
126        if (reason) {
127            rev->reason = ASN1_ENUMERATED_get(reason);
128            ASN1_ENUMERATED_free(reason);
129        } else
130            rev->reason = CRL_REASON_NONE;
131
132        /* Check for critical CRL entry extensions */
133
134        exts = rev->extensions;
135
136        for (j = 0; j < sk_X509_EXTENSION_num(exts); j++) {
137            ext = sk_X509_EXTENSION_value(exts, j);
138            if (X509_EXTENSION_get_critical(ext)) {
139                if (OBJ_obj2nid(X509_EXTENSION_get_object(ext)) == NID_certificate_issuer)
140                    continue;
141                crl->flags |= EXFLAG_CRITICAL;
142                break;
143            }
144        }
145
146    }
147
148    return 1;
149
150}
151
152/*
153 * The X509_CRL structure needs a bit of customisation. Cache some extensions
154 * and hash of the whole CRL or set EXFLAG_NO_FINGERPRINT if this fails.
155 */
156static int crl_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
157                  void *exarg)
158{
159    X509_CRL *crl = (X509_CRL *)*pval;
160    STACK_OF(X509_EXTENSION) *exts;
161    X509_EXTENSION *ext;
162    int idx, i;
163
164    switch (operation) {
165    case ASN1_OP_D2I_PRE:
166        if (crl->meth->crl_free) {
167            if (!crl->meth->crl_free(crl))
168                return 0;
169        }
170        AUTHORITY_KEYID_free(crl->akid);
171        ISSUING_DIST_POINT_free(crl->idp);
172        ASN1_INTEGER_free(crl->crl_number);
173        ASN1_INTEGER_free(crl->base_crl_number);
174        sk_GENERAL_NAMES_pop_free(crl->issuers, GENERAL_NAMES_free);
175        /* fall thru */
176
177    case ASN1_OP_NEW_POST:
178        crl->idp = NULL;
179        crl->akid = NULL;
180        crl->flags = 0;
181        crl->idp_flags = 0;
182        crl->idp_reasons = CRLDP_ALL_REASONS;
183        crl->meth = default_crl_method;
184        crl->meth_data = NULL;
185        crl->issuers = NULL;
186        crl->crl_number = NULL;
187        crl->base_crl_number = NULL;
188        break;
189
190    case ASN1_OP_D2I_POST:
191        if (!X509_CRL_digest(crl, EVP_sha1(), crl->sha1_hash, NULL))
192            crl->flags |= EXFLAG_NO_FINGERPRINT;
193        crl->idp = X509_CRL_get_ext_d2i(crl,
194                                        NID_issuing_distribution_point, &i,
195                                        NULL);
196        if (crl->idp != NULL) {
197            if (!setup_idp(crl, crl->idp))
198                crl->flags |= EXFLAG_INVALID;
199        }
200        else if (i != -1) {
201            crl->flags |= EXFLAG_INVALID;
202        }
203
204        crl->akid = X509_CRL_get_ext_d2i(crl,
205                                         NID_authority_key_identifier, &i,
206                                         NULL);
207        if (crl->akid == NULL && i != -1)
208            crl->flags |= EXFLAG_INVALID;
209
210        crl->crl_number = X509_CRL_get_ext_d2i(crl,
211                                               NID_crl_number, &i, NULL);
212        if (crl->crl_number == NULL && i != -1)
213            crl->flags |= EXFLAG_INVALID;
214
215        crl->base_crl_number = X509_CRL_get_ext_d2i(crl,
216                                                    NID_delta_crl, &i,
217                                                    NULL);
218        if (crl->base_crl_number == NULL && i != -1)
219            crl->flags |= EXFLAG_INVALID;
220        /* Delta CRLs must have CRL number */
221        if (crl->base_crl_number && !crl->crl_number)
222            crl->flags |= EXFLAG_INVALID;
223
224        /*
225         * See if we have any unhandled critical CRL extensions and indicate
226         * this in a flag. We only currently handle IDP so anything else
227         * critical sets the flag. This code accesses the X509_CRL structure
228         * directly: applications shouldn't do this.
229         */
230
231        exts = crl->crl.extensions;
232
233        for (idx = 0; idx < sk_X509_EXTENSION_num(exts); idx++) {
234            int nid;
235            ext = sk_X509_EXTENSION_value(exts, idx);
236            nid = OBJ_obj2nid(X509_EXTENSION_get_object(ext));
237            if (nid == NID_freshest_crl)
238                crl->flags |= EXFLAG_FRESHEST;
239            if (X509_EXTENSION_get_critical(ext)) {
240                /* We handle IDP and deltas */
241                if ((nid == NID_issuing_distribution_point)
242                    || (nid == NID_authority_key_identifier)
243                    || (nid == NID_delta_crl))
244                    continue;
245                crl->flags |= EXFLAG_CRITICAL;
246                break;
247            }
248        }
249
250        if (!crl_set_issuers(crl))
251            return 0;
252
253        if (crl->meth->crl_init) {
254            if (crl->meth->crl_init(crl) == 0)
255                return 0;
256        }
257
258        crl->flags |= EXFLAG_SET;
259        break;
260
261    case ASN1_OP_FREE_POST:
262        if (crl->meth != NULL && crl->meth->crl_free != NULL) {
263            if (!crl->meth->crl_free(crl))
264                return 0;
265        }
266        AUTHORITY_KEYID_free(crl->akid);
267        ISSUING_DIST_POINT_free(crl->idp);
268        ASN1_INTEGER_free(crl->crl_number);
269        ASN1_INTEGER_free(crl->base_crl_number);
270        sk_GENERAL_NAMES_pop_free(crl->issuers, GENERAL_NAMES_free);
271        OPENSSL_free(crl->propq);
272        break;
273    case ASN1_OP_DUP_POST:
274        {
275            X509_CRL *old = exarg;
276
277            if (!ossl_x509_crl_set0_libctx(crl, old->libctx, old->propq))
278                return 0;
279        }
280        break;
281    }
282    return 1;
283}
284
285/* Convert IDP into a more convenient form */
286
287static int setup_idp(X509_CRL *crl, ISSUING_DIST_POINT *idp)
288{
289    int idp_only = 0;
290
291    /* Set various flags according to IDP */
292    crl->idp_flags |= IDP_PRESENT;
293    if (idp->onlyuser > 0) {
294        idp_only++;
295        crl->idp_flags |= IDP_ONLYUSER;
296    }
297    if (idp->onlyCA > 0) {
298        idp_only++;
299        crl->idp_flags |= IDP_ONLYCA;
300    }
301    if (idp->onlyattr > 0) {
302        idp_only++;
303        crl->idp_flags |= IDP_ONLYATTR;
304    }
305
306    if (idp_only > 1)
307        crl->idp_flags |= IDP_INVALID;
308
309    if (idp->indirectCRL > 0)
310        crl->idp_flags |= IDP_INDIRECT;
311
312    if (idp->onlysomereasons) {
313        crl->idp_flags |= IDP_REASONS;
314        if (idp->onlysomereasons->length > 0)
315            crl->idp_reasons = idp->onlysomereasons->data[0];
316        if (idp->onlysomereasons->length > 1)
317            crl->idp_reasons |= (idp->onlysomereasons->data[1] << 8);
318        crl->idp_reasons &= CRLDP_ALL_REASONS;
319    }
320
321    return DIST_POINT_set_dpname(idp->distpoint, X509_CRL_get_issuer(crl));
322}
323
324ASN1_SEQUENCE_ref(X509_CRL, crl_cb) = {
325        ASN1_EMBED(X509_CRL, crl, X509_CRL_INFO),
326        ASN1_EMBED(X509_CRL, sig_alg, X509_ALGOR),
327        ASN1_EMBED(X509_CRL, signature, ASN1_BIT_STRING)
328} ASN1_SEQUENCE_END_ref(X509_CRL, X509_CRL)
329
330IMPLEMENT_ASN1_FUNCTIONS(X509_REVOKED)
331
332IMPLEMENT_ASN1_DUP_FUNCTION(X509_REVOKED)
333
334IMPLEMENT_ASN1_FUNCTIONS(X509_CRL_INFO)
335
336IMPLEMENT_ASN1_FUNCTIONS(X509_CRL)
337
338IMPLEMENT_ASN1_DUP_FUNCTION(X509_CRL)
339
340static int X509_REVOKED_cmp(const X509_REVOKED *const *a,
341                            const X509_REVOKED *const *b)
342{
343    return (ASN1_STRING_cmp((ASN1_STRING *)&(*a)->serialNumber,
344                            (ASN1_STRING *)&(*b)->serialNumber));
345}
346
347X509_CRL *X509_CRL_new_ex(OSSL_LIB_CTX *libctx, const char *propq)
348{
349    X509_CRL *crl = NULL;
350
351    crl = (X509_CRL *)ASN1_item_new((X509_CRL_it()));
352    if (!ossl_x509_crl_set0_libctx(crl, libctx, propq)) {
353        X509_CRL_free(crl);
354        crl = NULL;
355    }
356    return crl;
357}
358
359int X509_CRL_add0_revoked(X509_CRL *crl, X509_REVOKED *rev)
360{
361    X509_CRL_INFO *inf;
362
363    inf = &crl->crl;
364    if (inf->revoked == NULL)
365        inf->revoked = sk_X509_REVOKED_new(X509_REVOKED_cmp);
366    if (inf->revoked == NULL || !sk_X509_REVOKED_push(inf->revoked, rev)) {
367        ERR_raise(ERR_LIB_ASN1, ERR_R_MALLOC_FAILURE);
368        return 0;
369    }
370    inf->enc.modified = 1;
371    return 1;
372}
373
374int X509_CRL_verify(X509_CRL *crl, EVP_PKEY *r)
375{
376    if (crl->meth->crl_verify)
377        return crl->meth->crl_verify(crl, r);
378    return 0;
379}
380
381int X509_CRL_get0_by_serial(X509_CRL *crl,
382                            X509_REVOKED **ret, const ASN1_INTEGER *serial)
383{
384    if (crl->meth->crl_lookup)
385        return crl->meth->crl_lookup(crl, ret, serial, NULL);
386    return 0;
387}
388
389int X509_CRL_get0_by_cert(X509_CRL *crl, X509_REVOKED **ret, X509 *x)
390{
391    if (crl->meth->crl_lookup)
392        return crl->meth->crl_lookup(crl, ret,
393                                     X509_get0_serialNumber(x),
394                                     X509_get_issuer_name(x));
395    return 0;
396}
397
398static int def_crl_verify(X509_CRL *crl, EVP_PKEY *r)
399{
400    return ASN1_item_verify_ex(ASN1_ITEM_rptr(X509_CRL_INFO),
401                               &crl->sig_alg, &crl->signature, &crl->crl, NULL,
402                               r, crl->libctx, crl->propq);
403}
404
405static int crl_revoked_issuer_match(X509_CRL *crl, const X509_NAME *nm,
406                                    X509_REVOKED *rev)
407{
408    int i;
409
410    if (!rev->issuer) {
411        if (!nm)
412            return 1;
413        if (!X509_NAME_cmp(nm, X509_CRL_get_issuer(crl)))
414            return 1;
415        return 0;
416    }
417
418    if (!nm)
419        nm = X509_CRL_get_issuer(crl);
420
421    for (i = 0; i < sk_GENERAL_NAME_num(rev->issuer); i++) {
422        GENERAL_NAME *gen = sk_GENERAL_NAME_value(rev->issuer, i);
423        if (gen->type != GEN_DIRNAME)
424            continue;
425        if (!X509_NAME_cmp(nm, gen->d.directoryName))
426            return 1;
427    }
428    return 0;
429
430}
431
432static int def_crl_lookup(X509_CRL *crl,
433                          X509_REVOKED **ret, const ASN1_INTEGER *serial,
434                          const X509_NAME *issuer)
435{
436    X509_REVOKED rtmp, *rev;
437    int idx, num;
438
439    if (crl->crl.revoked == NULL)
440        return 0;
441
442    /*
443     * Sort revoked into serial number order if not already sorted. Do this
444     * under a lock to avoid race condition.
445     */
446    if (!sk_X509_REVOKED_is_sorted(crl->crl.revoked)) {
447        if (!CRYPTO_THREAD_write_lock(crl->lock))
448            return 0;
449        sk_X509_REVOKED_sort(crl->crl.revoked);
450        CRYPTO_THREAD_unlock(crl->lock);
451    }
452    rtmp.serialNumber = *serial;
453    idx = sk_X509_REVOKED_find(crl->crl.revoked, &rtmp);
454    if (idx < 0)
455        return 0;
456    /* Need to look for matching name */
457    for (num = sk_X509_REVOKED_num(crl->crl.revoked); idx < num; idx++) {
458        rev = sk_X509_REVOKED_value(crl->crl.revoked, idx);
459        if (ASN1_INTEGER_cmp(&rev->serialNumber, serial))
460            return 0;
461        if (crl_revoked_issuer_match(crl, issuer, rev)) {
462            if (ret)
463                *ret = rev;
464            if (rev->reason == CRL_REASON_REMOVE_FROM_CRL)
465                return 2;
466            return 1;
467        }
468    }
469    return 0;
470}
471
472void X509_CRL_set_default_method(const X509_CRL_METHOD *meth)
473{
474    if (meth == NULL)
475        default_crl_method = &int_crl_meth;
476    else
477        default_crl_method = meth;
478}
479
480X509_CRL_METHOD *X509_CRL_METHOD_new(int (*crl_init) (X509_CRL *crl),
481                                     int (*crl_free) (X509_CRL *crl),
482                                     int (*crl_lookup) (X509_CRL *crl,
483                                                        X509_REVOKED **ret,
484                                                        const ASN1_INTEGER *ser,
485                                                        const X509_NAME *issuer),
486                                     int (*crl_verify) (X509_CRL *crl,
487                                                        EVP_PKEY *pk))
488{
489    X509_CRL_METHOD *m = OPENSSL_malloc(sizeof(*m));
490
491    if (m == NULL) {
492        ERR_raise(ERR_LIB_X509, ERR_R_MALLOC_FAILURE);
493        return NULL;
494    }
495    m->crl_init = crl_init;
496    m->crl_free = crl_free;
497    m->crl_lookup = crl_lookup;
498    m->crl_verify = crl_verify;
499    m->flags = X509_CRL_METHOD_DYNAMIC;
500    return m;
501}
502
503void X509_CRL_METHOD_free(X509_CRL_METHOD *m)
504{
505    if (m == NULL || !(m->flags & X509_CRL_METHOD_DYNAMIC))
506        return;
507    OPENSSL_free(m);
508}
509
510void X509_CRL_set_meth_data(X509_CRL *crl, void *dat)
511{
512    crl->meth_data = dat;
513}
514
515void *X509_CRL_get_meth_data(X509_CRL *crl)
516{
517    return crl->meth_data;
518}
519
520int ossl_x509_crl_set0_libctx(X509_CRL *x, OSSL_LIB_CTX *libctx,
521                              const char *propq)
522{
523    if (x != NULL) {
524        x->libctx = libctx;
525        OPENSSL_free(x->propq);
526        x->propq = NULL;
527        if (propq != NULL) {
528            x->propq = OPENSSL_strdup(propq);
529            if (x->propq == NULL)
530                return 0;
531        }
532    }
533    return 1;
534}
535