crypto/cms: add CAdES-BES signed attributes validation
[openssl.git] / crypto / ess / ess_lib.c
1 /*
2  * Copyright 2019-2020 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 <string.h>
11 #include <openssl/x509v3.h>
12 #include <openssl/err.h>
13 #include <openssl/ess.h>
14 #include "crypto/ess.h"
15
16 DEFINE_STACK_OF(ESS_CERT_ID)
17 DEFINE_STACK_OF(ESS_CERT_ID_V2)
18 DEFINE_STACK_OF(GENERAL_NAME)
19 DEFINE_STACK_OF(X509)
20
21 static ESS_CERT_ID *ESS_CERT_ID_new_init(X509 *cert, int issuer_needed);
22 static ESS_CERT_ID_V2 *ESS_CERT_ID_V2_new_init(const EVP_MD *hash_alg,
23                                                X509 *cert, int issuer_needed);
24
25 ESS_SIGNING_CERT *ESS_SIGNING_CERT_new_init(X509 *signcert,
26                                             STACK_OF(X509) *certs,
27                                             int issuer_needed)
28 {
29     ESS_CERT_ID *cid = NULL;
30     ESS_SIGNING_CERT *sc;
31     int i;
32
33     if ((sc = ESS_SIGNING_CERT_new()) == NULL)
34         goto err;
35     if (sc->cert_ids == NULL
36         && (sc->cert_ids = sk_ESS_CERT_ID_new_null()) == NULL)
37         goto err;
38
39     if ((cid = ESS_CERT_ID_new_init(signcert, issuer_needed)) == NULL
40         || !sk_ESS_CERT_ID_push(sc->cert_ids, cid))
41         goto err;
42     for (i = 0; i < sk_X509_num(certs); ++i) {
43         X509 *cert = sk_X509_value(certs, i);
44         if ((cid = ESS_CERT_ID_new_init(cert, 1)) == NULL
45             || !sk_ESS_CERT_ID_push(sc->cert_ids, cid))
46             goto err;
47     }
48
49     return sc;
50  err:
51     ESS_SIGNING_CERT_free(sc);
52     ESS_CERT_ID_free(cid);
53     ESSerr(ESS_F_ESS_SIGNING_CERT_NEW_INIT, ERR_R_MALLOC_FAILURE);
54     return NULL;
55 }
56
57 static ESS_CERT_ID *ESS_CERT_ID_new_init(X509 *cert, int issuer_needed)
58 {
59     ESS_CERT_ID *cid = NULL;
60     GENERAL_NAME *name = NULL;
61     unsigned char cert_sha1[SHA_DIGEST_LENGTH];
62
63     /* Call for side-effect of computing hash and caching extensions */
64     if (!X509v3_cache_extensions(cert, NULL, NULL))
65         return NULL;
66
67     if ((cid = ESS_CERT_ID_new()) == NULL)
68         goto err;
69     /* TODO(3.0): fetch sha1 algorithm from providers */
70     if (!X509_digest(cert, EVP_sha1(), cert_sha1, NULL))
71         goto err;
72     if (!ASN1_OCTET_STRING_set(cid->hash, cert_sha1, SHA_DIGEST_LENGTH))
73         goto err;
74
75     /* Setting the issuer/serial if requested. */
76     if (!issuer_needed)
77         return cid;
78
79     if (cid->issuer_serial == NULL
80         && (cid->issuer_serial = ESS_ISSUER_SERIAL_new()) == NULL)
81         goto err;
82     if ((name = GENERAL_NAME_new()) == NULL)
83         goto err;
84     name->type = GEN_DIRNAME;
85     if ((name->d.dirn = X509_NAME_dup(X509_get_issuer_name(cert))) == NULL)
86         goto err;
87     if (!sk_GENERAL_NAME_push(cid->issuer_serial->issuer, name))
88         goto err;
89     name = NULL;            /* Ownership is lost. */
90     ASN1_INTEGER_free(cid->issuer_serial->serial);
91     if ((cid->issuer_serial->serial =
92           ASN1_INTEGER_dup(X509_get_serialNumber(cert))) == NULL)
93         goto err;
94
95     return cid;
96  err:
97     GENERAL_NAME_free(name);
98     ESS_CERT_ID_free(cid);
99     ESSerr(ESS_F_ESS_CERT_ID_NEW_INIT, ERR_R_MALLOC_FAILURE);
100     return NULL;
101 }
102
103 ESS_SIGNING_CERT_V2 *ESS_SIGNING_CERT_V2_new_init(const EVP_MD *hash_alg,
104                                                   X509 *signcert,
105                                                   STACK_OF(X509) *certs,
106                                                   int issuer_needed)
107 {
108     ESS_CERT_ID_V2 *cid = NULL;
109     ESS_SIGNING_CERT_V2 *sc;
110     int i;
111
112     if ((sc = ESS_SIGNING_CERT_V2_new()) == NULL)
113         goto err;
114     if ((cid = ESS_CERT_ID_V2_new_init(hash_alg, signcert, issuer_needed)) == NULL)
115         goto err;
116     if (!sk_ESS_CERT_ID_V2_push(sc->cert_ids, cid))
117         goto err;
118     cid = NULL;
119
120     for (i = 0; i < sk_X509_num(certs); ++i) {
121         X509 *cert = sk_X509_value(certs, i);
122
123         if ((cid = ESS_CERT_ID_V2_new_init(hash_alg, cert, 1)) == NULL)
124             goto err;
125         if (!sk_ESS_CERT_ID_V2_push(sc->cert_ids, cid))
126             goto err;
127         cid = NULL;
128     }
129
130     return sc;
131  err:
132     ESS_SIGNING_CERT_V2_free(sc);
133     ESS_CERT_ID_V2_free(cid);
134     ESSerr(ESS_F_ESS_SIGNING_CERT_V2_NEW_INIT, ERR_R_MALLOC_FAILURE);
135     return NULL;
136 }
137
138 static ESS_CERT_ID_V2 *ESS_CERT_ID_V2_new_init(const EVP_MD *hash_alg,
139                                                X509 *cert, int issuer_needed)
140 {
141     ESS_CERT_ID_V2 *cid;
142     GENERAL_NAME *name = NULL;
143     unsigned char hash[EVP_MAX_MD_SIZE];
144     unsigned int hash_len = sizeof(hash);
145     X509_ALGOR *alg = NULL;
146
147     memset(hash, 0, sizeof(hash));
148
149     if ((cid = ESS_CERT_ID_V2_new()) == NULL)
150         goto err;
151
152     if (hash_alg != EVP_sha256()) {
153         alg = X509_ALGOR_new();
154         if (alg == NULL)
155             goto err;
156         X509_ALGOR_set_md(alg, hash_alg);
157         if (alg->algorithm == NULL)
158             goto err;
159         cid->hash_alg = alg;
160         alg = NULL;
161     } else {
162         cid->hash_alg = NULL;
163     }
164
165     /* TODO(3.0): fetch sha1 algorithm from providers */
166     if (!X509_digest(cert, hash_alg, hash, &hash_len))
167         goto err;
168
169     if (!ASN1_OCTET_STRING_set(cid->hash, hash, hash_len))
170         goto err;
171
172     if (!issuer_needed)
173         return cid;
174
175     if ((cid->issuer_serial = ESS_ISSUER_SERIAL_new()) == NULL)
176         goto err;
177     if ((name = GENERAL_NAME_new()) == NULL)
178         goto err;
179     name->type = GEN_DIRNAME;
180     if ((name->d.dirn = X509_NAME_dup(X509_get_issuer_name(cert))) == NULL)
181         goto err;
182     if (!sk_GENERAL_NAME_push(cid->issuer_serial->issuer, name))
183         goto err;
184     name = NULL;            /* Ownership is lost. */
185     ASN1_INTEGER_free(cid->issuer_serial->serial);
186     cid->issuer_serial->serial = ASN1_INTEGER_dup(X509_get_serialNumber(cert));
187     if (cid->issuer_serial->serial == NULL)
188         goto err;
189
190     return cid;
191  err:
192     X509_ALGOR_free(alg);
193     GENERAL_NAME_free(name);
194     ESS_CERT_ID_V2_free(cid);
195     ESSerr(ESS_F_ESS_CERT_ID_V2_NEW_INIT, ERR_R_MALLOC_FAILURE);
196     return NULL;
197 }
198
199 ESS_SIGNING_CERT *ESS_SIGNING_CERT_get(PKCS7_SIGNER_INFO *si)
200 {
201     ASN1_TYPE *attr;
202     const unsigned char *p;
203
204     attr = PKCS7_get_signed_attribute(si, NID_id_smime_aa_signingCertificate);
205     if (attr == NULL)
206         return NULL;
207     p = attr->value.sequence->data;
208     return d2i_ESS_SIGNING_CERT(NULL, &p, attr->value.sequence->length);
209 }
210
211 ESS_SIGNING_CERT_V2 *ESS_SIGNING_CERT_V2_get(PKCS7_SIGNER_INFO *si)
212 {
213     ASN1_TYPE *attr;
214     const unsigned char *p;
215
216     attr = PKCS7_get_signed_attribute(si, NID_id_smime_aa_signingCertificateV2);
217     if (attr == NULL)
218         return NULL;
219     p = attr->value.sequence->data;
220     return d2i_ESS_SIGNING_CERT_V2(NULL, &p, attr->value.sequence->length);
221 }
222
223 int ESS_SIGNING_CERT_add(PKCS7_SIGNER_INFO *si, ESS_SIGNING_CERT *sc)
224 {
225     ASN1_STRING *seq = NULL;
226     unsigned char *p, *pp = NULL;
227     int len;
228
229     len = i2d_ESS_SIGNING_CERT(sc, NULL);
230     if ((pp = OPENSSL_malloc(len)) == NULL) {
231         ESSerr(ESS_F_ESS_SIGNING_CERT_ADD, ERR_R_MALLOC_FAILURE);
232         goto err;
233     }
234     p = pp;
235     i2d_ESS_SIGNING_CERT(sc, &p);
236     if ((seq = ASN1_STRING_new()) == NULL || !ASN1_STRING_set(seq, pp, len)) {
237         ESSerr(ESS_F_ESS_SIGNING_CERT_ADD, ERR_R_MALLOC_FAILURE);
238         goto err;
239     }
240     OPENSSL_free(pp);
241     pp = NULL;
242     return PKCS7_add_signed_attribute(si,
243                                       NID_id_smime_aa_signingCertificate,
244                                       V_ASN1_SEQUENCE, seq);
245  err:
246     ASN1_STRING_free(seq);
247     OPENSSL_free(pp);
248
249     return 0;
250 }
251
252 int ESS_SIGNING_CERT_V2_add(PKCS7_SIGNER_INFO *si,
253                             ESS_SIGNING_CERT_V2 *sc)
254 {
255     ASN1_STRING *seq = NULL;
256     unsigned char *p, *pp = NULL;
257     int len = i2d_ESS_SIGNING_CERT_V2(sc, NULL);
258
259     if ((pp = OPENSSL_malloc(len)) == NULL) {
260         ESSerr(ESS_F_ESS_SIGNING_CERT_V2_ADD, ERR_R_MALLOC_FAILURE);
261         goto err;
262     }
263
264     p = pp;
265     i2d_ESS_SIGNING_CERT_V2(sc, &p);
266     if ((seq = ASN1_STRING_new()) == NULL || !ASN1_STRING_set(seq, pp, len)) {
267         ESSerr(ESS_F_ESS_SIGNING_CERT_V2_ADD, ERR_R_MALLOC_FAILURE);
268         goto err;
269     }
270
271     OPENSSL_free(pp);
272     pp = NULL;
273     return PKCS7_add_signed_attribute(si,
274                                       NID_id_smime_aa_signingCertificateV2,
275                                       V_ASN1_SEQUENCE, seq);
276  err:
277     ASN1_STRING_free(seq);
278     OPENSSL_free(pp);
279     return 0;
280 }
281
282 static int ess_issuer_serial_cmp(const ESS_ISSUER_SERIAL *is, const X509 *cert)
283 {
284     GENERAL_NAME *issuer;
285
286     if (is == NULL || cert == NULL || sk_GENERAL_NAME_num(is->issuer) != 1)
287         return -1;
288
289     issuer = sk_GENERAL_NAME_value(is->issuer, 0);
290     if (issuer->type != GEN_DIRNAME
291         || X509_NAME_cmp(issuer->d.dirn, X509_get_issuer_name(cert)) != 0)
292         return -1;
293
294     return ASN1_INTEGER_cmp(is->serial, X509_get0_serialNumber(cert));
295 }
296
297 /* Returns < 0 if certificate is not found, certificate index otherwise. */
298 int ess_find_cert(const STACK_OF(ESS_CERT_ID) *cert_ids, X509 *cert)
299 {
300     int i;
301     unsigned char cert_sha1[SHA_DIGEST_LENGTH];
302
303     if (cert_ids == NULL || cert == NULL)
304         return -1;
305
306     /* Recompute SHA1 hash of certificate if necessary (side effect). */
307     if (!X509v3_cache_extensions(cert, NULL, NULL))
308         return -1;
309
310     /* TODO(3.0): fetch sha1 algorithm from providers */
311     if (!X509_digest(cert, EVP_sha1(), cert_sha1, NULL))
312         return -1;
313
314     /* Look for cert in the cert_ids vector. */
315     for (i = 0; i < sk_ESS_CERT_ID_num(cert_ids); ++i) {
316         const ESS_CERT_ID *cid = sk_ESS_CERT_ID_value(cert_ids, i);
317
318         if (cid->hash->length == SHA_DIGEST_LENGTH
319             && memcmp(cid->hash->data, cert_sha1, SHA_DIGEST_LENGTH) == 0) {
320             const ESS_ISSUER_SERIAL *is = cid->issuer_serial;
321
322             if (is == NULL || ess_issuer_serial_cmp(is, cert) == 0)
323                 return i;
324         }
325     }
326
327     return -1;
328 }
329
330 /* Returns < 0 if certificate is not found, certificate index otherwise. */
331 int ess_find_cert_v2(const STACK_OF(ESS_CERT_ID_V2) *cert_ids, const X509 *cert)
332 {
333     int i;
334     unsigned char cert_digest[EVP_MAX_MD_SIZE];
335     unsigned int len;
336
337     /* Look for cert in the cert_ids vector. */
338     for (i = 0; i < sk_ESS_CERT_ID_V2_num(cert_ids); ++i) {
339         const ESS_CERT_ID_V2 *cid = sk_ESS_CERT_ID_V2_value(cert_ids, i);
340         const EVP_MD *md;
341
342         if (cid != NULL && cid->hash_alg != NULL)
343             md = EVP_get_digestbyobj(cid->hash_alg->algorithm);
344         else
345             md = EVP_sha256();
346
347         /* TODO(3.0): fetch sha1 algorithm from providers */
348         if (!X509_digest(cert, md, cert_digest, &len))
349             return -1;
350
351         if (cid->hash->length != (int)len)
352             return -1;
353
354         if (memcmp(cid->hash->data, cert_digest, cid->hash->length) == 0) {
355             const ESS_ISSUER_SERIAL *is = cid->issuer_serial;
356
357             if (is == NULL || ess_issuer_serial_cmp(is, cert) == 0)
358                 return i;
359         }
360     }
361
362     return -1;
363 }