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