dirmngr/ocsp.c

   1 /* ocsp.c - OCSP management
   2  *      Copyright (C) 2004, 2007 g10 Code GmbH
   3  *
   4  * This file is part of DirMngr.
   5  *
   6  * DirMngr is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * DirMngr is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <errno.h>
  25 #include <assert.h>
  26
  27 #include "dirmngr.h"
  28 #include "misc.h"
  29 #include "http.h"
  30 #include "validate.h"
  31 #include "certcache.h"
  32 #include "ocsp.h"
  33
  34 /* The maximum size we allow as a response from an OCSP reponder. */
  35 #define MAX_RESPONSE_SIZE 65536
  36
  37
  38 static const char oidstr_ocsp[] = "1.3.6.1.5.5.7.48.1";
  39
  40
  41 /* Telesec attribute used to implement a positive confirmation.
  42
  43    CertHash ::= SEQUENCE {
  44       HashAlgorithm    AlgorithmIdentifier,
  45       certificateHash OCTET STRING }
  46  */
  47 /* static const char oidstr_certHash[] = "1.3.36.8.3.13"; */
  48
  49
  50
  51
  52 /* Read from FP and return a newly allocated buffer in R_BUFFER with the
  53    entire data read from FP. */
  54 static gpg_error_t
  55 read_response (estream_t fp, unsigned char **r_buffer, size_t *r_buflen)
  56 {
  57   gpg_error_t err;
  58   unsigned char *buffer;
  59   size_t bufsize, nbytes;
  60
  61   *r_buffer = NULL;
  62   *r_buflen = 0;
  63
  64   bufsize = 4096;
  65   buffer = xtrymalloc (bufsize);
  66   if (!buffer)
  67     return gpg_error_from_errno (errno);
  68
  69   nbytes = 0;
  70   for (;;)
  71     {
  72       unsigned char *tmp;
  73       size_t nread = 0;
  74
  75       assert (nbytes < bufsize);
  76       nread = es_fread (buffer+nbytes, 1, bufsize-nbytes, fp);
  77       if (nread < bufsize-nbytes && es_ferror (fp))
  78         {
  79           err = gpg_error_from_errno (errno);
  80           log_error (_("error reading from responder: %s\n"),
  81                      strerror (errno));
  82           xfree (buffer);
  83           return err;
  84         }
  85       if ( !(nread == bufsize-nbytes && !es_feof (fp)))
  86         { /* Response successfully received. */
  87           nbytes += nread;
  88           *r_buffer = buffer;
  89           *r_buflen = nbytes;
  90           return 0;
  91         }
  92
  93       nbytes += nread;
  94
  95       /* Need to enlarge the buffer. */
  96       if (bufsize >= MAX_RESPONSE_SIZE)
  97         {
  98           log_error (_("response from server too large; limit is %d bytes\n"),
  99                      MAX_RESPONSE_SIZE);
 100           xfree (buffer);
 101           return gpg_error (GPG_ERR_TOO_LARGE);
 102         }
 103
 104       bufsize += 4096;
 105       tmp = xtryrealloc (buffer, bufsize);
 106       if (!tmp)
 107         {
 108           err = gpg_error_from_errno (errno);
 109           xfree (buffer);
 110           return err;
 111         }
 112       buffer = tmp;
 113     }
 114 }
 115
 116
 117 /* Construct an OCSP request, send it to the configured OCSP responder
 118    and parse the response. On success the OCSP context may be used to
 119    further process the response.  The signature value and the
 120    production date are returned at R_SIGVAL and R_PRODUCED_AT; they
 121    may be NULL or an empty string if not available.  A new hash
 122    context is returned at R_MD.  */
 123 static gpg_error_t
 124 do_ocsp_request (ctrl_t ctrl, ksba_ocsp_t ocsp,
 125                  const char *url, ksba_cert_t cert, ksba_cert_t issuer_cert,
 126                  ksba_sexp_t *r_sigval, ksba_isotime_t r_produced_at,
 127                  gcry_md_hd_t *r_md)
 128 {
 129   gpg_error_t err;
 130   unsigned char *request, *response;
 131   size_t requestlen, responselen;
 132   http_t http;
 133   ksba_ocsp_response_status_t response_status;
 134   const char *t;
 135   int redirects_left = 2;
 136   char *free_this = NULL;
 137
 138   (void)ctrl;
 139
 140   *r_sigval = NULL;
 141   *r_produced_at = 0;
 142   *r_md = NULL;
 143
 144   if (dirmngr_use_tor ())
 145     {
 146       /* For now we do not allow OCSP via Tor due to possible privacy
 147          concerns.  Needs further research.  */
 148       const char *msg = _("OCSP request not possible due to Tor mode");
 149       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
 150       log_error ("%s", msg);
 151       dirmngr_status_printf (ctrl, "NOTE", "no_ocsp_due_to_tor %u %s", err,msg);
 152       return err;
 153     }
 154
 155   if (opt.disable_http)
 156     {
 157       log_error (_("OCSP request not possible due to disabled HTTP\n"));
 158       return gpg_error (GPG_ERR_NOT_SUPPORTED);
 159     }
 160
 161   err = ksba_ocsp_add_target (ocsp, cert, issuer_cert);
 162   if (err)
 163     {
 164       log_error (_("error setting OCSP target: %s\n"), gpg_strerror (err));
 165       return err;
 166     }
 167
 168   {
 169     size_t n;
 170     unsigned char nonce[32];
 171
 172     n = ksba_ocsp_set_nonce (ocsp, NULL, 0);
 173     if (n > sizeof nonce)
 174       n = sizeof nonce;
 175     gcry_create_nonce (nonce, n);
 176     ksba_ocsp_set_nonce (ocsp, nonce, n);
 177   }
 178
 179   err = ksba_ocsp_build_request (ocsp, &request, &requestlen);
 180   if (err)
 181     {
 182       log_error (_("error building OCSP request: %s\n"), gpg_strerror (err));
 183       return err;
 184     }
 185
 186  once_more:
 187   err = http_open (ctrl, &http, HTTP_REQ_POST, url, NULL, NULL,
 188                    ((opt.honor_http_proxy? HTTP_FLAG_TRY_PROXY:0)
 189                     | (dirmngr_use_tor ()? HTTP_FLAG_FORCE_TOR:0)
 190                     | (opt.disable_ipv4? HTTP_FLAG_IGNORE_IPv4 : 0)
 191                     | (opt.disable_ipv6? HTTP_FLAG_IGNORE_IPv6 : 0)),
 192                    ctrl->http_proxy, NULL, NULL, NULL);
 193   if (err)
 194     {
 195       log_error (_("error connecting to '%s': %s\n"), url, gpg_strerror (err));
 196       xfree (free_this);
 197       return err;
 198     }
 199
 200   es_fprintf (http_get_write_ptr (http),
 201               "Content-Type: application/ocsp-request\r\n"
 202               "Content-Length: %lu\r\n",
 203               (unsigned long)requestlen );
 204   http_start_data (http);
 205   if (es_fwrite (request, requestlen, 1, http_get_write_ptr (http)) != 1)
 206     {
 207       err = gpg_error_from_errno (errno);
 208       log_error ("error sending request to '%s': %s\n", url, strerror (errno));
 209       http_close (http, 0);
 210       xfree (request);
 211       xfree (free_this);
 212       return err;
 213     }
 214   xfree (request);
 215   request = NULL;
 216
 217   err = http_wait_response (http);
 218   if (err || http_get_status_code (http) != 200)
 219     {
 220       if (err)
 221         log_error (_("error reading HTTP response for '%s': %s\n"),
 222                    url, gpg_strerror (err));
 223       else
 224         {
 225           switch (http_get_status_code (http))
 226             {
 227             case 301:
 228             case 302:
 229               {
 230                 const char *s = http_get_header (http, "Location");
 231
 232                 log_info (_("URL '%s' redirected to '%s' (%u)\n"),
 233                           url, s?s:"[none]", http_get_status_code (http));
 234                 if (s && *s && redirects_left-- )
 235                   {
 236                     xfree (free_this); url = NULL;
 237                     free_this = xtrystrdup (s);
 238                     if (!free_this)
 239                       err = gpg_error_from_errno (errno);
 240                     else
 241                       {
 242                         url = free_this;
 243                         http_close (http, 0);
 244                         goto once_more;
 245                       }
 246                   }
 247                 else
 248                   err = gpg_error (GPG_ERR_NO_DATA);
 249                 log_error (_("too many redirections\n"));
 250               }
 251               break;
 252
 253             case 413:  /* Payload too large */
 254               err = gpg_error (GPG_ERR_TOO_LARGE);
 255               break;
 256
 257             default:
 258               log_error (_("error accessing '%s': http status %u\n"),
 259                          url, http_get_status_code (http));
 260               err = gpg_error (GPG_ERR_NO_DATA);
 261               break;
 262             }
 263         }
 264       http_close (http, 0);
 265       xfree (free_this);
 266       return err;
 267     }
 268
 269   err = read_response (http_get_read_ptr (http), &response, &responselen);
 270   http_close (http, 0);
 271   if (err)
 272     {
 273       log_error (_("error reading HTTP response for '%s': %s\n"),
 274                  url, gpg_strerror (err));
 275       xfree (free_this);
 276       return err;
 277     }
 278   /* log_printhex (response, responselen, "ocsp response"); */
 279
 280   err = ksba_ocsp_parse_response (ocsp, response, responselen,
 281                                   &response_status);
 282   if (err)
 283     {
 284       log_error (_("error parsing OCSP response for '%s': %s\n"),
 285                  url, gpg_strerror (err));
 286       xfree (response);
 287       xfree (free_this);
 288       return err;
 289     }
 290
 291   switch (response_status)
 292     {
 293     case KSBA_OCSP_RSPSTATUS_SUCCESS:      t = "success"; break;
 294     case KSBA_OCSP_RSPSTATUS_MALFORMED:    t = "malformed"; break;
 295     case KSBA_OCSP_RSPSTATUS_INTERNAL:     t = "internal error"; break;
 296     case KSBA_OCSP_RSPSTATUS_TRYLATER:     t = "try later"; break;
 297     case KSBA_OCSP_RSPSTATUS_SIGREQUIRED:  t = "must sign request"; break;
 298     case KSBA_OCSP_RSPSTATUS_UNAUTHORIZED: t = "unauthorized"; break;
 299     case KSBA_OCSP_RSPSTATUS_REPLAYED:     t = "replay detected"; break;
 300     case KSBA_OCSP_RSPSTATUS_OTHER:        t = "other (unknown)"; break;
 301     case KSBA_OCSP_RSPSTATUS_NONE:         t = "no status"; break;
 302     default:                               t = "[unknown status]"; break;
 303     }
 304   if (response_status == KSBA_OCSP_RSPSTATUS_SUCCESS)
 305     {
 306       int hash_algo;
 307
 308       if (opt.verbose)
 309         log_info (_("OCSP responder at '%s' status: %s\n"), url, t);
 310
 311       /* Get the signature value now because we can call this function
 312        * only once.  */
 313       *r_sigval = ksba_ocsp_get_sig_val (ocsp, r_produced_at);
 314
 315       hash_algo = hash_algo_from_sigval (*r_sigval);
 316       if (!hash_algo)
 317         {
 318           if (opt.verbose)
 319             log_info ("ocsp: using SHA-256 as fallback hash algo.\n");
 320           hash_algo = GCRY_MD_SHA256;
 321         }
 322       err = gcry_md_open (r_md, hash_algo, 0);
 323       if (err)
 324         {
 325           log_error (_("failed to establish a hashing context for OCSP: %s\n"),
 326                      gpg_strerror (err));
 327           goto leave;
 328         }
 329       if (DBG_HASHING)
 330         gcry_md_debug (*r_md, "ocsp");
 331
 332       err = ksba_ocsp_hash_response (ocsp, response, responselen,
 333                                      HASH_FNC, *r_md);
 334       if (err)
 335         log_error (_("hashing the OCSP response for '%s' failed: %s\n"),
 336                    url, gpg_strerror (err));
 337     }
 338   else
 339     {
 340       log_error (_("OCSP responder at '%s' status: %s\n"), url, t);
 341       err = gpg_error (GPG_ERR_GENERAL);
 342     }
 343
 344  leave:
 345   xfree (response);
 346   xfree (free_this);
 347   if (err)
 348     {
 349       xfree (*r_sigval);
 350       *r_sigval = NULL;
 351       *r_produced_at = 0;
 352       gcry_md_close (*r_md);
 353       *r_md = NULL;
 354     }
 355   return err;
 356 }
 357
 358
 359 /* Validate that CERT is indeed valid to sign an OCSP response. If
 360    SIGNER_FPR_LIST is not NULL we simply check that CERT matches one
 361    of the fingerprints in this list. */
 362 static gpg_error_t
 363 validate_responder_cert (ctrl_t ctrl, ksba_cert_t cert,
 364                          fingerprint_list_t signer_fpr_list)
 365 {
 366   gpg_error_t err;
 367   char *fpr;
 368
 369   if (signer_fpr_list)
 370     {
 371       fpr = get_fingerprint_hexstring (cert);
 372       for (; signer_fpr_list && strcmp (signer_fpr_list->hexfpr, fpr);
 373            signer_fpr_list = signer_fpr_list->next)
 374         ;
 375       if (signer_fpr_list)
 376         err = 0;
 377       else
 378         {
 379           log_error (_("not signed by a default OCSP signer's certificate"));
 380           err = gpg_error (GPG_ERR_BAD_CA_CERT);
 381         }
 382       xfree (fpr);
 383     }
 384   else
 385     {
 386       /* We avoid duplicating the entire certificate validation code
 387          from gpgsm here.  Because we have no way calling back to the
 388          client and letting it compute the validity, we use the ugly
 389          hack of telling the client that the response will only be
 390          valid if the certificate given in this status message is
 391          valid.
 392
 393          Note, that in theory we could simply ask the client via an
 394          inquire to validate a certificate but this might involve
 395          calling DirMngr again recursively - we can't do that as of now
 396          (neither DirMngr nor gpgsm have the ability for concurrent
 397          access to DirMngr.   */
 398
 399       /* FIXME: We should cache this certificate locally, so that the next
 400          call to dirmngr won't need to look it up - if this works at
 401          all. */
 402       fpr = get_fingerprint_hexstring (cert);
 403       dirmngr_status (ctrl, "ONLY_VALID_IF_CERT_VALID", fpr, NULL);
 404       xfree (fpr);
 405       err = 0;
 406     }
 407
 408   return err;
 409 }
 410
 411
 412 /* Helper for check_signature.  MD is the finalized hash context.  */
 413 static gpg_error_t
 414 check_signature_core (ctrl_t ctrl, ksba_cert_t cert, gcry_sexp_t s_sig,
 415                       gcry_md_hd_t md, fingerprint_list_t signer_fpr_list)
 416 {
 417   gpg_error_t err;
 418   gcry_sexp_t s_pkey = NULL;
 419   gcry_sexp_t s_hash = NULL;
 420   const char *s;
 421   int mdalgo, mdlen;
 422
 423   /* Get the public key as a gcrypt s-expression.  */
 424   {
 425     ksba_sexp_t pk = ksba_cert_get_public_key (cert);
 426     if (!pk)
 427       err = gpg_error (GPG_ERR_INV_OBJ);
 428     else
 429       {
 430         err = canon_sexp_to_gcry (pk, &s_pkey);
 431         xfree (pk);
 432       }
 433     if (err)
 434       goto leave;
 435   }
 436
 437   mdalgo = gcry_md_get_algo (md);
 438   mdlen  = gcry_md_get_algo_dlen (mdalgo);
 439
 440   if (pk_algo_from_sexp (s_pkey) == GCRY_PK_ECC)
 441     {
 442       unsigned int qbits0, qbits;
 443
 444       qbits0 = gcry_pk_get_nbits (s_pkey);
 445       qbits = qbits0 == 521? 512 : qbits0;
 446
 447       if ((qbits%8))
 448         {
 449           log_error ("ECDSA requires the hash length to be a"
 450                      " multiple of 8 bits\n");
 451           err = gpg_error (GPG_ERR_INTERNAL);
 452           goto leave;
 453         }
 454
 455       /* Don't allow any Q smaller than 160 bits.  */
 456       if (qbits < 160)
 457         {
 458           log_error (_("%s key uses an unsafe (%u bit) hash\n"),
 459                      "ECDSA", qbits0);
 460           err = gpg_error (GPG_ERR_INTERNAL);
 461           goto leave;
 462         }
 463
 464       /* Check if we're too short.  */
 465       if (mdlen < qbits/8)
 466         {
 467           log_error (_("a %u bit hash is not valid for a %u bit %s key\n"),
 468                      (unsigned int)mdlen*8,
 469                      qbits0,
 470                      "ECDSA");
 471           if (mdlen < 20)
 472             {
 473               err = gpg_error (GPG_ERR_INTERNAL);
 474               goto leave;
 475             }
 476         }
 477
 478       /* Truncate.  */
 479       if (mdlen > qbits/8)
 480         mdlen = qbits/8;
 481
 482       err = gcry_sexp_build (&s_hash, NULL, "(data(flags raw)(value %b))",
 483                              (int)mdlen, gcry_md_read (md, mdalgo));
 484     }
 485   else if (mdalgo && (s = gcry_md_algo_name (mdalgo)) && strlen (s) < 16)
 486     {
 487       /* Assume RSA */
 488       char hashalgostr[16+1];
 489       int i;
 490
 491       for (i=0; s[i]; i++)
 492         hashalgostr[i] = ascii_tolower (s[i]);
 493       hashalgostr[i] = 0;
 494       err = gcry_sexp_build (&s_hash, NULL, "(data(flags pkcs1)(hash %s %b))",
 495                              hashalgostr,
 496                              (int)mdlen,
 497                              gcry_md_read (md, mdalgo));
 498     }
 499   else
 500     err = gpg_error (GPG_ERR_DIGEST_ALGO);
 501   if (err)
 502     {
 503       log_error (_("creating S-expression failed: %s\n"), gcry_strerror (err));
 504       goto leave;
 505     }
 506
 507   if (DBG_CRYPTO)
 508     {
 509       gcry_log_debugsxp ("sig ", s_sig);
 510       gcry_log_debugsxp ("hash", s_hash);
 511     }
 512
 513   err = gcry_pk_verify (s_sig, s_hash, s_pkey);
 514   if (err)
 515     goto leave;
 516
 517   err = validate_responder_cert (ctrl, cert, signer_fpr_list);
 518
 519  leave:
 520   gcry_sexp_release (s_hash);
 521   gcry_sexp_release (s_pkey);
 522   return err;
 523 }
 524
 525
 526 /* Check the signature of an OCSP response.  OCSP is the context,
 527    S_SIG the signature value and MD the handle of the hash we used for
 528    the response.  This function automagically finds the correct public
 529    key.  If SIGNER_FPR_LIST is not NULL, the default OCSP reponder has been
 530    used and thus the certificate is one of those identified by
 531    the fingerprints. */
 532 static gpg_error_t
 533 check_signature (ctrl_t ctrl,
 534                  ksba_ocsp_t ocsp, gcry_sexp_t s_sig, gcry_md_hd_t md,
 535                  fingerprint_list_t signer_fpr_list)
 536 {
 537   gpg_error_t err;
 538   int cert_idx;
 539   ksba_cert_t cert;
 540
 541   /* Create a suitable S-expression with the hash value of our response. */
 542   gcry_md_final (md);
 543
 544   /* Get rid of old OCSP specific certificate references. */
 545   release_ctrl_ocsp_certs (ctrl);
 546
 547   if (signer_fpr_list && !signer_fpr_list->next)
 548     {
 549       /* There is exactly one signer fingerprint given. Thus we use
 550          the default OCSP responder's certificate and instantly know
 551          the certificate to use.  */
 552       cert = get_cert_byhexfpr (signer_fpr_list->hexfpr);
 553       if (!cert)
 554         cert = get_cert_local (ctrl, signer_fpr_list->hexfpr);
 555       if (cert)
 556         {
 557           err = check_signature_core (ctrl, cert, s_sig, md,
 558                                       signer_fpr_list);
 559           ksba_cert_release (cert);
 560           cert = NULL;
 561           if (!err)
 562             {
 563               return 0; /* Successfully verified the signature. */
 564             }
 565         }
 566     }
 567   else
 568     {
 569       char *name;
 570       ksba_sexp_t keyid;
 571
 572       /* Put all certificates included in the response into the cache
 573          and setup a list of those certificate which will later be
 574          preferred used when locating certificates.  */
 575       for (cert_idx=0; (cert = ksba_ocsp_get_cert (ocsp, cert_idx));
 576            cert_idx++)
 577         {
 578           cert_ref_t cref;
 579
 580           /* dump_cert ("from ocsp response", cert); */
 581           cref = xtrymalloc (sizeof *cref);
 582           if (!cref)
 583             {
 584               err = gpg_error_from_syserror ();
 585               log_error (_("allocating list item failed: %s\n"),
 586                          gpg_strerror (err));
 587             }
 588           else if (!cache_cert_silent (cert, &cref->fpr))
 589             {
 590               cref->next = ctrl->ocsp_certs;
 591               ctrl->ocsp_certs = cref;
 592             }
 593           else
 594             xfree (cref);
 595         }
 596
 597       /* Get the certificate by means of the responder ID. */
 598       err = ksba_ocsp_get_responder_id (ocsp, &name, &keyid);
 599       if (err)
 600         {
 601           log_error (_("error getting responder ID: %s\n"),
 602                      gcry_strerror (err));
 603           return err;
 604         }
 605       cert = find_cert_bysubject (ctrl, name, keyid);
 606       if (!cert)
 607         {
 608           log_error ("responder certificate ");
 609           if (name)
 610             log_printf ("'/%s' ", name);
 611           if (keyid)
 612             {
 613               log_printf ("{");
 614               dump_serial (keyid);
 615               log_printf ("} ");
 616             }
 617           log_printf ("not found\n");
 618         }
 619
 620       if (cert)
 621         {
 622           err = check_signature_core (ctrl, cert, s_sig, md, signer_fpr_list);
 623           ksba_cert_release (cert);
 624           if (!err)
 625             {
 626               ksba_free (name);
 627               ksba_free (keyid);
 628               return 0; /* Successfully verified the signature. */
 629             }
 630           log_error ("responder certificate ");
 631           if (name)
 632             log_printf ("'/%s' ", name);
 633           if (keyid)
 634             {
 635               log_printf ("{");
 636               dump_serial (keyid);
 637               log_printf ("} ");
 638             }
 639           log_printf ("did not verify: %s\n", gpg_strerror (err));
 640         }
 641       ksba_free (name);
 642       ksba_free (keyid);
 643     }
 644
 645   log_error (_("no suitable certificate found to verify the OCSP response\n"));
 646   return gpg_error (GPG_ERR_NO_PUBKEY);
 647 }
 648
 649
 650 /* Check whether the certificate either given by fingerprint CERT_FPR
 651    or directly through the CERT object is valid by running an OCSP
 652    transaction.  With FORCE_DEFAULT_RESPONDER set only the configured
 653    default responder is used.  If R_REVOKED_AT or R_REASON are not
 654    NULL and the certificat has been revoked the revocation time and
 655    the reasons are stored there. */
 656 gpg_error_t
 657 ocsp_isvalid (ctrl_t ctrl, ksba_cert_t cert, const char *cert_fpr,
 658               int force_default_responder, ksba_isotime_t r_revoked_at,
 659               const char **r_reason)
 660 {
 661   gpg_error_t err;
 662   ksba_ocsp_t ocsp = NULL;
 663   ksba_cert_t issuer_cert = NULL;
 664   ksba_sexp_t sigval = NULL;
 665   gcry_sexp_t s_sig = NULL;
 666   ksba_isotime_t current_time;
 667   ksba_isotime_t this_update, next_update, revocation_time, produced_at;
 668   ksba_isotime_t tmp_time;
 669   ksba_status_t status;
 670   ksba_crl_reason_t reason;
 671   char *url_buffer = NULL;
 672   const char *url;
 673   gcry_md_hd_t md = NULL;
 674   int i, idx;
 675   char *oid;
 676   ksba_name_t name;
 677   fingerprint_list_t default_signer = NULL;
 678   const char *sreason;
 679
 680   if (r_revoked_at)
 681     *r_revoked_at = 0;
 682   if (r_reason)
 683     *r_reason = NULL;
 684
 685   /* Get the certificate.  */
 686   if (cert)
 687     {
 688       ksba_cert_ref (cert);
 689
 690       err = find_issuing_cert (ctrl, cert, &issuer_cert);
 691       if (err)
 692         {
 693           log_error (_("issuer certificate not found: %s\n"),
 694                      gpg_strerror (err));
 695           goto leave;
 696         }
 697     }
 698   else
 699     {
 700       cert = get_cert_local (ctrl, cert_fpr);
 701       if (!cert)
 702         {
 703           log_error (_("caller did not return the target certificate\n"));
 704           err = gpg_error (GPG_ERR_GENERAL);
 705           goto leave;
 706         }
 707       issuer_cert = get_issuing_cert_local (ctrl, NULL);
 708       if (!issuer_cert)
 709         {
 710           log_error (_("caller did not return the issuing certificate\n"));
 711           err = gpg_error (GPG_ERR_GENERAL);
 712           goto leave;
 713         }
 714     }
 715
 716   /* Create an OCSP instance.  */
 717   err = ksba_ocsp_new (&ocsp);
 718   if (err)
 719     {
 720       log_error (_("failed to allocate OCSP context: %s\n"),
 721                  gpg_strerror (err));
 722       goto leave;
 723     }
 724
 725   /* Figure out the OCSP responder to use.
 726      1. Try to get the reponder from the certificate.
 727         We do only take http and https style URIs into account.
 728      2. If this fails use the default responder, if any.
 729    */
 730   url = NULL;
 731   for (idx=0; !url && !opt.ignore_ocsp_service_url && !force_default_responder
 732          && !(err=ksba_cert_get_authority_info_access (cert, idx,
 733                                                        &oid, &name)); idx++)
 734     {
 735       if ( !strcmp (oid, oidstr_ocsp) )
 736         {
 737           for (i=0; !url && ksba_name_enum (name, i); i++)
 738             {
 739               char *p = ksba_name_get_uri (name, i);
 740               if (p && (!ascii_strncasecmp (p, "http:", 5)
 741                         || !ascii_strncasecmp (p, "https:", 6)))
 742                 url = url_buffer = p;
 743               else
 744                 xfree (p);
 745             }
 746         }
 747       ksba_name_release (name);
 748       ksba_free (oid);
 749     }
 750   if (err && gpg_err_code (err) != GPG_ERR_EOF)
 751     {
 752       log_error (_("can't get authorityInfoAccess: %s\n"), gpg_strerror (err));
 753       goto leave;
 754     }
 755   if (!url)
 756     {
 757       if (!opt.ocsp_responder || !*opt.ocsp_responder)
 758         {
 759           log_info (_("no default OCSP responder defined\n"));
 760           err = gpg_error (GPG_ERR_CONFIGURATION);
 761           goto leave;
 762         }
 763       if (!opt.ocsp_signer)
 764         {
 765           log_info (_("no default OCSP signer defined\n"));
 766           err = gpg_error (GPG_ERR_CONFIGURATION);
 767           goto leave;
 768         }
 769       url = opt.ocsp_responder;
 770       default_signer = opt.ocsp_signer;
 771       if (opt.verbose)
 772         log_info (_("using default OCSP responder '%s'\n"), url);
 773     }
 774   else
 775     {
 776       if (opt.verbose)
 777         log_info (_("using OCSP responder '%s'\n"), url);
 778     }
 779
 780   /* Ask the OCSP responder. */
 781   err = do_ocsp_request (ctrl, ocsp, url, cert, issuer_cert,
 782                          &sigval, produced_at, &md);
 783   if (err)
 784     goto leave;
 785
 786   /* It is sometimes useful to know the responder ID. */
 787   if (opt.verbose)
 788     {
 789       char *resp_name;
 790       ksba_sexp_t resp_keyid;
 791
 792       err = ksba_ocsp_get_responder_id (ocsp, &resp_name, &resp_keyid);
 793       if (err)
 794         log_info (_("error getting responder ID: %s\n"), gpg_strerror (err));
 795       else
 796         {
 797           log_info ("responder id: ");
 798           if (resp_name)
 799             log_printf ("'/%s' ", resp_name);
 800           if (resp_keyid)
 801             {
 802               log_printf ("{");
 803               dump_serial (resp_keyid);
 804               log_printf ("} ");
 805             }
 806           log_printf ("\n");
 807         }
 808       ksba_free (resp_name);
 809       ksba_free (resp_keyid);
 810       err = 0;
 811     }
 812
 813   /* We got a useful answer, check that the answer has a valid signature. */
 814   if (!sigval || !*produced_at || !md)
 815     {
 816       err = gpg_error (GPG_ERR_INV_OBJ);
 817       goto leave;
 818     }
 819   if ( (err = canon_sexp_to_gcry (sigval, &s_sig)) )
 820     goto leave;
 821   xfree (sigval);
 822   sigval = NULL;
 823   err = check_signature (ctrl, ocsp, s_sig, md, default_signer);
 824   if (err)
 825     goto leave;
 826
 827   /* We only support one certificate per request.  Check that the
 828      answer matches the right certificate. */
 829   err = ksba_ocsp_get_status (ocsp, cert,
 830                               &status, this_update, next_update,
 831                               revocation_time, &reason);
 832   if (err)
 833     {
 834       log_error (_("error getting OCSP status for target certificate: %s\n"),
 835                  gpg_strerror (err));
 836       goto leave;
 837     }
 838
 839   /* In case the certificate has been revoked, we better invalidate
 840      our cached validation status. */
 841   if (status == KSBA_STATUS_REVOKED)
 842     {
 843       time_t validated_at = 0; /* That is: No cached validation available. */
 844       err = ksba_cert_set_user_data (cert, "validated_at",
 845                                      &validated_at, sizeof (validated_at));
 846       if (err)
 847         {
 848           log_error ("set_user_data(validated_at) failed: %s\n",
 849                      gpg_strerror (err));
 850           err = 0; /* The certificate is anyway revoked, and that is a
 851                       more important message than the failure of our
 852                       cache. */
 853         }
 854
 855       switch (reason)
 856         {
 857         case KSBA_CRLREASON_UNSPECIFIED:
 858           sreason = "unspecified"; break;
 859         case KSBA_CRLREASON_KEY_COMPROMISE:
 860           sreason = "key compromise"; break;
 861         case KSBA_CRLREASON_CA_COMPROMISE:
 862           sreason = "CA compromise"; break;
 863         case KSBA_CRLREASON_AFFILIATION_CHANGED:
 864           sreason = "affiliation changed"; break;
 865         case KSBA_CRLREASON_SUPERSEDED:
 866           sreason = "superseded"; break;
 867         case KSBA_CRLREASON_CESSATION_OF_OPERATION:
 868           sreason = "cessation of operation"; break;
 869         case KSBA_CRLREASON_CERTIFICATE_HOLD:
 870           sreason = "certificate on hold"; break;
 871         case KSBA_CRLREASON_REMOVE_FROM_CRL:
 872           sreason = "removed from CRL"; break;
 873         case KSBA_CRLREASON_PRIVILEGE_WITHDRAWN:
 874           sreason = "privilege withdrawn"; break;
 875         case KSBA_CRLREASON_AA_COMPROMISE:
 876           sreason = "AA compromise"; break;
 877         case KSBA_CRLREASON_OTHER:
 878           sreason = "other"; break;
 879         default: sreason = "?"; break;
 880         }
 881     }
 882   else
 883     sreason = "";
 884
 885   if (opt.verbose)
 886     {
 887       log_info (_("certificate status is: %s  (this=%s  next=%s)\n"),
 888                 status == KSBA_STATUS_GOOD? _("good"):
 889                 status == KSBA_STATUS_REVOKED? _("revoked"):
 890                 status == KSBA_STATUS_UNKNOWN? _("unknown"):
 891                 status == KSBA_STATUS_NONE? _("none"): "?",
 892                 this_update, next_update);
 893       if (status == KSBA_STATUS_REVOKED)
 894         log_info (_("certificate has been revoked at: %s due to: %s\n"),
 895                   revocation_time, sreason);
 896
 897     }
 898
 899
 900   if (status == KSBA_STATUS_REVOKED)
 901     {
 902       err = gpg_error (GPG_ERR_CERT_REVOKED);
 903       if (r_revoked_at)
 904         gnupg_copy_time (r_revoked_at, revocation_time);
 905       if (r_reason)
 906         *r_reason = sreason;
 907     }
 908   else if (status == KSBA_STATUS_UNKNOWN)
 909     err = gpg_error (GPG_ERR_NO_DATA);
 910   else if (status != KSBA_STATUS_GOOD)
 911     err = gpg_error (GPG_ERR_GENERAL);
 912
 913   /* Allow for some clock skew. */
 914   gnupg_get_isotime (current_time);
 915   add_seconds_to_isotime (current_time, opt.ocsp_max_clock_skew);
 916
 917   if (strcmp (this_update, current_time) > 0 )
 918     {
 919       log_error (_("OCSP responder returned a status in the future\n"));
 920       log_info ("used now: %s  this_update: %s\n", current_time, this_update);
 921       if (!err)
 922         err = gpg_error (GPG_ERR_TIME_CONFLICT);
 923     }
 924
 925   /* Check that THIS_UPDATE is not too far back in the past. */
 926   gnupg_copy_time (tmp_time, this_update);
 927   add_seconds_to_isotime (tmp_time,
 928                           opt.ocsp_max_period+opt.ocsp_max_clock_skew);
 929   if (!*tmp_time || strcmp (tmp_time, current_time) < 0 )
 930     {
 931       log_error (_("OCSP responder returned a non-current status\n"));
 932       log_info ("used now: %s  this_update: %s\n",
 933                 current_time, this_update);
 934       if (!err)
 935         err = gpg_error (GPG_ERR_TIME_CONFLICT);
 936     }
 937
 938   /* Check that we are not beyond NEXT_UPDATE  (plus some extra time). */
 939   if (*next_update)
 940     {
 941       gnupg_copy_time (tmp_time, next_update);
 942       add_seconds_to_isotime (tmp_time,
 943                               opt.ocsp_current_period+opt.ocsp_max_clock_skew);
 944       if (!*tmp_time && strcmp (tmp_time, current_time) < 0 )
 945         {
 946           log_error (_("OCSP responder returned an too old status\n"));
 947           log_info ("used now: %s  next_update: %s\n",
 948                     current_time, next_update);
 949           if (!err)
 950             err = gpg_error (GPG_ERR_TIME_CONFLICT);
 951         }
 952     }
 953
 954
 955  leave:
 956   gcry_md_close (md);
 957   gcry_sexp_release (s_sig);
 958   xfree (sigval);
 959   ksba_cert_release (issuer_cert);
 960   ksba_cert_release (cert);
 961   ksba_ocsp_release (ocsp);
 962   xfree (url_buffer);
 963   return err;
 964 }
 965
 966
 967 /* Release the list of OCSP certificates hold in the CTRL object. */
 968 void
 969 release_ctrl_ocsp_certs (ctrl_t ctrl)
 970 {
 971   while (ctrl->ocsp_certs)
 972     {
 973       cert_ref_t tmp = ctrl->ocsp_certs->next;
 974       xfree (ctrl->ocsp_certs);
 975       ctrl->ocsp_certs = tmp;
 976     }
 977 }