src/ocsp.c

   1 /* ocsp.c - OCSP (rfc2560)
   2  * Copyright (C) 2003, 2004, 2005, 2006, 2012 g10 Code GmbH
   3  *
   4  * This file is part of KSBA.
   5  *
   6  * KSBA is free software; you can redistribute it and/or modify
   7  * it under the terms of either
   8  *
   9  *   - the GNU Lesser General Public License as published by the Free
  10  *     Software Foundation; either version 3 of the License, or (at
  11  *     your option) any later version.
  12  *
  13  * or
  14  *
  15  *   - the GNU General Public License as published by the Free
  16  *     Software Foundation; either version 2 of the License, or (at
  17  *     your option) any later version.
  18  *
  19  * or both in parallel, as here.
  20  *
  21  * KSBA is distributed in the hope that it will be useful, but WITHOUT
  22  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  23  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  24  * License for more details.
  25  *
  26  * You should have received a copies of the GNU General Public License
  27  * and the GNU Lesser General Public License along with this program;
  28  * if not, see <http://www.gnu.org/licenses/>.
  29  */
  30
  31 #include <config.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <assert.h>
  36
  37 #include "util.h"
  38
  39 #include "cert.h"
  40 #include "convert.h"
  41 #include "keyinfo.h"
  42 #include "der-encoder.h"
  43 #include "ber-help.h"
  44 #include "ocsp.h"
  45
  46
  47 static const char oidstr_sha1[] = "1.3.14.3.2.26";
  48 static const char oidstr_ocsp_basic[] = "1.3.6.1.5.5.7.48.1.1";
  49 static const char oidstr_ocsp_nonce[] = "1.3.6.1.5.5.7.48.1.2";
  50
  51
  52 #if 0
  53 static void
  54 dump_hex (const unsigned char *p, size_t n)
  55 {
  56   if (!p)
  57     fputs ("none", stderr);
  58   else
  59     {
  60       for (; n; n--, p++)
  61         fprintf (stderr, " %02X", *p);
  62     }
  63 }
  64 #endif
  65
  66 \f
  67 /* Create a new OCSP object and retrun it in R_OCSP.  Return 0 on
  68    success or an error code.
  69  */
  70 gpg_error_t
  71 ksba_ocsp_new (ksba_ocsp_t *r_ocsp)
  72 {
  73   *r_ocsp = xtrycalloc (1, sizeof **r_ocsp);
  74   if (!*r_ocsp)
  75     return gpg_error_from_syserror ();
  76   return 0;
  77 }
  78
  79
  80 static void
  81 release_ocsp_certlist (struct ocsp_certlist_s *cl)
  82 {
  83   while (cl)
  84     {
  85       struct ocsp_certlist_s *tmp = cl->next;
  86       ksba_cert_release (cl->cert);
  87       xfree (cl);
  88       cl = tmp;
  89     }
  90 }
  91
  92
  93 static void
  94 release_ocsp_extensions (struct ocsp_extension_s *ex)
  95 {
  96   while (ex)
  97     {
  98       struct ocsp_extension_s *tmp = ex->next;
  99       xfree (ex);
 100       ex = tmp;
 101     }
 102 }
 103
 104
 105 /* Release the OCSP object and all its resources. Passing NULL for
 106    OCSP is a valid nop. */
 107 void
 108 ksba_ocsp_release (ksba_ocsp_t ocsp)
 109 {
 110   struct ocsp_reqitem_s *ri;
 111
 112   if (!ocsp)
 113     return;
 114   xfree (ocsp->digest_oid);
 115   xfree (ocsp->request_buffer);
 116   for (; (ri=ocsp->requestlist); ri = ocsp->requestlist )
 117     {
 118       ocsp->requestlist = ri->next;
 119       ksba_cert_release (ri->cert);
 120       ksba_cert_release (ri->issuer_cert);
 121       release_ocsp_extensions (ri->single_extensions);
 122       xfree (ri->serialno);
 123     }
 124   xfree (ocsp->sigval);
 125   xfree (ocsp->responder_id.name);
 126   xfree (ocsp->responder_id.keyid);
 127   release_ocsp_certlist (ocsp->received_certs);
 128   release_ocsp_extensions (ocsp->response_extensions);
 129   xfree (ocsp);
 130 }
 131
 132
 133
 134 /* Set the hash algorithm to be used for signing the request to OID.
 135    Using this function will force the creation of a signed
 136    request.  */
 137 gpg_error_t
 138 ksba_ocsp_set_digest_algo (ksba_ocsp_t ocsp, const char *oid)
 139 {
 140   if (!ocsp || !oid || !*oid)
 141     return gpg_error (GPG_ERR_INV_VALUE);
 142   if (ocsp->digest_oid)
 143     xfree (ocsp->digest_oid);
 144   ocsp->digest_oid = xtrystrdup (oid);
 145   if (!ocsp->digest_oid)
 146     return gpg_error_from_syserror ();
 147   return 0;
 148 }
 149
 150
 151 gpg_error_t
 152 ksba_ocsp_set_requestor (ksba_ocsp_t ocsp, ksba_cert_t cert)
 153 {
 154   (void)ocsp;
 155   (void)cert;
 156   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
 157 }
 158
 159
 160 /* Add the certificate CERT for which the status is to be requested
 161    and it's issuer certificate ISSUER_CERT to the context.  This
 162    function may be called multiple time to create a list of targets to
 163    get combined into one actual request. */
 164 gpg_error_t
 165 ksba_ocsp_add_target (ksba_ocsp_t ocsp,
 166                       ksba_cert_t cert, ksba_cert_t issuer_cert)
 167 {
 168   struct ocsp_reqitem_s *ri;
 169
 170   if (!ocsp || !cert || !issuer_cert)
 171     return gpg_error (GPG_ERR_INV_VALUE);
 172
 173   ri = xtrycalloc (1, sizeof *ri);
 174   if (!ri)
 175     return gpg_error_from_syserror ();
 176   ksba_cert_ref (cert);
 177   ri->cert = cert;
 178   ksba_cert_ref (issuer_cert);
 179   ri->issuer_cert = issuer_cert;
 180
 181   ri->next = ocsp->requestlist;
 182   ocsp->requestlist = ri;
 183
 184   return 0;
 185 }
 186
 187
 188 /* Set the nonce to be used for the request to the content of the
 189    buffer NONCE of size NONCELEN.  Libksba may have an upper limit of
 190    the allowed size of the nonce; if the supplied nonce is larger it
 191    will be truncated and the actual used length of the nonce returned.
 192    To detect the implementation limit (which should be considered as a
 193    good suggestion), the function may be called with NULL for NONCE,
 194    in which case the maximal usable noncelength is returned. The
 195    function returns the length of the nonce which will be used. */
 196 size_t
 197 ksba_ocsp_set_nonce (ksba_ocsp_t ocsp, unsigned char *nonce, size_t noncelen)
 198 {
 199   if (!ocsp)
 200     return 0;
 201   if (!nonce)
 202     return sizeof ocsp->nonce;
 203   if (noncelen > sizeof ocsp->nonce)
 204     noncelen = sizeof ocsp->nonce;
 205   if (noncelen)
 206     {
 207       memcpy (ocsp->nonce, nonce, noncelen);
 208     }
 209   ocsp->noncelen = noncelen;
 210   return noncelen;
 211 }
 212
 213
 214 /* Compute the SHA-1 nameHash for the certificate CERT and put it in
 215    the buffer SHA1_BUFFER which must have been allocated to at least
 216    20 bytes. */
 217 static gpg_error_t
 218 issuer_name_hash (ksba_cert_t cert, unsigned char *sha1_buffer)
 219 {
 220   gpg_error_t err;
 221   const unsigned char *ptr;
 222   size_t length, dummy;
 223
 224   err = _ksba_cert_get_subject_dn_ptr (cert, &ptr, &length);
 225   if (!err)
 226     {
 227       err = _ksba_hash_buffer (NULL, ptr, length, 20, sha1_buffer, &dummy);
 228       if (!err && dummy != 20)
 229         err = gpg_error (GPG_ERR_BUG);
 230     }
 231   return err;
 232 }
 233
 234 /* Compute the SHA-1 hash of the public key of CERT and put it in teh
 235    buffer SHA1_BUFFER which must have been allocated with at least 20
 236    bytes. */
 237 static gpg_error_t
 238 issuer_key_hash (ksba_cert_t cert, unsigned char *sha1_buffer)
 239 {
 240   gpg_error_t err;
 241   const unsigned char *ptr;
 242   size_t length, dummy;
 243
 244   err = _ksba_cert_get_public_key_ptr (cert, &ptr, &length);
 245   if (!err)
 246     {
 247       err = _ksba_hash_buffer (NULL, ptr, length, 20, sha1_buffer, &dummy);
 248       if (!err && dummy != 20)
 249         err = gpg_error (GPG_ERR_BUG);
 250     }
 251   return err;
 252 }
 253
 254
 255 /* Write the extensions for a request to WOUT. */
 256 static gpg_error_t
 257 write_request_extensions (ksba_ocsp_t ocsp, ksba_writer_t wout)
 258 {
 259   gpg_error_t err;
 260   unsigned char *buf;
 261   size_t buflen;
 262   unsigned char *p;
 263   size_t derlen;
 264   ksba_writer_t w1 = NULL;
 265   ksba_writer_t w2 = NULL;
 266
 267   if (!ocsp->noncelen)
 268     return 0; /* We do only support the nonce extension.  */
 269
 270   /* Create writer objects for construction of the extension. */
 271   err = ksba_writer_new (&w2);
 272   if (!err)
 273     err = ksba_writer_set_mem (w2, 256);
 274   if (!err)
 275     err = ksba_writer_new (&w1);
 276   if (!err)
 277     err = ksba_writer_set_mem (w1, 256);
 278   if (err)
 279     goto leave;
 280
 281   /* Write OID and nonce.  */
 282   err = ksba_oid_from_str (oidstr_ocsp_nonce, &buf, &buflen);
 283   if (err)
 284     goto leave;
 285   err = _ksba_ber_write_tl (w1, TYPE_OBJECT_ID, CLASS_UNIVERSAL, 0, buflen);
 286   if (!err)
 287     err = ksba_writer_write (w1, buf, buflen);
 288   xfree (buf); buf = NULL;
 289   /* We known that the nonce is short enough to put the tag into 2 bytes, thus
 290      we write the encapsulating octet string directly with a fixed length. */
 291   if (!err)
 292     err = _ksba_ber_write_tl (w1, TYPE_OCTET_STRING, CLASS_UNIVERSAL, 0,
 293                               2+ocsp->noncelen);
 294   if (!err)
 295     err = _ksba_ber_write_tl (w1, TYPE_OCTET_STRING, CLASS_UNIVERSAL, 0,
 296                               ocsp->noncelen);
 297   if (!err)
 298     err = ksba_writer_write (w1, ocsp->nonce, ocsp->noncelen);
 299
 300   /* Put a sequence around. */
 301   p = ksba_writer_snatch_mem (w1, &derlen);
 302   if (!p)
 303     {
 304       err = ksba_writer_error (w1);
 305       goto leave;
 306     }
 307   err = _ksba_ber_write_tl (w2, TYPE_SEQUENCE, CLASS_UNIVERSAL, 1, derlen);
 308   if (!err)
 309     err = ksba_writer_write (w2, p, derlen);
 310   xfree (p); p = NULL;
 311
 312   /* Put the sequence around all extensions.  */
 313   err = ksba_writer_set_mem (w1, 256);
 314   if (err)
 315     goto leave;
 316   p = ksba_writer_snatch_mem (w2, &derlen);
 317   if (!p)
 318     {
 319       err = ksba_writer_error (w2);
 320       goto leave;
 321     }
 322   err = _ksba_ber_write_tl (w1, TYPE_SEQUENCE, CLASS_UNIVERSAL, 1, derlen);
 323   if (!err)
 324     err = ksba_writer_write (w1, p, derlen);
 325   xfree (p); p = NULL;
 326
 327   /* And put a context tag around everything.  */
 328   p = ksba_writer_snatch_mem (w1, &derlen);
 329   if (!p)
 330     {
 331       err = ksba_writer_error (w1);
 332       goto leave;
 333     }
 334   err = _ksba_ber_write_tl (wout, 2, CLASS_CONTEXT, 1, derlen);
 335   if (!err)
 336     err = ksba_writer_write (wout, p, derlen);
 337   xfree (p); p = NULL;
 338
 339
 340  leave:
 341   ksba_writer_release (w2);
 342   ksba_writer_release (w1);
 343   return err;
 344 }
 345
 346
 347 /* Build a request from the current context.  The function checks that
 348    all necessary information have been set and stores the prepared
 349    request in the context.  A subsequent ksba_ocsp_build_request may
 350    then be used to retrieve this request.  Optional the requestmay be
 351    signed beofre calling ksba_ocsp_build_request.
 352  */
 353 gpg_error_t
 354 ksba_ocsp_prepare_request (ksba_ocsp_t ocsp)
 355 {
 356   gpg_error_t err;
 357   struct ocsp_reqitem_s *ri;
 358   unsigned char *p;
 359   const unsigned char *der;
 360   size_t derlen;
 361   struct tag_info ti;
 362   ksba_writer_t w1 = NULL;
 363   ksba_writer_t w2 = NULL;
 364   ksba_writer_t w3 = NULL;
 365   ksba_writer_t w4, w5, w6, w7; /* Used as aliases. */
 366
 367   if (!ocsp)
 368     return gpg_error (GPG_ERR_INV_VALUE);
 369
 370   xfree (ocsp->request_buffer);
 371   ocsp->request_buffer = NULL;
 372   ocsp->request_buflen = 0;
 373
 374   if (!ocsp->requestlist)
 375     return gpg_error (GPG_ERR_MISSING_ACTION);
 376
 377   /* Create three writer objects for construction of the request. */
 378   err = ksba_writer_new (&w3);
 379   if (!err)
 380     err = ksba_writer_set_mem (w3, 2048);
 381   if (!err)
 382     err = ksba_writer_new (&w2);
 383   if (!err)
 384     err = ksba_writer_new (&w1);
 385   if (err)
 386     goto leave;
 387
 388
 389   /* Loop over all single requests. */
 390   for (ri=ocsp->requestlist; ri; ri = ri->next)
 391     {
 392       err = ksba_writer_set_mem (w2, 256);
 393       if (!err)
 394         err = ksba_writer_set_mem (w1, 256);
 395       if (err)
 396         goto leave;
 397
 398       /* Write the AlgorithmIdentifier. */
 399       err = _ksba_der_write_algorithm_identifier (w1, oidstr_sha1, NULL, 0);
 400       if (err)
 401         goto leave;
 402
 403       /* Compute the issuerNameHash and write it into the CertID object. */
 404       err = issuer_name_hash (ri->issuer_cert, ri->issuer_name_hash);
 405       if (!err)
 406         err = _ksba_ber_write_tl (w1, TYPE_OCTET_STRING, CLASS_UNIVERSAL, 0,20);
 407       if (!err)
 408         err = ksba_writer_write (w1, ri->issuer_name_hash, 20);
 409       if(err)
 410         goto leave;
 411
 412       /* Compute the issuerKeyHash and write it. */
 413       err = issuer_key_hash (ri->issuer_cert, ri->issuer_key_hash);
 414       if (!err)
 415         err = _ksba_ber_write_tl (w1, TYPE_OCTET_STRING, CLASS_UNIVERSAL, 0,20);
 416       if (!err)
 417         err = ksba_writer_write (w1, ri->issuer_key_hash, 20);
 418       if (err)
 419         goto leave;
 420
 421       /* Write the serialNumber of the certificate to be checked. */
 422       err = _ksba_cert_get_serial_ptr (ri->cert, &der, &derlen);
 423       if (!err)
 424         err = ksba_writer_write (w1, der, derlen);
 425       if (err)
 426         goto leave;
 427       /* Store the integer value.  */
 428       {
 429         const unsigned char *tmpder = der;
 430         size_t tmpderlen = derlen;
 431
 432         err = parse_integer (&tmpder, &tmpderlen, &ti);
 433         if (err)
 434           goto leave;
 435         xfree (ri->serialno);
 436         ri->serialno = xtrymalloc (tmpderlen);
 437         if (!ri->serialno)
 438           {
 439             err = gpg_error_from_syserror ();
 440             goto leave;
 441           }
 442         memcpy (ri->serialno, tmpder, tmpderlen);
 443         ri->serialnolen = tmpderlen;
 444       }
 445
 446       /* Now write it out as a sequence to the outer certID object. */
 447       p = ksba_writer_snatch_mem (w1, &derlen);
 448       if (!p)
 449         {
 450           err = ksba_writer_error (w1);
 451           goto leave;
 452         }
 453       err = _ksba_ber_write_tl (w2, TYPE_SEQUENCE, CLASS_UNIVERSAL,
 454                                 1, derlen);
 455       if (!err)
 456         err = ksba_writer_write (w2, p, derlen);
 457       xfree (p); p = NULL;
 458       if (err)
 459         goto leave;
 460
 461       /* Here we would write singleRequestExtensions. */
 462
 463       /* Now write it out as a sequence to the outer Request object. */
 464       p = ksba_writer_snatch_mem (w2, &derlen);
 465       if (!p)
 466         {
 467           err = ksba_writer_error (w2);
 468           goto leave;
 469         }
 470       err = _ksba_ber_write_tl (w3, TYPE_SEQUENCE, CLASS_UNIVERSAL,
 471                                 1, derlen);
 472       if (!err)
 473         err = ksba_writer_write (w3, p, derlen);
 474       xfree (p); p = NULL;
 475       if (err)
 476         goto leave;
 477
 478     } /* End of looping over single requests. */
 479
 480   /* Reuse writers; for clarity, use new names. */
 481   w4 = w1;
 482   w5 = w2;
 483   err = ksba_writer_set_mem (w4, 2048);
 484   if (!err)
 485     err = ksba_writer_set_mem (w5, 2048);
 486   if (err)
 487     goto leave;
 488
 489   /* Put a sequence tag before the requestList. */
 490   p = ksba_writer_snatch_mem (w3, &derlen);
 491   if (!p)
 492     {
 493       err = ksba_writer_error (w3);
 494       goto leave;
 495     }
 496   err = _ksba_ber_write_tl (w4, TYPE_SEQUENCE, CLASS_UNIVERSAL,
 497                             1, derlen);
 498   if (!err)
 499     err = ksba_writer_write (w4, p, derlen);
 500   xfree (p); p = NULL;
 501   if (err)
 502     goto leave;
 503
 504   /* The requestExtensions go here. */
 505   err = write_request_extensions (ocsp, w4);
 506
 507   /* Write the tbsRequest. */
 508
 509   /* The version is default, thus we don't write it. */
 510
 511   /* The requesterName would go here. */
 512
 513   /* Write the requestList. */
 514   p = ksba_writer_snatch_mem (w4, &derlen);
 515   if (!p)
 516     {
 517       err = ksba_writer_error (w4);
 518       goto leave;
 519     }
 520   err = _ksba_ber_write_tl (w5, TYPE_SEQUENCE, CLASS_UNIVERSAL,
 521                             1, derlen);
 522   if (!err)
 523     err = ksba_writer_write (w5, p, derlen);
 524   xfree (p); p = NULL;
 525   if (err)
 526     goto leave;
 527
 528   /* Reuse writers; for clarity, use new names. */
 529   w6 = w3;
 530   w7 = w4;
 531   err = ksba_writer_set_mem (w6, 2048);
 532   if (!err)
 533     err = ksba_writer_set_mem (w7, 2048);
 534   if (err)
 535     goto leave;
 536
 537   /* Prepend a sequence tag. */
 538   p = ksba_writer_snatch_mem (w5, &derlen);
 539   if (!p)
 540     {
 541       err = ksba_writer_error (w5);
 542       goto leave;
 543     }
 544   err = _ksba_ber_write_tl (w6, TYPE_SEQUENCE, CLASS_UNIVERSAL,
 545                             1, derlen);
 546   if (!err)
 547     err = ksba_writer_write (w6, p, derlen);
 548   xfree (p); p = NULL;
 549   if (err)
 550     goto leave;
 551
 552   /* Write the ocspRequest. */
 553
 554   /* Note that we do not support the optional signature, because this
 555      saves us one writer object. */
 556
 557   /* Prepend a sequence tag. */
 558 /*   p = ksba_writer_snatch_mem (w6, &derlen); */
 559 /*   if (!p) */
 560 /*     { */
 561 /*       err = ksba_writer_error (w6); */
 562 /*       goto leave; */
 563 /*     } */
 564 /*   err = _ksba_ber_write_tl (w7, TYPE_SEQUENCE, CLASS_UNIVERSAL, */
 565 /*                             1, derlen); */
 566 /*   if (!err) */
 567 /*     err = ksba_writer_write (w7, p, derlen); */
 568 /*   xfree (p); p = NULL; */
 569 /*   if (err) */
 570 /*     goto leave; */
 571
 572
 573   /* Read out the entire request. */
 574   p = ksba_writer_snatch_mem (w6, &derlen);
 575   if (!p)
 576     {
 577       err = ksba_writer_error (w6);
 578       goto leave;
 579     }
 580   ocsp->request_buffer = p;
 581   ocsp->request_buflen = derlen;
 582   /* Ready. */
 583
 584  leave:
 585   ksba_writer_release (w3);
 586   ksba_writer_release (w2);
 587   ksba_writer_release (w1);
 588   return err;
 589 }
 590
 591
 592 gpg_error_t
 593 ksba_ocsp_hash_request (ksba_ocsp_t ocsp,
 594                         void (*hasher)(void *, const void *,
 595                                        size_t length),
 596                         void *hasher_arg)
 597 {
 598   (void)ocsp;
 599   (void)hasher;
 600   (void)hasher_arg;
 601   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
 602 }
 603
 604
 605 gpg_error_t
 606 ksba_ocsp_set_sig_val (ksba_ocsp_t ocsp,
 607                        ksba_const_sexp_t sigval)
 608 {
 609   (void)ocsp;
 610   (void)sigval;
 611   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
 612 }
 613
 614
 615 gpg_error_t
 616 ksba_ocsp_add_cert (ksba_ocsp_t ocsp, ksba_cert_t cert)
 617 {
 618   (void)ocsp;
 619   (void)cert;
 620   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
 621 }
 622
 623
 624
 625 /* Build a request from the current context.  The function checks that
 626    all necessary information have been set and then returns an
 627    allocated buffer with the resulting request.
 628  */
 629 gpg_error_t
 630 ksba_ocsp_build_request (ksba_ocsp_t ocsp,
 631                          unsigned char **r_buffer, size_t *r_buflen)
 632 {
 633   gpg_error_t err;
 634
 635   if (!ocsp || !r_buffer || !r_buflen)
 636     return gpg_error (GPG_ERR_INV_VALUE);
 637   *r_buffer = NULL;
 638   *r_buflen = 0;
 639
 640   if (!ocsp->requestlist)
 641     return gpg_error (GPG_ERR_MISSING_ACTION);
 642   if (!ocsp->request_buffer)
 643     {
 644       /* No prepare done, do it now. */
 645       err = ksba_ocsp_prepare_request (ocsp);
 646       if (err)
 647         return err;
 648       assert (ocsp->request_buffer);
 649     }
 650   *r_buffer = ocsp->request_buffer;
 651   *r_buflen = ocsp->request_buflen;
 652   ocsp->request_buffer = NULL;
 653   ocsp->request_buflen = 0;
 654   return 0;
 655 }
 656
 657
 658 \f
 659 /*
 660    Parse the response extensions and store them aways.  While doing
 661    this we also check the nonce extension.  A typical data ASN.1 blob
 662    with only the nonce extension as passed to this function is:
 663
 664     SEQUENCE {
 665       SEQUENCE {
 666         OBJECT IDENTIFIER ocspNonce (1 3 6 1 5 5 7 48 1 2)
 667         OCTET STRING, encapsulates {
 668             INTEGER
 669               41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50
 670             }
 671         }
 672       }
 673 */
 674
 675 static int
 676 parse_response_extensions (ksba_ocsp_t ocsp,
 677                           const unsigned char *data, size_t datalen)
 678 {
 679   gpg_error_t err;
 680   struct tag_info ti;
 681   size_t length;
 682   char *oid = NULL;
 683
 684   assert (!ocsp->response_extensions);
 685   err = parse_sequence (&data, &datalen, &ti);
 686   if (err)
 687     goto leave;
 688   length = ti.length;
 689   while (length)
 690     {
 691       struct ocsp_extension_s *ex;
 692       int is_crit;
 693
 694       err = parse_sequence (&data, &datalen, &ti);
 695       if (err)
 696         goto leave;
 697       if (length < ti.nhdr + ti.length)
 698         {
 699           err = gpg_error (GPG_ERR_BAD_BER);
 700           goto leave;
 701         }
 702       length -= ti.nhdr + ti.length;
 703
 704       xfree (oid);
 705       err = parse_object_id_into_str (&data, &datalen, &oid);
 706       if (err)
 707         goto leave;
 708       is_crit = 0;
 709       err = parse_optional_boolean (&data, &datalen, &is_crit);
 710       if (err)
 711         goto leave;
 712       err = parse_octet_string (&data, &datalen, &ti);
 713       if (err)
 714         goto leave;
 715       if (!strcmp (oid, oidstr_ocsp_nonce))
 716         {
 717           err = parse_octet_string (&data, &datalen, &ti);
 718           if (err)
 719             goto leave;
 720           if (ocsp->noncelen != ti.length
 721               || memcmp (ocsp->nonce, data, ti.length))
 722             ocsp->bad_nonce = 1;
 723         }
 724       ex = xtrymalloc (sizeof *ex + strlen (oid) + ti.length);
 725       if (!ex)
 726         {
 727           err = gpg_error_from_syserror ();
 728           goto leave;
 729         }
 730       ex->crit = is_crit;
 731       strcpy (ex->data, oid);
 732       ex->data[strlen (oid)] = 0;
 733       ex->off = strlen (oid) + 1;
 734       ex->len = ti.length;
 735       memcpy (ex->data + ex->off, data, ti.length);
 736       ex->next = ocsp->response_extensions;
 737       ocsp->response_extensions = ex;
 738
 739       parse_skip (&data, &datalen, &ti); /* Skip the octet string / integer. */
 740     }
 741
 742  leave:
 743   xfree (oid);
 744   return err;
 745 }
 746
 747
 748 /*
 749    Parse single extensions and store them away.
 750 */
 751 static int
 752 parse_single_extensions (struct ocsp_reqitem_s *ri,
 753                          const unsigned char *data, size_t datalen)
 754 {
 755   gpg_error_t err;
 756   struct tag_info ti;
 757   size_t length;
 758   char *oid = NULL;
 759
 760   assert (ri && !ri->single_extensions);
 761   err = parse_sequence (&data, &datalen, &ti);
 762   if (err)
 763     goto leave;
 764   length = ti.length;
 765   while (length)
 766     {
 767       struct ocsp_extension_s *ex;
 768       int is_crit;
 769
 770       err = parse_sequence (&data, &datalen, &ti);
 771       if (err)
 772         goto leave;
 773       if (length < ti.nhdr + ti.length)
 774         {
 775           err = gpg_error (GPG_ERR_BAD_BER);
 776           goto leave;
 777         }
 778       length -= ti.nhdr + ti.length;
 779
 780       xfree (oid);
 781       err = parse_object_id_into_str (&data, &datalen, &oid);
 782       if (err)
 783         goto leave;
 784       is_crit = 0;
 785       err = parse_optional_boolean (&data, &datalen, &is_crit);
 786       if (err)
 787         goto leave;
 788       err = parse_octet_string (&data, &datalen, &ti);
 789       if (err)
 790         goto leave;
 791       ex = xtrymalloc (sizeof *ex + strlen (oid) + ti.length);
 792       if (!ex)
 793         {
 794           err = gpg_error_from_syserror ();
 795           goto leave;
 796         }
 797       ex->crit = is_crit;
 798       strcpy (ex->data, oid);
 799       ex->data[strlen (oid)] = 0;
 800       ex->off = strlen (oid) + 1;
 801       ex->len = ti.length;
 802       memcpy (ex->data + ex->off, data, ti.length);
 803       ex->next = ri->single_extensions;
 804       ri->single_extensions = ex;
 805
 806       parse_skip (&data, &datalen, &ti); /* Skip the octet string / integer. */
 807     }
 808
 809  leave:
 810   xfree (oid);
 811   return err;
 812 }
 813
 814
 815 /* Parse the first part of a response:
 816
 817      OCSPResponse ::= SEQUENCE {
 818         responseStatus         OCSPResponseStatus,
 819         responseBytes          [0] EXPLICIT ResponseBytes OPTIONAL }
 820
 821      OCSPResponseStatus ::= ENUMERATED {
 822          successful            (0),  --Response has valid confirmations
 823          malformedRequest      (1),  --Illegal confirmation request
 824          internalError         (2),  --Internal error in issuer
 825          tryLater              (3),  --Try again later
 826                                      --(4) is not used
 827          sigRequired           (5),  --Must sign the request
 828          unauthorized          (6)   --Request unauthorized
 829      }
 830
 831      ResponseBytes ::=       SEQUENCE {
 832          responseType   OBJECT IDENTIFIER,
 833          response       OCTET STRING }
 834
 835    On success the RESPONSE_STATUS field of OCSP will be set to the
 836    response status and DATA will now point to the first byte in the
 837    octet string of the response; RLEN will be set to the length of
 838    this octet string.  Note thate DATALEN is also updated but might
 839    point to a value larger than RLEN points to, if the provided data
 840    is a part of a larger image. */
 841 static gpg_error_t
 842 parse_response_status (ksba_ocsp_t ocsp,
 843                        unsigned char const **data, size_t *datalen,
 844                        size_t *rlength)
 845 {
 846   gpg_error_t err;
 847   struct tag_info ti;
 848   char *oid;
 849
 850   *rlength = 0;
 851   /* Parse the OCSPResponse sequence. */
 852   err = parse_sequence (data, datalen, &ti);
 853   if (err)
 854     return err;
 855   /* Parse the OCSPResponseStatus. */
 856   err = parse_enumerated (data, datalen, &ti, 1);
 857   if (err)
 858     return err;
 859   switch (**data)
 860     {
 861     case 0:  ocsp->response_status = KSBA_OCSP_RSPSTATUS_SUCCESS; break;
 862     case 1:  ocsp->response_status = KSBA_OCSP_RSPSTATUS_MALFORMED; break;
 863     case 2:  ocsp->response_status = KSBA_OCSP_RSPSTATUS_INTERNAL; break;
 864     case 3:  ocsp->response_status = KSBA_OCSP_RSPSTATUS_TRYLATER; break;
 865     case 5:  ocsp->response_status = KSBA_OCSP_RSPSTATUS_SIGREQUIRED; break;
 866     case 6:  ocsp->response_status = KSBA_OCSP_RSPSTATUS_UNAUTHORIZED; break;
 867     default: ocsp->response_status = KSBA_OCSP_RSPSTATUS_OTHER; break;
 868     }
 869   parse_skip (data, datalen, &ti);
 870
 871   if (ocsp->response_status)
 872       return 0; /* This is an error reponse; we have to stop here. */
 873
 874   /* We have a successful reponse status, thus we check that
 875      ResponseBytes are actually available. */
 876   err = parse_context_tag (data, datalen, &ti, 0);
 877   if (err)
 878     return err;
 879   err = parse_sequence (data, datalen, &ti);
 880   if (err)
 881     return err;
 882   err = parse_object_id_into_str (data, datalen, &oid);
 883   if (err)
 884     return err;
 885   if (strcmp (oid, oidstr_ocsp_basic))
 886     {
 887       xfree (oid);
 888       return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL);
 889     }
 890   xfree (oid);
 891
 892   /* Check that the next field is an octet string. */
 893   err = parse_octet_string (data, datalen, &ti);
 894   if (err)
 895     return err;
 896   *rlength = ti.length;
 897   return 0;
 898 }
 899
 900 /* Parse the object:
 901
 902      SingleResponse ::= SEQUENCE {
 903       certID                       CertID,
 904       certStatus                   CertStatus,
 905       thisUpdate                   GeneralizedTime,
 906       nextUpdate         [0]       EXPLICIT GeneralizedTime OPTIONAL,
 907       singleExtensions   [1]       EXPLICIT Extensions OPTIONAL }
 908
 909      CertStatus ::= CHOICE {
 910        good        [0]     IMPLICIT NULL,
 911        revoked     [1]     IMPLICIT RevokedInfo,
 912        unknown     [2]     IMPLICIT UnknownInfo }
 913
 914      RevokedInfo ::= SEQUENCE {
 915        revocationTime              GeneralizedTime,
 916        revocationReason    [0]     EXPLICIT CRLReason OPTIONAL }
 917
 918      UnknownInfo ::= NULL -- this can be replaced with an enumeration
 919
 920 */
 921
 922 static gpg_error_t
 923 parse_single_response (ksba_ocsp_t ocsp,
 924                        unsigned char const **data, size_t *datalen)
 925 {
 926   gpg_error_t err;
 927   struct tag_info ti;
 928   const unsigned char *savedata;
 929   const unsigned char *endptr;
 930   size_t savedatalen;
 931   size_t n;
 932   char *oid;
 933   ksba_isotime_t this_update, next_update, revocation_time;
 934   int look_for_request;
 935   const unsigned char *name_hash;
 936   const unsigned char *key_hash;
 937   const unsigned char *serialno;
 938   size_t serialnolen;
 939   struct ocsp_reqitem_s *request_item = NULL;
 940
 941   /* The SingeResponse sequence. */
 942   err = parse_sequence (data, datalen, &ti);
 943   if (err)
 944     return err;
 945   endptr = *data + ti.length;
 946
 947   /* The CertID is
 948        SEQUENCE {
 949          hashAlgorithm       AlgorithmIdentifier,
 950          issuerNameHash      OCTET STRING, -- Hash of Issuer's DN
 951          issuerKeyHash       OCTET STRING, -- Hash of Issuers public key
 952          serialNumber        CertificateSerialNumber }
 953   */
 954   err = parse_sequence (data, datalen, &ti);
 955   if (err)
 956     return err;
 957   err = _ksba_parse_algorithm_identifier (*data, *datalen, &n, &oid);
 958   if (err)
 959     return err;
 960   assert (n <= *datalen);
 961   *data += n;
 962   *datalen -= n;
 963   /* gpgrt_log_debug ("algorithmIdentifier is `%s'\n", oid); */
 964   look_for_request = !strcmp (oid, oidstr_sha1);
 965   xfree (oid);
 966
 967   err = parse_octet_string (data, datalen, &ti);
 968   if (err)
 969     return err;
 970   name_hash = *data;
 971 /*   fprintf (stderr, "issuerNameHash=");  */
 972 /*   dump_hex (*data, ti.length); */
 973 /*   putc ('\n', stderr); */
 974   if (ti.length != 20)
 975     look_for_request = 0; /* Can't be a SHA-1 digest. */
 976   parse_skip (data, datalen, &ti);
 977
 978   err = parse_octet_string (data, datalen, &ti);
 979   if (err)
 980     return err;
 981   key_hash = *data;
 982 /*   fprintf (stderr, "issuerKeyHash=");  */
 983 /*   dump_hex (*data, ti.length); */
 984 /*   putc ('\n', stderr); */
 985   if (ti.length != 20)
 986     look_for_request = 0; /* Can't be a SHA-1 digest. */
 987   parse_skip (data, datalen, &ti);
 988
 989   err= parse_integer (data, datalen, &ti);
 990   if (err)
 991     return err;
 992   serialno = *data;
 993   serialnolen = ti.length;
 994 /*   fprintf (stderr, "serialNumber=");  */
 995 /*   dump_hex (*data, ti.length); */
 996 /*   putc ('\n', stderr); */
 997   parse_skip (data, datalen, &ti);
 998
 999   if (look_for_request)
1000     {
1001       for (request_item = ocsp->requestlist;
1002            request_item; request_item = request_item->next)
1003         if (!memcmp (request_item->issuer_name_hash, name_hash, 20)
1004             && !memcmp (request_item->issuer_key_hash, key_hash, 20)
1005             && request_item->serialnolen == serialnolen
1006             && !memcmp (request_item->serialno, serialno, serialnolen))
1007             break; /* Got it. */
1008     }
1009
1010
1011   /*
1012      CertStatus ::= CHOICE {
1013        good        [0]     IMPLICIT NULL,
1014        revoked     [1]     IMPLICIT RevokedInfo,
1015        unknown     [2]     IMPLICIT UnknownInfo }
1016   */
1017   *revocation_time = 0;
1018   err = _ksba_ber_parse_tl (data, datalen, &ti);
1019   if (err)
1020     return err;
1021   if (ti.length > *datalen)
1022     return gpg_error (GPG_ERR_BAD_BER);
1023   else if (ti.class == CLASS_CONTEXT && ti.tag == 0  && !ti.is_constructed)
1024     { /* good */
1025       if (!ti.length)
1026         ; /* Cope with zero length objects. */
1027       else if (*datalen && !**data)
1028         { /* Skip the NULL. */
1029           (*datalen)--;
1030           (*data)++;
1031         }
1032       else
1033         return gpg_error (GPG_ERR_INV_OBJ);
1034
1035       if (request_item)
1036         request_item->status = KSBA_STATUS_GOOD;
1037     }
1038   else if (ti.class == CLASS_CONTEXT && ti.tag == 1  && ti.is_constructed)
1039     { /* revoked */
1040       ksba_crl_reason_t reason = KSBA_CRLREASON_UNSPECIFIED;
1041
1042       err = parse_asntime_into_isotime (data, datalen, revocation_time);
1043       if (err)
1044         return err;
1045 /*       fprintf (stderr, "revocationTime=%s\n", revocation_time); */
1046       savedata = *data;
1047       savedatalen = *datalen;
1048       err = parse_context_tag (data, datalen, &ti, 0);
1049       if (err)
1050         {
1051           *data = savedata;
1052           *datalen = savedatalen;
1053         }
1054       else
1055         { /* Got a revocationReason. */
1056           err = parse_enumerated (data, datalen, &ti, 1);
1057           if (err)
1058             return err;
1059           switch (**data)
1060             {
1061             case  0: reason = KSBA_CRLREASON_UNSPECIFIED; break;
1062             case  1: reason = KSBA_CRLREASON_KEY_COMPROMISE; break;
1063             case  2: reason = KSBA_CRLREASON_CA_COMPROMISE; break;
1064             case  3: reason = KSBA_CRLREASON_AFFILIATION_CHANGED; break;
1065             case  4: reason = KSBA_CRLREASON_SUPERSEDED; break;
1066             case  5: reason = KSBA_CRLREASON_CESSATION_OF_OPERATION; break;
1067             case  6: reason = KSBA_CRLREASON_CERTIFICATE_HOLD; break;
1068             case  8: reason = KSBA_CRLREASON_REMOVE_FROM_CRL; break;
1069             case  9: reason = KSBA_CRLREASON_PRIVILEGE_WITHDRAWN; break;
1070             case 10: reason = KSBA_CRLREASON_AA_COMPROMISE; break;
1071             default: reason = KSBA_CRLREASON_OTHER; break;
1072             }
1073           parse_skip (data, datalen, &ti);
1074         }
1075 /*       fprintf (stderr, "revocationReason=%04x\n", reason); */
1076       if (request_item)
1077         {
1078           request_item->status = KSBA_STATUS_REVOKED;
1079           _ksba_copy_time (request_item->revocation_time, revocation_time);
1080           request_item->revocation_reason = reason;
1081         }
1082     }
1083   else if (ti.class == CLASS_CONTEXT && ti.tag == 2 && !ti.is_constructed
1084            && *datalen)
1085     { /* unknown */
1086       if (!ti.length)
1087         ; /* Cope with zero length objects. */
1088       else if (!**data)
1089         { /* Skip the NULL. */
1090           (*datalen)--;
1091           (*data)++;
1092         }
1093       else /* The comment indicates that an enumeration may come here. */
1094         {
1095           err = parse_enumerated (data, datalen, &ti, 0);
1096           if (err)
1097             return err;
1098           fprintf (stderr, "libksba: unknownReason with an enum of "
1099                    "length %u detected\n",
1100                    (unsigned int)ti.length);
1101           parse_skip (data, datalen, &ti);
1102         }
1103       if (request_item)
1104         request_item->status = KSBA_STATUS_UNKNOWN;
1105     }
1106   else
1107     err = gpg_error (GPG_ERR_INV_OBJ);
1108
1109   /* thisUpdate. */
1110   err = parse_asntime_into_isotime (data, datalen, this_update);
1111   if (err)
1112     return err;
1113   if (request_item)
1114     _ksba_copy_time (request_item->this_update, this_update);
1115
1116   /* nextUpdate is optional. */
1117   if (*data >= endptr)
1118     return 0;
1119   *next_update = 0;
1120   err = _ksba_ber_parse_tl (data, datalen, &ti);
1121   if (err)
1122     return err;
1123   if (ti.length > *datalen)
1124     return gpg_error (GPG_ERR_BAD_BER);
1125   else if (ti.class == CLASS_CONTEXT && ti.tag == 0  && ti.is_constructed)
1126     { /* have nextUpdate */
1127       err = parse_asntime_into_isotime (data, datalen, next_update);
1128       if (err)
1129         return err;
1130       if (request_item)
1131         _ksba_copy_time (request_item->next_update, next_update);
1132     }
1133   else if (ti.class == CLASS_CONTEXT && ti.tag == 1  && ti.is_constructed)
1134     { /* Undo that read. */
1135       *data -= ti.nhdr;
1136       *datalen += ti.nhdr;
1137     }
1138   else
1139     err = gpg_error (GPG_ERR_INV_OBJ);
1140
1141   /* singleExtensions is optional */
1142   if (*data >= endptr)
1143     return 0;
1144   err = _ksba_ber_parse_tl (data, datalen, &ti);
1145   if (err)
1146     return err;
1147   if (ti.length > *datalen)
1148     return gpg_error (GPG_ERR_BAD_BER);
1149   if (ti.class == CLASS_CONTEXT && ti.tag == 1  && ti.is_constructed)
1150     {
1151       if (request_item)
1152         {
1153           err = parse_single_extensions (request_item, *data, ti.length);
1154           if (err)
1155             return err;
1156         }
1157       parse_skip (data, datalen, &ti);
1158     }
1159   else
1160     err = gpg_error (GPG_ERR_INV_OBJ);
1161
1162   return 0;
1163 }
1164
1165 /* Parse the object:
1166
1167         ResponseData ::= SEQUENCE {
1168            version              [0] EXPLICIT Version DEFAULT v1,
1169            responderID              ResponderID,
1170            producedAt               GeneralizedTime,
1171            responses                SEQUENCE OF SingleResponse,
1172            responseExtensions   [1] EXPLICIT Extensions OPTIONAL }
1173
1174         ResponderID ::= CHOICE {
1175            byName               [1] Name,
1176            byKey                [2] KeyHash }
1177
1178
1179 */
1180 static gpg_error_t
1181 parse_response_data (ksba_ocsp_t ocsp,
1182                      unsigned char const **data, size_t *datalen)
1183 {
1184   gpg_error_t err;
1185   struct tag_info ti;
1186   const unsigned char *savedata;
1187   size_t savedatalen;
1188   size_t responses_length;
1189
1190   /* The out er sequence. */
1191   err = parse_sequence (data, datalen, &ti);
1192   if (err)
1193     return err;
1194
1195   /* The optional version field. */
1196   savedata = *data;
1197   savedatalen = *datalen;
1198   err = parse_context_tag (data, datalen, &ti, 0);
1199   if (err)
1200     {
1201       *data = savedata;
1202       *datalen = savedatalen;
1203     }
1204   else
1205     {
1206       /* FIXME: check that the version matches. */
1207       parse_skip (data, datalen, &ti);
1208     }
1209
1210   /* The responderID field. */
1211   assert (!ocsp->responder_id.name);
1212   assert (!ocsp->responder_id.keyid);
1213   err = _ksba_ber_parse_tl (data, datalen, &ti);
1214   if (err)
1215     return err;
1216   if (ti.length > *datalen)
1217     return gpg_error (GPG_ERR_BAD_BER);
1218   else if (ti.class == CLASS_CONTEXT && ti.tag == 1  && ti.is_constructed)
1219     { /* byName. */
1220       err = _ksba_derdn_to_str (*data, ti.length, &ocsp->responder_id.name);
1221       if (err)
1222         return err;
1223       parse_skip (data, datalen, &ti);
1224     }
1225   else if (ti.class == CLASS_CONTEXT && ti.tag == 2  && ti.is_constructed)
1226     { /* byKey. */
1227       err = parse_octet_string (data, datalen, &ti);
1228       if (err)
1229         return err;
1230       if (!ti.length)
1231         return gpg_error (GPG_ERR_INV_OBJ); /* Zero length key id.  */
1232       ocsp->responder_id.keyid = xtrymalloc (ti.length);
1233       if (!ocsp->responder_id.keyid)
1234         return gpg_error_from_syserror ();
1235       memcpy (ocsp->responder_id.keyid, *data, ti.length);
1236       ocsp->responder_id.keyidlen = ti.length;
1237       parse_skip (data, datalen, &ti);
1238     }
1239   else
1240     err = gpg_error (GPG_ERR_INV_OBJ);
1241
1242   /* The producedAt field. */
1243   err = parse_asntime_into_isotime (data, datalen, ocsp->produced_at);
1244   if (err)
1245     return err;
1246
1247   /* The responses field set. */
1248   err = parse_sequence (data, datalen, &ti);
1249   if (err )
1250     return err;
1251   responses_length = ti.length;
1252   while (responses_length)
1253     {
1254       savedatalen = *datalen;
1255       err = parse_single_response (ocsp, data, datalen);
1256       if (err)
1257         return err;
1258       assert (responses_length >= savedatalen - *datalen);
1259       responses_length -= savedatalen - *datalen;
1260     }
1261
1262   /* The optional responseExtensions set. */
1263   savedata = *data;
1264   savedatalen = *datalen;
1265   err = parse_context_tag (data, datalen, &ti, 1);
1266   if (!err)
1267     {
1268       err = parse_response_extensions (ocsp, *data, ti.length);
1269       if (err)
1270         return err;
1271       parse_skip (data, datalen, &ti);
1272     }
1273   else if (gpg_err_code (err) == GPG_ERR_INV_OBJ)
1274     {
1275       *data = savedata;
1276       *datalen = savedatalen;
1277     }
1278   else
1279     return err;
1280
1281   return 0;
1282 }
1283
1284
1285 /* Parse the entire response message pointed to by MSG of length
1286    MSGLEN. */
1287 static gpg_error_t
1288 parse_response (ksba_ocsp_t ocsp, const unsigned char *msg, size_t msglen)
1289 {
1290   gpg_error_t err;
1291   struct tag_info ti;
1292   const unsigned char *msgstart;
1293   const unsigned char *endptr;
1294   const char *s;
1295   size_t len;
1296
1297
1298   msgstart = msg;
1299   err = parse_response_status (ocsp, &msg, &msglen, &len);
1300   if (err)
1301     return err;
1302   msglen = len; /* We don't care about any extra bytes provided to us. */
1303   if (ocsp->response_status)
1304     {
1305 /*       fprintf (stderr,"response status found to be %d - stop\n", */
1306 /*                ocsp->response_status); */
1307       return 0;
1308     }
1309
1310   /* Now that we are sure that it is a BasicOCSPResponse, we can parse
1311      the really important things:
1312
1313      BasicOCSPResponse       ::= SEQUENCE {
1314      tbsResponseData      ResponseData,
1315      signatureAlgorithm   AlgorithmIdentifier,
1316      signature            BIT STRING,
1317      certs                [0] EXPLICIT SEQUENCE OF Certificate OPTIONAL }
1318   */
1319   err = parse_sequence (&msg, &msglen, &ti);
1320   if (err)
1321     return err;
1322   endptr = msg + ti.length;
1323
1324   ocsp->hash_offset = msg - msgstart;
1325   err = parse_response_data (ocsp, &msg, &msglen);
1326   if (err)
1327     return err;
1328   ocsp->hash_length = msg - msgstart - ocsp->hash_offset;
1329
1330   /* The signatureAlgorithm and the signature. We only need to get the
1331      length of both objects and let a specialized function do the
1332      actual parsing. */
1333   s = msg;
1334   len = msglen;
1335   err = parse_sequence (&msg, &msglen, &ti);
1336   if (err)
1337     return err;
1338   parse_skip (&msg, &msglen, &ti);
1339   err= _ksba_ber_parse_tl (&msg, &msglen, &ti);
1340   if (err)
1341     return err;
1342   if (!(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_BIT_STRING
1343         && !ti.is_constructed) )
1344     err = gpg_error (GPG_ERR_INV_OBJ);
1345   else if (!ti.length)
1346     err = gpg_error (GPG_ERR_TOO_SHORT);
1347   else if (ti.length > msglen)
1348     err = gpg_error (GPG_ERR_BAD_BER);
1349   parse_skip (&msg, &msglen, &ti);
1350   len = len - msglen;
1351   xfree (ocsp->sigval); ocsp->sigval = NULL;
1352   err =  _ksba_sigval_to_sexp (s, len, &ocsp->sigval);
1353   if (err)
1354     return err;
1355
1356   /* Parse the optional sequence of certificates. */
1357   if (msg >= endptr)
1358     return 0; /* It's optional, so stop now. */
1359   err = parse_context_tag (&msg, &msglen, &ti, 0);
1360   if (gpg_err_code (err) == GPG_ERR_INV_OBJ)
1361     return 0; /* Not the right tag. Stop here. */
1362   if (err)
1363     return err;
1364   err = parse_sequence (&msg, &msglen, &ti);
1365   if (err)
1366     return err;
1367   if (ti.ndef)
1368     return gpg_error (GPG_ERR_UNSUPPORTED_ENCODING);
1369
1370   {
1371     ksba_cert_t cert;
1372     struct ocsp_certlist_s *cl, **cl_tail;
1373
1374     assert (!ocsp->received_certs);
1375     cl_tail = &ocsp->received_certs;
1376     endptr = msg + ti.length;
1377     while (msg < endptr)
1378       {
1379         /* Find the length of the certificate. */
1380         s = msg;
1381         err = parse_sequence (&msg, &msglen, &ti);
1382         if (err)
1383           return err;
1384         err = ksba_cert_new (&cert);
1385         if (err)
1386           return err;
1387         err = ksba_cert_init_from_mem (cert, msg - ti.nhdr,
1388                                        ti.nhdr + ti.length);
1389         if (err)
1390           {
1391             ksba_cert_release (cert);
1392             return err;
1393           }
1394         parse_skip (&msg, &msglen, &ti);
1395         cl = xtrycalloc (1, sizeof *cl);
1396         if (!cl)
1397           {
1398             err = gpg_error_from_syserror ();
1399             ksba_cert_release (cert);
1400             return err;
1401           }
1402
1403         cl->cert = cert;
1404
1405         *cl_tail = cl;
1406         cl_tail = &cl->next;
1407       }
1408   }
1409
1410   return 0;
1411 }
1412
1413
1414 /* Given the OCSP context and a binary reponse message of MSGLEN bytes
1415    in MSG, this fucntion parses the response and prepares it for
1416    signature verification.  The status from the server is returned in
1417    RESPONSE_STATUS and must be checked even if the function returns
1418    without an error. */
1419 gpg_error_t
1420 ksba_ocsp_parse_response (ksba_ocsp_t ocsp,
1421                           const unsigned char *msg, size_t msglen,
1422                           ksba_ocsp_response_status_t *response_status)
1423 {
1424   gpg_error_t err;
1425   struct ocsp_reqitem_s *ri;
1426
1427   if (!ocsp || !msg || !msglen || !response_status)
1428     return gpg_error (GPG_ERR_INV_VALUE);
1429
1430   if (!ocsp->requestlist)
1431     return gpg_error (GPG_ERR_MISSING_ACTION);
1432
1433   /* Reset the fields used to track the response.  This is so that we
1434      can use the parse function a second time for the same
1435      request. This is useful in case of a TryLater response status. */
1436   ocsp->response_status = KSBA_OCSP_RSPSTATUS_NONE;
1437   release_ocsp_certlist (ocsp->received_certs);
1438   release_ocsp_extensions (ocsp->response_extensions);
1439   ocsp->received_certs = NULL;
1440   ocsp->hash_length = 0;
1441   ocsp->bad_nonce = 0;
1442   xfree (ocsp->responder_id.name);
1443   ocsp->responder_id.name = NULL;
1444   xfree (ocsp->responder_id.keyid);
1445   ocsp->responder_id.keyid = NULL;
1446   for (ri=ocsp->requestlist; ri; ri = ri->next)
1447     {
1448       ri->status = KSBA_STATUS_NONE;
1449       *ri->this_update = 0;
1450       *ri->next_update = 0;
1451       *ri->revocation_time = 0;
1452       ri->revocation_reason = 0;
1453       release_ocsp_extensions (ri->single_extensions);
1454     }
1455
1456   /* Run the actual parser.  */
1457   err = parse_response (ocsp, msg, msglen);
1458   *response_status = ocsp->response_status;
1459
1460   /* FIXME: find duplicates in the request list and set them to the
1461      same status. */
1462
1463   /* We used to assume that the server needs to return a nonce, but
1464    * that is not true (see for example RFC-8954).  Thus we do not
1465    * check the former good_nonce flag anymore.  */
1466   if (*response_status == KSBA_OCSP_RSPSTATUS_SUCCESS
1467       && ocsp->bad_nonce)
1468     *response_status = KSBA_OCSP_RSPSTATUS_REPLAYED;
1469
1470   return err;
1471 }
1472
1473
1474 /* Return the digest algorithm to be used for the signature or NULL in
1475    case of an error.  The returned pointer is valid as long as the
1476    context is valid and no other ksba_ocsp_parse_response or
1477    ksba_ocsp_build_request has been used. */
1478 const char *
1479 ksba_ocsp_get_digest_algo (ksba_ocsp_t ocsp)
1480 {
1481   return ocsp? ocsp->digest_oid : NULL;
1482 }
1483
1484
1485 /* Hash the data of the response using the hash function HASHER which
1486    will be passed HASHER_ARG as its first argument and a pointer and a
1487    length of the data to be hashed. This hash function might be called
1488    several times and should update the hash context.  The algorithm to
1489    be used for the hashing can be retrieved using
1490    ksba_ocsp_get_digest_algo. Note that MSG and MSGLEN should be
1491    indentical to the values passed to ksba_ocsp_parse_response. */
1492 gpg_error_t
1493 ksba_ocsp_hash_response (ksba_ocsp_t ocsp,
1494                          const unsigned char *msg, size_t msglen,
1495                          void (*hasher)(void *, const void *, size_t length),
1496                          void *hasher_arg)
1497
1498 {
1499   if (!ocsp || !msg || !hasher)
1500     return gpg_error (GPG_ERR_INV_VALUE);
1501   if (!ocsp->hash_length)
1502     return gpg_error (GPG_ERR_MISSING_ACTION);
1503   if (ocsp->hash_offset + ocsp->hash_length >= msglen)
1504     return gpg_error (GPG_ERR_CONFLICT);
1505
1506   hasher (hasher_arg, msg + ocsp->hash_offset, ocsp->hash_length);
1507   return 0;
1508 }
1509
1510
1511 /* Return the actual signature in a format suitable to be used as
1512    input to Libgcrypt's verification function.  The caller must free
1513    the returned string and that function may be called only once after
1514    a successful ksba_ocsp_parse_response. Returns NULL for an invalid
1515    handle or if no signature is available. If PRODUCED_AT is not NULL,
1516    it will receive the time the response was signed. */
1517 ksba_sexp_t
1518 ksba_ocsp_get_sig_val (ksba_ocsp_t ocsp, ksba_isotime_t produced_at)
1519 {
1520   ksba_sexp_t p;
1521
1522   if (produced_at)
1523     *produced_at = 0;
1524   if (!ocsp || !ocsp->sigval )
1525     return NULL;
1526
1527   if (produced_at)
1528     _ksba_copy_time (produced_at, ocsp->produced_at);
1529
1530   p = ocsp->sigval;
1531   ocsp->sigval = NULL;
1532   return p;
1533 }
1534
1535
1536 /* Return the responder ID for the current response into R_NAME or
1537    into R_KEYID.  On sucess either R_NAME or R_KEYID will receive an
1538    allocated object.  If R_NAME or R_KEYID has been passed as NULL but
1539    a value is available the errorcode GPG_ERR_NO_DATA is returned.
1540    Caller must release the values stored at R_NAME or R_KEYID; the
1541    function stores NULL tehre in case of an error.  */
1542 gpg_error_t
1543 ksba_ocsp_get_responder_id (ksba_ocsp_t ocsp,
1544                             char **r_name, ksba_sexp_t *r_keyid)
1545 {
1546   if (r_name)
1547     *r_name = NULL;
1548   if (r_keyid)
1549     *r_keyid = NULL;
1550
1551   if (!ocsp)
1552     return gpg_error (GPG_ERR_INV_VALUE);
1553
1554   if (ocsp->responder_id.name && r_name)
1555     {
1556       *r_name = xtrystrdup (ocsp->responder_id.name);
1557       if (!*r_name)
1558         return gpg_error_from_syserror ();
1559     }
1560   else if (ocsp->responder_id.keyid && r_keyid)
1561     {
1562       char numbuf[50];
1563       size_t numbuflen;
1564
1565       sprintf (numbuf,"(%lu:", (unsigned long)ocsp->responder_id.keyidlen);
1566       numbuflen = strlen (numbuf);
1567       *r_keyid = xtrymalloc (numbuflen + ocsp->responder_id.keyidlen + 2);
1568       if (!*r_keyid)
1569         return gpg_error_from_syserror ();
1570       strcpy (*r_keyid, numbuf);
1571       memcpy (*r_keyid+numbuflen,
1572               ocsp->responder_id.keyid, ocsp->responder_id.keyidlen);
1573       (*r_keyid)[numbuflen + ocsp->responder_id.keyidlen] = ')';
1574       (*r_keyid)[numbuflen + ocsp->responder_id.keyidlen + 1] = 0;
1575     }
1576   else
1577     return gpg_error (GPG_ERR_NO_DATA);
1578
1579   return 0;
1580 }
1581
1582
1583 /* Get optional certificates out of a response.  The caller may use
1584  * this in a loop to get all certificates.  The returned certificate
1585  * is a shallow copy of the original one; the caller must still use
1586  * ksba_cert_release() to free it. Returns: A certificate object or
1587  * NULL for end of list or error. */
1588 ksba_cert_t
1589 ksba_ocsp_get_cert (ksba_ocsp_t ocsp, int idx)
1590 {
1591   struct ocsp_certlist_s *cl;
1592
1593   if (!ocsp || idx < 0)
1594     return NULL;
1595
1596   for (cl=ocsp->received_certs; cl && idx; cl = cl->next, idx--)
1597     ;
1598   if (!cl)
1599     return NULL;
1600   ksba_cert_ref (cl->cert);
1601   return cl->cert;
1602 }
1603
1604
1605
1606
1607 /* Return the status of the certificate CERT for the last response
1608    done on the context OCSP.  CERT must be the same certificate as
1609    used for the request; only a shallow compare is done (i.e. the
1610    pointers are compared).  R_STATUS returns the status value,
1611    R_THIS_UPDATE and R_NEXT_UPDATE are the corresponding OCSP response
1612    values, R_REVOCATION_TIME is only set to the revocation time if the
1613    indicated status is revoked, R_REASON will be set to the reason
1614    given for a revocation.  All the R_* arguments may be given as NULL
1615    if the value is not required.  The function return 0 on success,
1616    GPG_ERR_NOT_FOUND if CERT was not used in the request or any other
1617    error code.  Note that the caller should have checked the signature
1618    of the entire reponse to be good before using the stati retruned by
1619    this function. */
1620 gpg_error_t
1621 ksba_ocsp_get_status (ksba_ocsp_t ocsp, ksba_cert_t cert,
1622                       ksba_status_t *r_status,
1623                       ksba_isotime_t r_this_update,
1624                       ksba_isotime_t r_next_update,
1625                       ksba_isotime_t r_revocation_time,
1626                       ksba_crl_reason_t *r_reason)
1627 {
1628   struct ocsp_reqitem_s *ri;
1629
1630   if (!ocsp || !cert || !r_status)
1631     return gpg_error (GPG_ERR_INV_VALUE);
1632   if (!ocsp->requestlist)
1633     return gpg_error (GPG_ERR_MISSING_ACTION);
1634
1635   /* Find the certificate.  We don't care about the issuer certificate
1636      and stop at the first match.  The implementation may be optimized
1637      by keeping track of the last certificate found to start with the
1638      next one then.  Given that a usual request consists only of a few
1639      certificates, this does not make much sense in reality. */
1640   for (ri=ocsp->requestlist; ri; ri = ri->next)
1641     if (ri->cert == cert)
1642       break;
1643   if (!ri)
1644     return gpg_error (GPG_ERR_NOT_FOUND);
1645   if (r_status)
1646     *r_status = ri->status;
1647   if (r_this_update)
1648     _ksba_copy_time (r_this_update, ri->this_update);
1649   if (r_next_update)
1650     _ksba_copy_time (r_next_update, ri->next_update);
1651   if (r_revocation_time)
1652     _ksba_copy_time (r_revocation_time, ri->revocation_time);
1653   if (r_reason)
1654     *r_reason = ri->revocation_reason;
1655   return 0;
1656 }
1657
1658
1659 /* WARNING: The returned values ares only valid as long as no other
1660    ocsp function is called on the same context.  */
1661 gpg_error_t
1662 ksba_ocsp_get_extension (ksba_ocsp_t ocsp, ksba_cert_t cert, int idx,
1663                          char const **r_oid, int *r_crit,
1664                          unsigned char const **r_der, size_t *r_derlen)
1665 {
1666   struct ocsp_extension_s *ex;
1667
1668   if (!ocsp)
1669     return gpg_error (GPG_ERR_INV_VALUE);
1670   if (!ocsp->requestlist)
1671     return gpg_error (GPG_ERR_MISSING_ACTION);
1672   if (idx < 0)
1673     return gpg_error (GPG_ERR_INV_INDEX);
1674
1675   if (cert)
1676     {
1677       /* Return extensions for the certificate (singleExtensions).  */
1678       struct ocsp_reqitem_s *ri;
1679
1680       for (ri=ocsp->requestlist; ri; ri = ri->next)
1681         if (ri->cert == cert)
1682           break;
1683       if (!ri)
1684         return gpg_error (GPG_ERR_NOT_FOUND);
1685
1686       for (ex=ri->single_extensions; ex && idx; ex = ex->next, idx--)
1687         ;
1688       if (!ex)
1689         return gpg_error (GPG_ERR_EOF); /* No more extensions. */
1690     }
1691   else
1692     {
1693       /* Return extensions for the response (responseExtensions).  */
1694       for (ex=ocsp->response_extensions; ex && idx; ex = ex->next, idx--)
1695         ;
1696       if (!ex)
1697         return gpg_error (GPG_ERR_EOF); /* No more extensions. */
1698     }
1699
1700   if (r_oid)
1701     *r_oid = ex->data;
1702   if (r_crit)
1703     *r_crit = ex->crit;
1704   if (r_der)
1705     *r_der = ex->data + ex->off;
1706   if (r_derlen)
1707     *r_derlen = ex->len;
1708
1709   return 0;
1710 }