crypto/cms: add CAdES-BES signed attributes validation
[openssl.git] / crypto / ts / ts_rsp_verify.c
1 /*
2  * Copyright 2006-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 <stdio.h>
11 #include "internal/cryptlib.h"
12 #include <openssl/objects.h>
13 #include <openssl/ts.h>
14 #include <openssl/pkcs7.h>
15 #include "ts_local.h"
16 #include "crypto/ess.h"
17
18 DEFINE_STACK_OF(PKCS7_SIGNER_INFO)
19 DEFINE_STACK_OF(X509)
20 DEFINE_STACK_OF(ESS_CERT_ID)
21 DEFINE_STACK_OF(ESS_CERT_ID_V2)
22 DEFINE_STACK_OF(ASN1_UTF8STRING)
23 DEFINE_STACK_OF(GENERAL_NAME)
24
25 static int ts_verify_cert(X509_STORE *store, STACK_OF(X509) *untrusted,
26                           X509 *signer, STACK_OF(X509) **chain);
27 static int ts_check_signing_certs(PKCS7_SIGNER_INFO *si,
28                                   STACK_OF(X509) *chain);
29
30 static int int_ts_RESP_verify_token(TS_VERIFY_CTX *ctx,
31                                     PKCS7 *token, TS_TST_INFO *tst_info);
32 static int ts_check_status_info(TS_RESP *response);
33 static char *ts_get_status_text(STACK_OF(ASN1_UTF8STRING) *text);
34 static int ts_check_policy(const ASN1_OBJECT *req_oid,
35                            const TS_TST_INFO *tst_info);
36 static int ts_compute_imprint(BIO *data, TS_TST_INFO *tst_info,
37                               X509_ALGOR **md_alg,
38                               unsigned char **imprint, unsigned *imprint_len);
39 static int ts_check_imprints(X509_ALGOR *algor_a,
40                              const unsigned char *imprint_a, unsigned len_a,
41                              TS_TST_INFO *tst_info);
42 static int ts_check_nonces(const ASN1_INTEGER *a, TS_TST_INFO *tst_info);
43 static int ts_check_signer_name(GENERAL_NAME *tsa_name, X509 *signer);
44 static int ts_find_name(STACK_OF(GENERAL_NAME) *gen_names,
45                         GENERAL_NAME *name);
46
47 /*
48  * This must be large enough to hold all values in ts_status_text (with
49  * comma separator) or all text fields in ts_failure_info (also with comma).
50  */
51 #define TS_STATUS_BUF_SIZE      256
52
53 /*
54  * Local mapping between response codes and descriptions.
55  */
56 static const char *ts_status_text[] = {
57     "granted",
58     "grantedWithMods",
59     "rejection",
60     "waiting",
61     "revocationWarning",
62     "revocationNotification"
63 };
64
65 #define TS_STATUS_TEXT_SIZE     OSSL_NELEM(ts_status_text)
66
67 static struct {
68     int code;
69     const char *text;
70 } ts_failure_info[] = {
71     {TS_INFO_BAD_ALG, "badAlg"},
72     {TS_INFO_BAD_REQUEST, "badRequest"},
73     {TS_INFO_BAD_DATA_FORMAT, "badDataFormat"},
74     {TS_INFO_TIME_NOT_AVAILABLE, "timeNotAvailable"},
75     {TS_INFO_UNACCEPTED_POLICY, "unacceptedPolicy"},
76     {TS_INFO_UNACCEPTED_EXTENSION, "unacceptedExtension"},
77     {TS_INFO_ADD_INFO_NOT_AVAILABLE, "addInfoNotAvailable"},
78     {TS_INFO_SYSTEM_FAILURE, "systemFailure"}
79 };
80
81
82 /*-
83  * This function carries out the following tasks:
84  *      - Checks if there is one and only one signer.
85  *      - Search for the signing certificate in 'certs' and in the response.
86  *      - Check the extended key usage and key usage fields of the signer
87  *      certificate (done by the path validation).
88  *      - Build and validate the certificate path.
89  *      - Check if the certificate path meets the requirements of the
90  *      SigningCertificate ESS signed attribute.
91  *      - Verify the signature value.
92  *      - Returns the signer certificate in 'signer', if 'signer' is not NULL.
93  */
94 int TS_RESP_verify_signature(PKCS7 *token, STACK_OF(X509) *certs,
95                              X509_STORE *store, X509 **signer_out)
96 {
97     STACK_OF(PKCS7_SIGNER_INFO) *sinfos = NULL;
98     PKCS7_SIGNER_INFO *si;
99     STACK_OF(X509) *signers = NULL;
100     X509 *signer;
101     STACK_OF(X509) *chain = NULL;
102     char buf[4096];
103     int i, j = 0, ret = 0;
104     BIO *p7bio = NULL;
105
106     /* Some sanity checks first. */
107     if (!token) {
108         TSerr(TS_F_TS_RESP_VERIFY_SIGNATURE, TS_R_INVALID_NULL_POINTER);
109         goto err;
110     }
111     if (!PKCS7_type_is_signed(token)) {
112         TSerr(TS_F_TS_RESP_VERIFY_SIGNATURE, TS_R_WRONG_CONTENT_TYPE);
113         goto err;
114     }
115     sinfos = PKCS7_get_signer_info(token);
116     if (!sinfos || sk_PKCS7_SIGNER_INFO_num(sinfos) != 1) {
117         TSerr(TS_F_TS_RESP_VERIFY_SIGNATURE, TS_R_THERE_MUST_BE_ONE_SIGNER);
118         goto err;
119     }
120     si = sk_PKCS7_SIGNER_INFO_value(sinfos, 0);
121     if (PKCS7_get_detached(token)) {
122         TSerr(TS_F_TS_RESP_VERIFY_SIGNATURE, TS_R_NO_CONTENT);
123         goto err;
124     }
125
126     /*
127      * Get hold of the signer certificate, search only internal certificates
128      * if it was requested.
129      */
130     signers = PKCS7_get0_signers(token, certs, 0);
131     if (!signers || sk_X509_num(signers) != 1)
132         goto err;
133     signer = sk_X509_value(signers, 0);
134
135     if (!ts_verify_cert(store, certs, signer, &chain))
136         goto err;
137     if (!ts_check_signing_certs(si, chain))
138         goto err;
139     p7bio = PKCS7_dataInit(token, NULL);
140
141     /* We now have to 'read' from p7bio to calculate digests etc. */
142     while ((i = BIO_read(p7bio, buf, sizeof(buf))) > 0)
143         continue;
144
145     j = PKCS7_signatureVerify(p7bio, token, si, signer);
146     if (j <= 0) {
147         TSerr(TS_F_TS_RESP_VERIFY_SIGNATURE, TS_R_SIGNATURE_FAILURE);
148         goto err;
149     }
150
151     if (signer_out) {
152         *signer_out = signer;
153         X509_up_ref(signer);
154     }
155     ret = 1;
156
157  err:
158     BIO_free_all(p7bio);
159     sk_X509_pop_free(chain, X509_free);
160     sk_X509_free(signers);
161
162     return ret;
163 }
164
165 /*
166  * The certificate chain is returned in chain. Caller is responsible for
167  * freeing the vector.
168  */
169 static int ts_verify_cert(X509_STORE *store, STACK_OF(X509) *untrusted,
170                           X509 *signer, STACK_OF(X509) **chain)
171 {
172     X509_STORE_CTX *cert_ctx = NULL;
173     int i;
174     int ret = 0;
175
176     *chain = NULL;
177     cert_ctx = X509_STORE_CTX_new();
178     if (cert_ctx == NULL) {
179         TSerr(TS_F_TS_VERIFY_CERT, ERR_R_MALLOC_FAILURE);
180         goto err;
181     }
182     if (!X509_STORE_CTX_init(cert_ctx, store, signer, untrusted))
183         goto end;
184     X509_STORE_CTX_set_purpose(cert_ctx, X509_PURPOSE_TIMESTAMP_SIGN);
185     i = X509_verify_cert(cert_ctx);
186     if (i <= 0) {
187         int j = X509_STORE_CTX_get_error(cert_ctx);
188         TSerr(TS_F_TS_VERIFY_CERT, TS_R_CERTIFICATE_VERIFY_ERROR);
189         ERR_add_error_data(2, "Verify error:",
190                            X509_verify_cert_error_string(j));
191         goto err;
192     }
193     *chain = X509_STORE_CTX_get1_chain(cert_ctx);
194     ret = 1;
195     goto end;
196
197 err:
198     ret = 0;
199
200 end:
201     X509_STORE_CTX_free(cert_ctx);
202     return ret;
203 }
204
205 static int ts_check_signing_certs(PKCS7_SIGNER_INFO *si,
206                                   STACK_OF(X509) *chain)
207 {
208     ESS_SIGNING_CERT *ss = ESS_SIGNING_CERT_get(si);
209     STACK_OF(ESS_CERT_ID) *cert_ids = NULL;
210     ESS_SIGNING_CERT_V2 *ssv2 = ESS_SIGNING_CERT_V2_get(si);
211     STACK_OF(ESS_CERT_ID_V2) *cert_ids_v2 = NULL;
212     X509 *cert;
213     int i = 0;
214     int ret = 0;
215
216     if (ss != NULL) {
217         cert_ids = ss->cert_ids;
218         cert = sk_X509_value(chain, 0);
219         if (ess_find_cert(cert_ids, cert) != 0)
220             goto err;
221
222         /*
223          * Check the other certificates of the chain if there are more than one
224          * certificate ids in cert_ids.
225          */
226         if (sk_ESS_CERT_ID_num(cert_ids) > 1) {
227             for (i = 1; i < sk_X509_num(chain); ++i) {
228                 cert = sk_X509_value(chain, i);
229                 if (ess_find_cert(cert_ids, cert) < 0)
230                     goto err;
231             }
232         }
233     } else if (ssv2 != NULL) {
234         cert_ids_v2 = ssv2->cert_ids;
235         cert = sk_X509_value(chain, 0);
236         if (ess_find_cert_v2(cert_ids_v2, cert) != 0)
237             goto err;
238
239         /*
240          * Check the other certificates of the chain if there are more than one
241          * certificate ids in cert_ids.
242          */
243         if (sk_ESS_CERT_ID_V2_num(cert_ids_v2) > 1) {
244             for (i = 1; i < sk_X509_num(chain); ++i) {
245                 cert = sk_X509_value(chain, i);
246                 if (ess_find_cert_v2(cert_ids_v2, cert) < 0)
247                     goto err;
248             }
249         }
250     } else {
251         goto err;
252     }
253
254     ret = 1;
255  err:
256     if (!ret)
257         TSerr(TS_F_TS_CHECK_SIGNING_CERTS,
258               TS_R_ESS_SIGNING_CERTIFICATE_ERROR);
259     ESS_SIGNING_CERT_free(ss);
260     ESS_SIGNING_CERT_V2_free(ssv2);
261     return ret;
262 }
263
264 /*-
265  * Verifies whether 'response' contains a valid response with regards
266  * to the settings of the context:
267  *      - Gives an error message if the TS_TST_INFO is not present.
268  *      - Calls _TS_RESP_verify_token to verify the token content.
269  */
270 int TS_RESP_verify_response(TS_VERIFY_CTX *ctx, TS_RESP *response)
271 {
272     PKCS7 *token = response->token;
273     TS_TST_INFO *tst_info = response->tst_info;
274     int ret = 0;
275
276     if (!ts_check_status_info(response))
277         goto err;
278     if (!int_ts_RESP_verify_token(ctx, token, tst_info))
279         goto err;
280     ret = 1;
281
282  err:
283     return ret;
284 }
285
286 /*
287  * Tries to extract a TS_TST_INFO structure from the PKCS7 token and
288  * calls the internal int_TS_RESP_verify_token function for verifying it.
289  */
290 int TS_RESP_verify_token(TS_VERIFY_CTX *ctx, PKCS7 *token)
291 {
292     TS_TST_INFO *tst_info = PKCS7_to_TS_TST_INFO(token);
293     int ret = 0;
294     if (tst_info) {
295         ret = int_ts_RESP_verify_token(ctx, token, tst_info);
296         TS_TST_INFO_free(tst_info);
297     }
298     return ret;
299 }
300
301 /*-
302  * Verifies whether the 'token' contains a valid time stamp token
303  * with regards to the settings of the context. Only those checks are
304  * carried out that are specified in the context:
305  *      - Verifies the signature of the TS_TST_INFO.
306  *      - Checks the version number of the response.
307  *      - Check if the requested and returned policies math.
308  *      - Check if the message imprints are the same.
309  *      - Check if the nonces are the same.
310  *      - Check if the TSA name matches the signer.
311  *      - Check if the TSA name is the expected TSA.
312  */
313 static int int_ts_RESP_verify_token(TS_VERIFY_CTX *ctx,
314                                     PKCS7 *token, TS_TST_INFO *tst_info)
315 {
316     X509 *signer = NULL;
317     GENERAL_NAME *tsa_name = tst_info->tsa;
318     X509_ALGOR *md_alg = NULL;
319     unsigned char *imprint = NULL;
320     unsigned imprint_len = 0;
321     int ret = 0;
322     int flags = ctx->flags;
323
324     /* Some options require us to also check the signature */
325     if (((flags & TS_VFY_SIGNER) && tsa_name != NULL)
326             || (flags & TS_VFY_TSA_NAME)) {
327         flags |= TS_VFY_SIGNATURE;
328     }
329
330     if ((flags & TS_VFY_SIGNATURE)
331         && !TS_RESP_verify_signature(token, ctx->certs, ctx->store, &signer))
332         goto err;
333     if ((flags & TS_VFY_VERSION)
334         && TS_TST_INFO_get_version(tst_info) != 1) {
335         TSerr(TS_F_INT_TS_RESP_VERIFY_TOKEN, TS_R_UNSUPPORTED_VERSION);
336         goto err;
337     }
338     if ((flags & TS_VFY_POLICY)
339         && !ts_check_policy(ctx->policy, tst_info))
340         goto err;
341     if ((flags & TS_VFY_IMPRINT)
342         && !ts_check_imprints(ctx->md_alg, ctx->imprint, ctx->imprint_len,
343                               tst_info))
344         goto err;
345     if ((flags & TS_VFY_DATA)
346         && (!ts_compute_imprint(ctx->data, tst_info,
347                                 &md_alg, &imprint, &imprint_len)
348             || !ts_check_imprints(md_alg, imprint, imprint_len, tst_info)))
349         goto err;
350     if ((flags & TS_VFY_NONCE)
351         && !ts_check_nonces(ctx->nonce, tst_info))
352         goto err;
353     if ((flags & TS_VFY_SIGNER)
354         && tsa_name && !ts_check_signer_name(tsa_name, signer)) {
355         TSerr(TS_F_INT_TS_RESP_VERIFY_TOKEN, TS_R_TSA_NAME_MISMATCH);
356         goto err;
357     }
358     if ((flags & TS_VFY_TSA_NAME)
359         && !ts_check_signer_name(ctx->tsa_name, signer)) {
360         TSerr(TS_F_INT_TS_RESP_VERIFY_TOKEN, TS_R_TSA_UNTRUSTED);
361         goto err;
362     }
363     ret = 1;
364
365  err:
366     X509_free(signer);
367     X509_ALGOR_free(md_alg);
368     OPENSSL_free(imprint);
369     return ret;
370 }
371
372 static int ts_check_status_info(TS_RESP *response)
373 {
374     TS_STATUS_INFO *info = response->status_info;
375     long status = ASN1_INTEGER_get(info->status);
376     const char *status_text = NULL;
377     char *embedded_status_text = NULL;
378     char failure_text[TS_STATUS_BUF_SIZE] = "";
379
380     if (status == 0 || status == 1)
381         return 1;
382
383     /* There was an error, get the description in status_text. */
384     if (0 <= status && status < (long) OSSL_NELEM(ts_status_text))
385         status_text = ts_status_text[status];
386     else
387         status_text = "unknown code";
388
389     if (sk_ASN1_UTF8STRING_num(info->text) > 0
390         && (embedded_status_text = ts_get_status_text(info->text)) == NULL)
391         return 0;
392
393     /* Fill in failure_text with the failure information. */
394     if (info->failure_info) {
395         int i;
396         int first = 1;
397         for (i = 0; i < (int)OSSL_NELEM(ts_failure_info); ++i) {
398             if (ASN1_BIT_STRING_get_bit(info->failure_info,
399                                         ts_failure_info[i].code)) {
400                 if (!first)
401                     strcat(failure_text, ",");
402                 else
403                     first = 0;
404                 strcat(failure_text, ts_failure_info[i].text);
405             }
406         }
407     }
408     if (failure_text[0] == '\0')
409         strcpy(failure_text, "unspecified");
410
411     TSerr(TS_F_TS_CHECK_STATUS_INFO, TS_R_NO_TIME_STAMP_TOKEN);
412     ERR_add_error_data(6,
413                        "status code: ", status_text,
414                        ", status text: ", embedded_status_text ?
415                        embedded_status_text : "unspecified",
416                        ", failure codes: ", failure_text);
417     OPENSSL_free(embedded_status_text);
418
419     return 0;
420 }
421
422 static char *ts_get_status_text(STACK_OF(ASN1_UTF8STRING) *text)
423 {
424     return sk_ASN1_UTF8STRING2text(text, "/", TS_MAX_STATUS_LENGTH);
425 }
426
427 static int ts_check_policy(const ASN1_OBJECT *req_oid,
428                            const TS_TST_INFO *tst_info)
429 {
430     const ASN1_OBJECT *resp_oid = tst_info->policy_id;
431
432     if (OBJ_cmp(req_oid, resp_oid) != 0) {
433         TSerr(TS_F_TS_CHECK_POLICY, TS_R_POLICY_MISMATCH);
434         return 0;
435     }
436
437     return 1;
438 }
439
440 static int ts_compute_imprint(BIO *data, TS_TST_INFO *tst_info,
441                               X509_ALGOR **md_alg,
442                               unsigned char **imprint, unsigned *imprint_len)
443 {
444     TS_MSG_IMPRINT *msg_imprint = tst_info->msg_imprint;
445     X509_ALGOR *md_alg_resp = msg_imprint->hash_algo;
446     const EVP_MD *md;
447     EVP_MD_CTX *md_ctx = NULL;
448     unsigned char buffer[4096];
449     int length;
450
451     *md_alg = NULL;
452     *imprint = NULL;
453
454     if ((*md_alg = X509_ALGOR_dup(md_alg_resp)) == NULL)
455         goto err;
456     if ((md = EVP_get_digestbyobj((*md_alg)->algorithm)) == NULL) {
457         TSerr(TS_F_TS_COMPUTE_IMPRINT, TS_R_UNSUPPORTED_MD_ALGORITHM);
458         goto err;
459     }
460     length = EVP_MD_size(md);
461     if (length < 0)
462         goto err;
463     *imprint_len = length;
464     if ((*imprint = OPENSSL_malloc(*imprint_len)) == NULL) {
465         TSerr(TS_F_TS_COMPUTE_IMPRINT, ERR_R_MALLOC_FAILURE);
466         goto err;
467     }
468
469     md_ctx = EVP_MD_CTX_new();
470     if (md_ctx == NULL) {
471         TSerr(TS_F_TS_COMPUTE_IMPRINT, ERR_R_MALLOC_FAILURE);
472         goto err;
473     }
474     if (!EVP_DigestInit(md_ctx, md))
475         goto err;
476     while ((length = BIO_read(data, buffer, sizeof(buffer))) > 0) {
477         if (!EVP_DigestUpdate(md_ctx, buffer, length))
478             goto err;
479     }
480     if (!EVP_DigestFinal(md_ctx, *imprint, NULL))
481         goto err;
482     EVP_MD_CTX_free(md_ctx);
483
484     return 1;
485  err:
486     EVP_MD_CTX_free(md_ctx);
487     X509_ALGOR_free(*md_alg);
488     OPENSSL_free(*imprint);
489     *imprint_len = 0;
490     *imprint = 0;
491     return 0;
492 }
493
494 static int ts_check_imprints(X509_ALGOR *algor_a,
495                              const unsigned char *imprint_a, unsigned len_a,
496                              TS_TST_INFO *tst_info)
497 {
498     TS_MSG_IMPRINT *b = tst_info->msg_imprint;
499     X509_ALGOR *algor_b = b->hash_algo;
500     int ret = 0;
501
502     if (algor_a) {
503         if (OBJ_cmp(algor_a->algorithm, algor_b->algorithm))
504             goto err;
505
506         /* The parameter must be NULL in both. */
507         if ((algor_a->parameter
508              && ASN1_TYPE_get(algor_a->parameter) != V_ASN1_NULL)
509             || (algor_b->parameter
510                 && ASN1_TYPE_get(algor_b->parameter) != V_ASN1_NULL))
511             goto err;
512     }
513
514     ret = len_a == (unsigned)ASN1_STRING_length(b->hashed_msg) &&
515         memcmp(imprint_a, ASN1_STRING_get0_data(b->hashed_msg), len_a) == 0;
516  err:
517     if (!ret)
518         TSerr(TS_F_TS_CHECK_IMPRINTS, TS_R_MESSAGE_IMPRINT_MISMATCH);
519     return ret;
520 }
521
522 static int ts_check_nonces(const ASN1_INTEGER *a, TS_TST_INFO *tst_info)
523 {
524     const ASN1_INTEGER *b = tst_info->nonce;
525
526     if (!b) {
527         TSerr(TS_F_TS_CHECK_NONCES, TS_R_NONCE_NOT_RETURNED);
528         return 0;
529     }
530
531     /* No error if a nonce is returned without being requested. */
532     if (ASN1_INTEGER_cmp(a, b) != 0) {
533         TSerr(TS_F_TS_CHECK_NONCES, TS_R_NONCE_MISMATCH);
534         return 0;
535     }
536
537     return 1;
538 }
539
540 /*
541  * Check if the specified TSA name matches either the subject or one of the
542  * subject alternative names of the TSA certificate.
543  */
544 static int ts_check_signer_name(GENERAL_NAME *tsa_name, X509 *signer)
545 {
546     STACK_OF(GENERAL_NAME) *gen_names = NULL;
547     int idx = -1;
548     int found = 0;
549
550     if (tsa_name->type == GEN_DIRNAME
551         && X509_name_cmp(tsa_name->d.dirn, X509_get_subject_name(signer)) == 0)
552         return 1;
553     gen_names = X509_get_ext_d2i(signer, NID_subject_alt_name, NULL, &idx);
554     while (gen_names != NULL) {
555         found = ts_find_name(gen_names, tsa_name) >= 0;
556         if (found)
557             break;
558         /*
559          * Get the next subject alternative name, although there should be no
560          * more than one.
561          */
562         GENERAL_NAMES_free(gen_names);
563         gen_names = X509_get_ext_d2i(signer, NID_subject_alt_name, NULL, &idx);
564     }
565     GENERAL_NAMES_free(gen_names);
566
567     return found;
568 }
569
570 /* Returns 1 if name is in gen_names, 0 otherwise. */
571 static int ts_find_name(STACK_OF(GENERAL_NAME) *gen_names, GENERAL_NAME *name)
572 {
573     int i, found;
574     for (i = 0, found = 0; !found && i < sk_GENERAL_NAME_num(gen_names); ++i) {
575         GENERAL_NAME *current = sk_GENERAL_NAME_value(gen_names, i);
576         found = GENERAL_NAME_cmp(current, name) == 0;
577     }
578     return found ? i - 1 : -1;
579 }