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