crypto/libressl/crypto/ts/ts_rsp_verify.c

   1 /* $OpenBSD: ts_rsp_verify.c,v 1.15 2015/07/19 05:42:55 miod Exp $ */
   2 /* Written by Zoltan Glozik (zglozik@stones.com) for the OpenSSL
   3  * project 2002.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2006 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    licensing@OpenSSL.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  *
  53  * This product includes cryptographic software written by Eric Young
  54  * (eay@cryptsoft.com).  This product includes software written by Tim
  55  * Hudson (tjh@cryptsoft.com).
  56  *
  57  */
  58
  59 #include <stdio.h>
  60 #include <string.h>
  61
  62 #include <openssl/err.h>
  63 #include <openssl/objects.h>
  64 #include <openssl/pkcs7.h>
  65 #include <openssl/ts.h>
  66
  67 /* Private function declarations. */
  68
  69 static int TS_verify_cert(X509_STORE *store, STACK_OF(X509) *untrusted,
  70     X509 *signer, STACK_OF(X509) **chain);
  71 static int TS_check_signing_certs(PKCS7_SIGNER_INFO *si, STACK_OF(X509) *chain);
  72 static ESS_SIGNING_CERT *ESS_get_signing_cert(PKCS7_SIGNER_INFO *si);
  73 static int TS_find_cert(STACK_OF(ESS_CERT_ID) *cert_ids, X509 *cert);
  74 static int TS_issuer_serial_cmp(ESS_ISSUER_SERIAL *is, X509_CINF *cinfo);
  75 static int int_TS_RESP_verify_token(TS_VERIFY_CTX *ctx,
  76     PKCS7 *token, TS_TST_INFO *tst_info);
  77 static int TS_check_status_info(TS_RESP *response);
  78 static char *TS_get_status_text(STACK_OF(ASN1_UTF8STRING) *text);
  79 static int TS_check_policy(ASN1_OBJECT *req_oid, TS_TST_INFO *tst_info);
  80 static int TS_compute_imprint(BIO *data, TS_TST_INFO *tst_info,
  81     X509_ALGOR **md_alg,
  82     unsigned char **imprint, unsigned *imprint_len);
  83 static int TS_check_imprints(X509_ALGOR *algor_a,
  84     unsigned char *imprint_a, unsigned len_a,
  85     TS_TST_INFO *tst_info);
  86 static int TS_check_nonces(const ASN1_INTEGER *a, TS_TST_INFO *tst_info);
  87 static int TS_check_signer_name(GENERAL_NAME *tsa_name, X509 *signer);
  88 static int TS_find_name(STACK_OF(GENERAL_NAME) *gen_names, GENERAL_NAME *name);
  89
  90 /*
  91  * Local mapping between response codes and descriptions.
  92  * Don't forget to change TS_STATUS_BUF_SIZE when modifying
  93  * the elements of this array.
  94  */
  95 static const char *TS_status_text[] = {
  96         "granted",
  97         "grantedWithMods",
  98         "rejection",
  99         "waiting",
 100         "revocationWarning",
 101         "revocationNotification"
 102 };
 103
 104 #define TS_STATUS_TEXT_SIZE     (sizeof(TS_status_text)/sizeof(*TS_status_text))
 105
 106 /*
 107  * This must be greater or equal to the sum of the strings in TS_status_text
 108  * plus the number of its elements.
 109  */
 110 #define TS_STATUS_BUF_SIZE      256
 111
 112 static struct {
 113         int code;
 114         const char *text;
 115 } TS_failure_info[] = {
 116         { TS_INFO_BAD_ALG, "badAlg" },
 117         { TS_INFO_BAD_REQUEST, "badRequest" },
 118         { TS_INFO_BAD_DATA_FORMAT, "badDataFormat" },
 119         { TS_INFO_TIME_NOT_AVAILABLE, "timeNotAvailable" },
 120         { TS_INFO_UNACCEPTED_POLICY, "unacceptedPolicy" },
 121         { TS_INFO_UNACCEPTED_EXTENSION, "unacceptedExtension" },
 122         { TS_INFO_ADD_INFO_NOT_AVAILABLE, "addInfoNotAvailable" },
 123         { TS_INFO_SYSTEM_FAILURE, "systemFailure" }
 124 };
 125
 126 #define TS_FAILURE_INFO_SIZE    (sizeof(TS_failure_info) / \
 127                                 sizeof(*TS_failure_info))
 128
 129 /* Functions for verifying a signed TS_TST_INFO structure. */
 130
 131 /*
 132  * This function carries out the following tasks:
 133  *      - Checks if there is one and only one signer.
 134  *      - Search for the signing certificate in 'certs' and in the response.
 135  *      - Check the extended key usage and key usage fields of the signer
 136  *      certificate (done by the path validation).
 137  *      - Build and validate the certificate path.
 138  *      - Check if the certificate path meets the requirements of the
 139  *      SigningCertificate ESS signed attribute.
 140  *      - Verify the signature value.
 141  *      - Returns the signer certificate in 'signer', if 'signer' is not NULL.
 142  */
 143 int
 144 TS_RESP_verify_signature(PKCS7 *token, STACK_OF(X509) *certs,
 145     X509_STORE *store, X509 **signer_out)
 146 {
 147         STACK_OF(PKCS7_SIGNER_INFO) *sinfos = NULL;
 148         PKCS7_SIGNER_INFO *si;
 149         STACK_OF(X509) *signers = NULL;
 150         X509    *signer;
 151         STACK_OF(X509) *chain = NULL;
 152         char    buf[4096];
 153         int     i, j = 0, ret = 0;
 154         BIO     *p7bio = NULL;
 155
 156         /* Some sanity checks first. */
 157         if (!token) {
 158                 TSerr(TS_F_TS_RESP_VERIFY_SIGNATURE, TS_R_INVALID_NULL_POINTER);
 159                 goto err;
 160         }
 161
 162         /* Check for the correct content type */
 163         if (!PKCS7_type_is_signed(token)) {
 164                 TSerr(TS_F_TS_RESP_VERIFY_SIGNATURE, TS_R_WRONG_CONTENT_TYPE);
 165                 goto err;
 166         }
 167
 168         /* Check if there is one and only one signer. */
 169         sinfos = PKCS7_get_signer_info(token);
 170         if (!sinfos || sk_PKCS7_SIGNER_INFO_num(sinfos) != 1) {
 171                 TSerr(TS_F_TS_RESP_VERIFY_SIGNATURE,
 172                     TS_R_THERE_MUST_BE_ONE_SIGNER);
 173                 goto err;
 174         }
 175         si = sk_PKCS7_SIGNER_INFO_value(sinfos, 0);
 176
 177         /* Check for no content: no data to verify signature. */
 178         if (PKCS7_get_detached(token)) {
 179                 TSerr(TS_F_TS_RESP_VERIFY_SIGNATURE, TS_R_NO_CONTENT);
 180                 goto err;
 181         }
 182
 183         /* Get hold of the signer certificate, search only internal
 184            certificates if it was requested. */
 185         signers = PKCS7_get0_signers(token, certs, 0);
 186         if (!signers || sk_X509_num(signers) != 1)
 187                 goto err;
 188         signer = sk_X509_value(signers, 0);
 189
 190         /* Now verify the certificate. */
 191         if (!TS_verify_cert(store, certs, signer, &chain))
 192                 goto err;
 193
 194         /* Check if the signer certificate is consistent with the
 195            ESS extension. */
 196         if (!TS_check_signing_certs(si, chain))
 197                 goto err;
 198
 199         /* Creating the message digest. */
 200         p7bio = PKCS7_dataInit(token, NULL);
 201
 202         /* We now have to 'read' from p7bio to calculate digests etc. */
 203         while ((i = BIO_read(p7bio, buf, sizeof(buf))) > 0)
 204                 ;
 205
 206         /* Verifying the signature. */
 207         j = PKCS7_signatureVerify(p7bio, token, si, signer);
 208         if (j <= 0) {
 209                 TSerr(TS_F_TS_RESP_VERIFY_SIGNATURE, TS_R_SIGNATURE_FAILURE);
 210                 goto err;
 211         }
 212
 213         /* Return the signer certificate if needed. */
 214         if (signer_out) {
 215                 *signer_out = signer;
 216                 CRYPTO_add(&signer->references, 1, CRYPTO_LOCK_X509);
 217         }
 218
 219         ret = 1;
 220
 221 err:
 222         BIO_free_all(p7bio);
 223         sk_X509_pop_free(chain, X509_free);
 224         sk_X509_free(signers);
 225
 226         return ret;
 227 }
 228
 229 /*
 230  * The certificate chain is returned in chain. Caller is responsible for
 231  * freeing the vector.
 232  */
 233 static int
 234 TS_verify_cert(X509_STORE *store, STACK_OF(X509) *untrusted, X509 *signer,
 235     STACK_OF(X509) **chain)
 236 {
 237         X509_STORE_CTX cert_ctx;
 238         int i;
 239         int ret = 0;
 240
 241         /* chain is an out argument. */
 242         *chain = NULL;
 243         if (X509_STORE_CTX_init(&cert_ctx, store, signer, untrusted) == 0) {
 244                 TSerr(TS_F_TS_VERIFY_CERT, ERR_R_X509_LIB);
 245                 goto err;
 246         }
 247         X509_STORE_CTX_set_purpose(&cert_ctx, X509_PURPOSE_TIMESTAMP_SIGN);
 248         i = X509_verify_cert(&cert_ctx);
 249         if (i <= 0) {
 250                 int j = X509_STORE_CTX_get_error(&cert_ctx);
 251
 252                 TSerr(TS_F_TS_VERIFY_CERT, TS_R_CERTIFICATE_VERIFY_ERROR);
 253                 ERR_asprintf_error_data("Verify error:%s",
 254                     X509_verify_cert_error_string(j));
 255                 goto err;
 256         } else {
 257                 /* Get a copy of the certificate chain. */
 258                 *chain = X509_STORE_CTX_get1_chain(&cert_ctx);
 259                 ret = 1;
 260         }
 261
 262 err:
 263         X509_STORE_CTX_cleanup(&cert_ctx);
 264
 265         return ret;
 266 }
 267
 268 static int
 269 TS_check_signing_certs(PKCS7_SIGNER_INFO *si, STACK_OF(X509) *chain)
 270 {
 271         ESS_SIGNING_CERT *ss = ESS_get_signing_cert(si);
 272         STACK_OF(ESS_CERT_ID) *cert_ids = NULL;
 273         X509 *cert;
 274         int i = 0;
 275         int ret = 0;
 276
 277         if (!ss)
 278                 goto err;
 279         cert_ids = ss->cert_ids;
 280         /* The signer certificate must be the first in cert_ids. */
 281         cert = sk_X509_value(chain, 0);
 282         if (TS_find_cert(cert_ids, cert) != 0)
 283                 goto err;
 284
 285         /* Check the other certificates of the chain if there are more
 286            than one certificate ids in cert_ids. */
 287         if (sk_ESS_CERT_ID_num(cert_ids) > 1) {
 288                 /* All the certificates of the chain must be in cert_ids. */
 289                 for (i = 1; i < sk_X509_num(chain); ++i) {
 290                         cert = sk_X509_value(chain, i);
 291                         if (TS_find_cert(cert_ids, cert) < 0)
 292                                 goto err;
 293                 }
 294         }
 295         ret = 1;
 296
 297 err:
 298         if (!ret)
 299                 TSerr(TS_F_TS_CHECK_SIGNING_CERTS,
 300                     TS_R_ESS_SIGNING_CERTIFICATE_ERROR);
 301         ESS_SIGNING_CERT_free(ss);
 302         return ret;
 303 }
 304
 305 static ESS_SIGNING_CERT *
 306 ESS_get_signing_cert(PKCS7_SIGNER_INFO *si)
 307 {
 308         ASN1_TYPE *attr;
 309         const unsigned char *p;
 310
 311         attr = PKCS7_get_signed_attribute(si,
 312             NID_id_smime_aa_signingCertificate);
 313         if (!attr)
 314                 return NULL;
 315         if (attr->type != V_ASN1_SEQUENCE)
 316                 return NULL;
 317         p = attr->value.sequence->data;
 318         return d2i_ESS_SIGNING_CERT(NULL, &p, attr->value.sequence->length);
 319 }
 320
 321 /* Returns < 0 if certificate is not found, certificate index otherwise. */
 322 static int
 323 TS_find_cert(STACK_OF(ESS_CERT_ID) *cert_ids, X509 *cert)
 324 {
 325         int i;
 326
 327         if (!cert_ids || !cert)
 328                 return -1;
 329
 330         /* Recompute SHA1 hash of certificate if necessary (side effect). */
 331         X509_check_purpose(cert, -1, 0);
 332
 333         /* Look for cert in the cert_ids vector. */
 334         for (i = 0; i < sk_ESS_CERT_ID_num(cert_ids); ++i) {
 335                 ESS_CERT_ID *cid = sk_ESS_CERT_ID_value(cert_ids, i);
 336
 337                 /* Check the SHA-1 hash first. */
 338                 if (cid->hash->length == sizeof(cert->sha1_hash) &&
 339                     !memcmp(cid->hash->data, cert->sha1_hash,
 340                         sizeof(cert->sha1_hash))) {
 341                         /* Check the issuer/serial as well if specified. */
 342                         ESS_ISSUER_SERIAL *is = cid->issuer_serial;
 343                         if (!is || !TS_issuer_serial_cmp(is, cert->cert_info))
 344                                 return i;
 345                 }
 346         }
 347
 348         return -1;
 349 }
 350
 351 static int
 352 TS_issuer_serial_cmp(ESS_ISSUER_SERIAL *is, X509_CINF *cinfo)
 353 {
 354         GENERAL_NAME *issuer;
 355
 356         if (!is || !cinfo || sk_GENERAL_NAME_num(is->issuer) != 1)
 357                 return -1;
 358
 359         /* Check the issuer first. It must be a directory name. */
 360         issuer = sk_GENERAL_NAME_value(is->issuer, 0);
 361         if (issuer->type != GEN_DIRNAME ||
 362             X509_NAME_cmp(issuer->d.dirn, cinfo->issuer))
 363                 return -1;
 364
 365         /* Check the serial number, too. */
 366         if (ASN1_INTEGER_cmp(is->serial, cinfo->serialNumber))
 367                 return -1;
 368
 369         return 0;
 370 }
 371
 372 /*
 373  * Verifies whether 'response' contains a valid response with regards
 374  * to the settings of the context:
 375  *      - Gives an error message if the TS_TST_INFO is not present.
 376  *      - Calls _TS_RESP_verify_token to verify the token content.
 377  */
 378 int
 379 TS_RESP_verify_response(TS_VERIFY_CTX *ctx, TS_RESP *response)
 380 {
 381         PKCS7 *token = TS_RESP_get_token(response);
 382         TS_TST_INFO *tst_info = TS_RESP_get_tst_info(response);
 383         int ret = 0;
 384
 385         /* Check if we have a successful TS_TST_INFO object in place. */
 386         if (!TS_check_status_info(response))
 387                 goto err;
 388
 389         /* Check the contents of the time stamp token. */
 390         if (!int_TS_RESP_verify_token(ctx, token, tst_info))
 391                 goto err;
 392
 393         ret = 1;
 394
 395 err:
 396         return ret;
 397 }
 398
 399 /*
 400  * Tries to extract a TS_TST_INFO structure from the PKCS7 token and
 401  * calls the internal int_TS_RESP_verify_token function for verifying it.
 402  */
 403 int
 404 TS_RESP_verify_token(TS_VERIFY_CTX *ctx, PKCS7 *token)
 405 {
 406         TS_TST_INFO *tst_info = PKCS7_to_TS_TST_INFO(token);
 407         int ret = 0;
 408
 409         if (tst_info) {
 410                 ret = int_TS_RESP_verify_token(ctx, token, tst_info);
 411                 TS_TST_INFO_free(tst_info);
 412         }
 413         return ret;
 414 }
 415
 416 /*
 417  * Verifies whether the 'token' contains a valid time stamp token
 418  * with regards to the settings of the context. Only those checks are
 419  * carried out that are specified in the context:
 420  *      - Verifies the signature of the TS_TST_INFO.
 421  *      - Checks the version number of the response.
 422  *      - Check if the requested and returned policies math.
 423  *      - Check if the message imprints are the same.
 424  *      - Check if the nonces are the same.
 425  *      - Check if the TSA name matches the signer.
 426  *      - Check if the TSA name is the expected TSA.
 427  */
 428 static int
 429 int_TS_RESP_verify_token(TS_VERIFY_CTX *ctx, PKCS7 *token,
 430     TS_TST_INFO *tst_info)
 431 {
 432         X509 *signer = NULL;
 433         GENERAL_NAME *tsa_name = TS_TST_INFO_get_tsa(tst_info);
 434         X509_ALGOR *md_alg = NULL;
 435         unsigned char *imprint = NULL;
 436         unsigned imprint_len = 0;
 437         int ret = 0;
 438
 439         /* Verify the signature. */
 440         if ((ctx->flags & TS_VFY_SIGNATURE) &&
 441             !TS_RESP_verify_signature(token, ctx->certs, ctx->store, &signer))
 442                 goto err;
 443
 444         /* Check version number of response. */
 445         if ((ctx->flags & TS_VFY_VERSION) &&
 446             TS_TST_INFO_get_version(tst_info) != 1) {
 447                 TSerr(TS_F_INT_TS_RESP_VERIFY_TOKEN, TS_R_UNSUPPORTED_VERSION);
 448                 goto err;
 449         }
 450
 451         /* Check policies. */
 452         if ((ctx->flags & TS_VFY_POLICY) &&
 453             !TS_check_policy(ctx->policy, tst_info))
 454                 goto err;
 455
 456         /* Check message imprints. */
 457         if ((ctx->flags & TS_VFY_IMPRINT) &&
 458             !TS_check_imprints(ctx->md_alg, ctx->imprint, ctx->imprint_len,
 459                 tst_info))
 460                 goto err;
 461
 462         /* Compute and check message imprints. */
 463         if ((ctx->flags & TS_VFY_DATA) &&
 464             (!TS_compute_imprint(ctx->data, tst_info,
 465             &md_alg, &imprint, &imprint_len) ||
 466             !TS_check_imprints(md_alg, imprint, imprint_len, tst_info)))
 467                 goto err;
 468
 469         /* Check nonces. */
 470         if ((ctx->flags & TS_VFY_NONCE) &&
 471             !TS_check_nonces(ctx->nonce, tst_info))
 472                 goto err;
 473
 474         /* Check whether TSA name and signer certificate match. */
 475         if ((ctx->flags & TS_VFY_SIGNER) &&
 476             tsa_name && !TS_check_signer_name(tsa_name, signer)) {
 477                 TSerr(TS_F_INT_TS_RESP_VERIFY_TOKEN, TS_R_TSA_NAME_MISMATCH);
 478                 goto err;
 479         }
 480
 481         /* Check whether the TSA is the expected one. */
 482         if ((ctx->flags & TS_VFY_TSA_NAME) &&
 483             !TS_check_signer_name(ctx->tsa_name, signer)) {
 484                 TSerr(TS_F_INT_TS_RESP_VERIFY_TOKEN, TS_R_TSA_UNTRUSTED);
 485                 goto err;
 486         }
 487
 488         ret = 1;
 489
 490 err:
 491         X509_free(signer);
 492         X509_ALGOR_free(md_alg);
 493         free(imprint);
 494         return ret;
 495 }
 496
 497 static int
 498 TS_check_status_info(TS_RESP *response)
 499 {
 500         TS_STATUS_INFO *info = TS_RESP_get_status_info(response);
 501         long status = ASN1_INTEGER_get(info->status);
 502         const char *status_text = NULL;
 503         char *embedded_status_text = NULL;
 504         char failure_text[TS_STATUS_BUF_SIZE] = "";
 505
 506         /* Check if everything went fine. */
 507         if (status == 0 || status == 1)
 508                 return 1;
 509
 510         /* There was an error, get the description in status_text. */
 511         if (0 <= status && status < (long)TS_STATUS_TEXT_SIZE)
 512                 status_text = TS_status_text[status];
 513         else
 514                 status_text = "unknown code";
 515
 516         /* Set the embedded_status_text to the returned description. */
 517         if (sk_ASN1_UTF8STRING_num(info->text) > 0 &&
 518             !(embedded_status_text = TS_get_status_text(info->text)))
 519                 return 0;
 520
 521         /* Filling in failure_text with the failure information. */
 522         if (info->failure_info) {
 523                 int i;
 524                 int first = 1;
 525                 for (i = 0; i < (int)TS_FAILURE_INFO_SIZE; ++i) {
 526                         if (ASN1_BIT_STRING_get_bit(info->failure_info,
 527                             TS_failure_info[i].code)) {
 528                                 if (!first)
 529                                         strlcat(failure_text, ",",
 530                                             TS_STATUS_BUF_SIZE);
 531                                 else
 532                                         first = 0;
 533                                 strlcat(failure_text, TS_failure_info[i].text,
 534                                     TS_STATUS_BUF_SIZE);
 535                         }
 536                 }
 537         }
 538         if (failure_text[0] == '\0')
 539                 strlcpy(failure_text, "unspecified", TS_STATUS_BUF_SIZE);
 540
 541         /* Making up the error string. */
 542         TSerr(TS_F_TS_CHECK_STATUS_INFO, TS_R_NO_TIME_STAMP_TOKEN);
 543         ERR_asprintf_error_data
 544             ("status code: %s, status text: %s, failure codes: %s",
 545             status_text,
 546             embedded_status_text ? embedded_status_text : "unspecified",
 547             failure_text);
 548         free(embedded_status_text);
 549
 550         return 0;
 551 }
 552
 553 static char *
 554 TS_get_status_text(STACK_OF(ASN1_UTF8STRING) *text)
 555 {
 556         int i;
 557         unsigned int length = 0;
 558         char *result = NULL;
 559
 560         /* Determine length first. */
 561         for (i = 0; i < sk_ASN1_UTF8STRING_num(text); ++i) {
 562                 ASN1_UTF8STRING *current = sk_ASN1_UTF8STRING_value(text, i);
 563                 length += ASN1_STRING_length(current);
 564                 length += 1;    /* separator character */
 565         }
 566         /* Allocate memory (closing '\0' included). */
 567         if (!(result = malloc(length))) {
 568                 TSerr(TS_F_TS_GET_STATUS_TEXT, ERR_R_MALLOC_FAILURE);
 569                 return NULL;
 570         }
 571         /* Concatenate the descriptions. */
 572         result[0] = '\0';
 573         for (i = 0; i < sk_ASN1_UTF8STRING_num(text); ++i) {
 574                 ASN1_UTF8STRING *current = sk_ASN1_UTF8STRING_value(text, i);
 575                 if (i > 0)
 576                         strlcat(result, "/", length);
 577                 strlcat(result, (const char *)ASN1_STRING_data(current), length);
 578         }
 579         return result;
 580 }
 581
 582 static int
 583 TS_check_policy(ASN1_OBJECT *req_oid, TS_TST_INFO *tst_info)
 584 {
 585         ASN1_OBJECT *resp_oid = TS_TST_INFO_get_policy_id(tst_info);
 586
 587         if (OBJ_cmp(req_oid, resp_oid) != 0) {
 588                 TSerr(TS_F_TS_CHECK_POLICY, TS_R_POLICY_MISMATCH);
 589                 return 0;
 590         }
 591
 592         return 1;
 593 }
 594
 595 static int
 596 TS_compute_imprint(BIO *data, TS_TST_INFO *tst_info, X509_ALGOR **md_alg,
 597     unsigned char **imprint, unsigned *imprint_len)
 598 {
 599         TS_MSG_IMPRINT *msg_imprint = TS_TST_INFO_get_msg_imprint(tst_info);
 600         X509_ALGOR *md_alg_resp = TS_MSG_IMPRINT_get_algo(msg_imprint);
 601         const EVP_MD *md;
 602         EVP_MD_CTX md_ctx;
 603         unsigned char buffer[4096];
 604         int length;
 605
 606         *md_alg = NULL;
 607         *imprint = NULL;
 608
 609         /* Return the MD algorithm of the response. */
 610         if (!(*md_alg = X509_ALGOR_dup(md_alg_resp)))
 611                 goto err;
 612
 613         /* Getting the MD object. */
 614         if (!(md = EVP_get_digestbyobj((*md_alg)->algorithm))) {
 615                 TSerr(TS_F_TS_COMPUTE_IMPRINT, TS_R_UNSUPPORTED_MD_ALGORITHM);
 616                 goto err;
 617         }
 618
 619         /* Compute message digest. */
 620         length = EVP_MD_size(md);
 621         if (length < 0)
 622                 goto err;
 623         *imprint_len = length;
 624         if (!(*imprint = malloc(*imprint_len))) {
 625                 TSerr(TS_F_TS_COMPUTE_IMPRINT, ERR_R_MALLOC_FAILURE);
 626                 goto err;
 627         }
 628
 629         if (!EVP_DigestInit(&md_ctx, md))
 630                 goto err;
 631         while ((length = BIO_read(data, buffer, sizeof(buffer))) > 0) {
 632                 if (!EVP_DigestUpdate(&md_ctx, buffer, length))
 633                         goto err;
 634         }
 635         if (!EVP_DigestFinal(&md_ctx, *imprint, NULL))
 636                 goto err;
 637
 638         return 1;
 639
 640 err:
 641         X509_ALGOR_free(*md_alg);
 642         free(*imprint);
 643         *imprint = NULL;
 644         *imprint_len = 0;
 645         return 0;
 646 }
 647
 648 static int
 649 TS_check_imprints(X509_ALGOR *algor_a, unsigned char *imprint_a, unsigned len_a,
 650     TS_TST_INFO *tst_info)
 651 {
 652         TS_MSG_IMPRINT *b = TS_TST_INFO_get_msg_imprint(tst_info);
 653         X509_ALGOR *algor_b = TS_MSG_IMPRINT_get_algo(b);
 654         int ret = 0;
 655
 656         /* algor_a is optional. */
 657         if (algor_a) {
 658                 /* Compare algorithm OIDs. */
 659                 if (OBJ_cmp(algor_a->algorithm, algor_b->algorithm))
 660                         goto err;
 661
 662                 /* The parameter must be NULL in both. */
 663                 if ((algor_a->parameter &&
 664                     ASN1_TYPE_get(algor_a->parameter) != V_ASN1_NULL) ||
 665                     (algor_b->parameter &&
 666                     ASN1_TYPE_get(algor_b->parameter) != V_ASN1_NULL))
 667                         goto err;
 668         }
 669
 670         /* Compare octet strings. */
 671         ret = len_a == (unsigned) ASN1_STRING_length(b->hashed_msg) &&
 672             memcmp(imprint_a, ASN1_STRING_data(b->hashed_msg), len_a) == 0;
 673
 674 err:
 675         if (!ret)
 676                 TSerr(TS_F_TS_CHECK_IMPRINTS, TS_R_MESSAGE_IMPRINT_MISMATCH);
 677         return ret;
 678 }
 679
 680 static int
 681 TS_check_nonces(const ASN1_INTEGER *a, TS_TST_INFO *tst_info)
 682 {
 683         const ASN1_INTEGER *b = TS_TST_INFO_get_nonce(tst_info);
 684
 685         /* Error if nonce is missing. */
 686         if (!b) {
 687                 TSerr(TS_F_TS_CHECK_NONCES, TS_R_NONCE_NOT_RETURNED);
 688                 return 0;
 689         }
 690
 691         /* No error if a nonce is returned without being requested. */
 692         if (ASN1_INTEGER_cmp(a, b) != 0) {
 693                 TSerr(TS_F_TS_CHECK_NONCES, TS_R_NONCE_MISMATCH);
 694                 return 0;
 695         }
 696
 697         return 1;
 698 }
 699
 700 /* Check if the specified TSA name matches either the subject
 701    or one of the subject alternative names of the TSA certificate. */
 702 static int
 703 TS_check_signer_name(GENERAL_NAME *tsa_name, X509 *signer)
 704 {
 705         STACK_OF(GENERAL_NAME) *gen_names = NULL;
 706         int idx = -1;
 707         int found = 0;
 708
 709         if (signer == NULL)
 710                 return 0;
 711
 712         /* Check the subject name first. */
 713         if (tsa_name->type == GEN_DIRNAME &&
 714             X509_name_cmp(tsa_name->d.dirn, signer->cert_info->subject) == 0)
 715                 return 1;
 716
 717         /* Check all the alternative names. */
 718         gen_names = X509_get_ext_d2i(signer, NID_subject_alt_name,
 719             NULL, &idx);
 720         while (gen_names != NULL &&
 721             !(found = (TS_find_name(gen_names, tsa_name) >= 0))) {
 722                 /* Get the next subject alternative name,
 723                    although there should be no more than one. */
 724                 GENERAL_NAMES_free(gen_names);
 725                 gen_names = X509_get_ext_d2i(signer, NID_subject_alt_name,
 726                     NULL, &idx);
 727         }
 728         if (gen_names)
 729                 GENERAL_NAMES_free(gen_names);
 730
 731         return found;
 732 }
 733
 734 /* Returns 1 if name is in gen_names, 0 otherwise. */
 735 static int
 736 TS_find_name(STACK_OF(GENERAL_NAME) *gen_names, GENERAL_NAME *name)
 737 {
 738         int i, found;
 739         for (i = 0, found = 0; !found && i < sk_GENERAL_NAME_num(gen_names);
 740             ++i) {
 741                 GENERAL_NAME *current = sk_GENERAL_NAME_value(gen_names, i);
 742                 found = GENERAL_NAME_cmp(current, name) == 0;
 743         }
 744         return found ? i - 1 : -1;
 745 }