doc: Fix distchek for generated eps file
[gnupg.git] / 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       log_error (_("OCSP request not possible due to Tor mode\n"));
149       return gpg_error (GPG_ERR_NOT_SUPPORTED);
150     }
151
152   if (opt.disable_http)
153     {
154       log_error (_("OCSP request not possible due to disabled HTTP\n"));
155       return gpg_error (GPG_ERR_NOT_SUPPORTED);
156     }
157
158   err = ksba_ocsp_add_target (ocsp, cert, issuer_cert);
159   if (err)
160     {
161       log_error (_("error setting OCSP target: %s\n"), gpg_strerror (err));
162       return err;
163     }
164
165   {
166     size_t n;
167     unsigned char nonce[32];
168
169     n = ksba_ocsp_set_nonce (ocsp, NULL, 0);
170     if (n > sizeof nonce)
171       n = sizeof nonce;
172     gcry_create_nonce (nonce, n);
173     ksba_ocsp_set_nonce (ocsp, nonce, n);
174   }
175
176   err = ksba_ocsp_build_request (ocsp, &request, &requestlen);
177   if (err)
178     {
179       log_error (_("error building OCSP request: %s\n"), gpg_strerror (err));
180       return err;
181     }
182
183  once_more:
184   err = http_open (ctrl, &http, HTTP_REQ_POST, url, NULL, NULL,
185                    ((opt.honor_http_proxy? HTTP_FLAG_TRY_PROXY:0)
186                     | (dirmngr_use_tor ()? HTTP_FLAG_FORCE_TOR:0)
187                     | (opt.disable_ipv4? HTTP_FLAG_IGNORE_IPv4 : 0)
188                     | (opt.disable_ipv6? HTTP_FLAG_IGNORE_IPv6 : 0)),
189                    ctrl->http_proxy, NULL, NULL, NULL);
190   if (err)
191     {
192       log_error (_("error connecting to '%s': %s\n"), url, gpg_strerror (err));
193       xfree (free_this);
194       return err;
195     }
196
197   es_fprintf (http_get_write_ptr (http),
198               "Content-Type: application/ocsp-request\r\n"
199               "Content-Length: %lu\r\n",
200               (unsigned long)requestlen );
201   http_start_data (http);
202   if (es_fwrite (request, requestlen, 1, http_get_write_ptr (http)) != 1)
203     {
204       err = gpg_error_from_errno (errno);
205       log_error ("error sending request to '%s': %s\n", url, strerror (errno));
206       http_close (http, 0);
207       xfree (request);
208       xfree (free_this);
209       return err;
210     }
211   xfree (request);
212   request = NULL;
213
214   err = http_wait_response (http);
215   if (err || http_get_status_code (http) != 200)
216     {
217       if (err)
218         log_error (_("error reading HTTP response for '%s': %s\n"),
219                    url, gpg_strerror (err));
220       else
221         {
222           switch (http_get_status_code (http))
223             {
224             case 301:
225             case 302:
226               {
227                 const char *s = http_get_header (http, "Location");
228
229                 log_info (_("URL '%s' redirected to '%s' (%u)\n"),
230                           url, s?s:"[none]", http_get_status_code (http));
231                 if (s && *s && redirects_left-- )
232                   {
233                     xfree (free_this); url = NULL;
234                     free_this = xtrystrdup (s);
235                     if (!free_this)
236                       err = gpg_error_from_errno (errno);
237                     else
238                       {
239                         url = free_this;
240                         http_close (http, 0);
241                         goto once_more;
242                       }
243                   }
244                 else
245                   err = gpg_error (GPG_ERR_NO_DATA);
246                 log_error (_("too many redirections\n"));
247               }
248               break;
249
250             case 413:  /* Payload too large */
251               err = gpg_error (GPG_ERR_TOO_LARGE);
252               break;
253
254             default:
255               log_error (_("error accessing '%s': http status %u\n"),
256                          url, http_get_status_code (http));
257               err = gpg_error (GPG_ERR_NO_DATA);
258               break;
259             }
260         }
261       http_close (http, 0);
262       xfree (free_this);
263       return err;
264     }
265
266   err = read_response (http_get_read_ptr (http), &response, &responselen);
267   http_close (http, 0);
268   if (err)
269     {
270       log_error (_("error reading HTTP response for '%s': %s\n"),
271                  url, gpg_strerror (err));
272       xfree (free_this);
273       return err;
274     }
275   /* log_printhex (response, responselen, "ocsp response"); */
276
277   err = ksba_ocsp_parse_response (ocsp, response, responselen,
278                                   &response_status);
279   if (err)
280     {
281       log_error (_("error parsing OCSP response for '%s': %s\n"),
282                  url, gpg_strerror (err));
283       xfree (response);
284       xfree (free_this);
285       return err;
286     }
287
288   switch (response_status)
289     {
290     case KSBA_OCSP_RSPSTATUS_SUCCESS:      t = "success"; break;
291     case KSBA_OCSP_RSPSTATUS_MALFORMED:    t = "malformed"; break;
292     case KSBA_OCSP_RSPSTATUS_INTERNAL:     t = "internal error"; break;
293     case KSBA_OCSP_RSPSTATUS_TRYLATER:     t = "try later"; break;
294     case KSBA_OCSP_RSPSTATUS_SIGREQUIRED:  t = "must sign request"; break;
295     case KSBA_OCSP_RSPSTATUS_UNAUTHORIZED: t = "unauthorized"; break;
296     case KSBA_OCSP_RSPSTATUS_REPLAYED:     t = "replay detected"; break;
297     case KSBA_OCSP_RSPSTATUS_OTHER:        t = "other (unknown)"; break;
298     case KSBA_OCSP_RSPSTATUS_NONE:         t = "no status"; break;
299     default:                               t = "[unknown status]"; break;
300     }
301   if (response_status == KSBA_OCSP_RSPSTATUS_SUCCESS)
302     {
303       int hash_algo;
304
305       if (opt.verbose)
306         log_info (_("OCSP responder at '%s' status: %s\n"), url, t);
307
308       /* Get the signature value now because we can all this fucntion
309        * only once.  */
310       *r_sigval = ksba_ocsp_get_sig_val (ocsp, r_produced_at);
311
312       hash_algo = hash_algo_from_sigval (*r_sigval);
313       if (!hash_algo)
314         {
315           if (opt.verbose)
316             log_info ("ocsp: using SHA-256 as fallback hash algo.\n");
317           hash_algo = GCRY_MD_SHA256;
318         }
319       err = gcry_md_open (r_md, hash_algo, 0);
320       if (err)
321         {
322           log_error (_("failed to establish a hashing context for OCSP: %s\n"),
323                      gpg_strerror (err));
324           goto leave;
325         }
326       if (DBG_HASHING)
327         gcry_md_debug (*r_md, "ocsp");
328
329       err = ksba_ocsp_hash_response (ocsp, response, responselen,
330                                      HASH_FNC, *r_md);
331       if (err)
332         log_error (_("hashing the OCSP response for '%s' failed: %s\n"),
333                    url, gpg_strerror (err));
334     }
335   else
336     {
337       log_error (_("OCSP responder at '%s' status: %s\n"), url, t);
338       err = gpg_error (GPG_ERR_GENERAL);
339     }
340
341  leave:
342   xfree (response);
343   xfree (free_this);
344   if (err)
345     {
346       xfree (*r_sigval);
347       *r_sigval = NULL;
348       *r_produced_at = 0;
349       gcry_md_close (*r_md);
350       *r_md = NULL;
351     }
352   return err;
353 }
354
355
356 /* Validate that CERT is indeed valid to sign an OCSP response. If
357    SIGNER_FPR_LIST is not NULL we simply check that CERT matches one
358    of the fingerprints in this list. */
359 static gpg_error_t
360 validate_responder_cert (ctrl_t ctrl, ksba_cert_t cert,
361                          fingerprint_list_t signer_fpr_list)
362 {
363   gpg_error_t err;
364   char *fpr;
365
366   if (signer_fpr_list)
367     {
368       fpr = get_fingerprint_hexstring (cert);
369       for (; signer_fpr_list && strcmp (signer_fpr_list->hexfpr, fpr);
370            signer_fpr_list = signer_fpr_list->next)
371         ;
372       if (signer_fpr_list)
373         err = 0;
374       else
375         {
376           log_error (_("not signed by a default OCSP signer's certificate"));
377           err = gpg_error (GPG_ERR_BAD_CA_CERT);
378         }
379       xfree (fpr);
380     }
381   else
382     {
383       /* We avoid duplicating the entire certificate validation code
384          from gpgsm here.  Because we have no way calling back to the
385          client and letting it compute the validity, we use the ugly
386          hack of telling the client that the response will only be
387          valid if the certificate given in this status message is
388          valid.
389
390          Note, that in theory we could simply ask the client via an
391          inquire to validate a certificate but this might involve
392          calling DirMngr again recursively - we can't do that as of now
393          (neither DirMngr nor gpgsm have the ability for concurrent
394          access to DirMngr.   */
395
396       /* FIXME: We should cache this certificate locally, so that the next
397          call to dirmngr won't need to look it up - if this works at
398          all. */
399       fpr = get_fingerprint_hexstring (cert);
400       dirmngr_status (ctrl, "ONLY_VALID_IF_CERT_VALID", fpr, NULL);
401       xfree (fpr);
402       err = 0;
403     }
404
405   return err;
406 }
407
408
409 /* Helper for check_signature. */
410 static int
411 check_signature_core (ctrl_t ctrl, ksba_cert_t cert, gcry_sexp_t s_sig,
412                       gcry_sexp_t s_hash, fingerprint_list_t signer_fpr_list)
413 {
414   gpg_error_t err;
415   ksba_sexp_t pubkey;
416   gcry_sexp_t s_pkey = NULL;
417
418   pubkey = ksba_cert_get_public_key (cert);
419   if (!pubkey)
420     err = gpg_error (GPG_ERR_INV_OBJ);
421   else
422     err = canon_sexp_to_gcry (pubkey, &s_pkey);
423   xfree (pubkey);
424   if (!err)
425     err = gcry_pk_verify (s_sig, s_hash, s_pkey);
426   if (!err)
427     err = validate_responder_cert (ctrl, cert, signer_fpr_list);
428   if (!err)
429     {
430       gcry_sexp_release (s_pkey);
431       return 0; /* Successfully verified the signature. */
432     }
433
434   /* We simply ignore all errors. */
435   gcry_sexp_release (s_pkey);
436   return err;
437 }
438
439
440 /* Check the signature of an OCSP response.  OCSP is the context,
441    S_SIG the signature value and MD the handle of the hash we used for
442    the response.  This function automagically finds the correct public
443    key.  If SIGNER_FPR_LIST is not NULL, the default OCSP reponder has been
444    used and thus the certificate is one of those identified by
445    the fingerprints. */
446 static gpg_error_t
447 check_signature (ctrl_t ctrl,
448                  ksba_ocsp_t ocsp, gcry_sexp_t s_sig, gcry_md_hd_t md,
449                  fingerprint_list_t signer_fpr_list)
450 {
451   gpg_error_t err;
452   int algo, cert_idx;
453   gcry_sexp_t s_hash;
454   ksba_cert_t cert;
455   const char *s;
456
457   /* Create a suitable S-expression with the hash value of our response. */
458   gcry_md_final (md);
459   algo = gcry_md_get_algo (md);
460   s = gcry_md_algo_name (algo);
461   if (algo && s && strlen (s) < 16)
462     {
463       char hashalgostr[16+1];
464       int i;
465
466       for (i=0; s[i]; i++)
467         hashalgostr[i] = ascii_tolower (s[i]);
468       hashalgostr[i] = 0;
469       err = gcry_sexp_build (&s_hash, NULL, "(data(flags pkcs1)(hash %s %b))",
470                              hashalgostr,
471                              (int)gcry_md_get_algo_dlen (algo),
472                              gcry_md_read (md, algo));
473     }
474   else
475     err = gpg_error (GPG_ERR_DIGEST_ALGO);
476   if (err)
477     {
478       log_error (_("creating S-expression failed: %s\n"), gcry_strerror (err));
479       return err;
480     }
481
482   /* Get rid of old OCSP specific certificate references. */
483   release_ctrl_ocsp_certs (ctrl);
484
485   if (signer_fpr_list && !signer_fpr_list->next)
486     {
487       /* There is exactly one signer fingerprint given. Thus we use
488          the default OCSP responder's certificate and instantly know
489          the certificate to use.  */
490       cert = get_cert_byhexfpr (signer_fpr_list->hexfpr);
491       if (!cert)
492         cert = get_cert_local (ctrl, signer_fpr_list->hexfpr);
493       if (cert)
494         {
495           err = check_signature_core (ctrl, cert, s_sig, s_hash,
496                                       signer_fpr_list);
497           ksba_cert_release (cert);
498           cert = NULL;
499           if (!err)
500             {
501               gcry_sexp_release (s_hash);
502               return 0; /* Successfully verified the signature. */
503             }
504         }
505     }
506   else
507     {
508       char *name;
509       ksba_sexp_t keyid;
510
511       /* Put all certificates included in the response into the cache
512          and setup a list of those certificate which will later be
513          preferred used when locating certificates.  */
514       for (cert_idx=0; (cert = ksba_ocsp_get_cert (ocsp, cert_idx));
515            cert_idx++)
516         {
517           cert_ref_t cref;
518
519           /* dump_cert ("from ocsp response", cert); */
520           cref = xtrymalloc (sizeof *cref);
521           if (!cref)
522             log_error (_("allocating list item failed: %s\n"),
523                        gcry_strerror (err));
524           else if (!cache_cert_silent (cert, &cref->fpr))
525             {
526               cref->next = ctrl->ocsp_certs;
527               ctrl->ocsp_certs = cref;
528             }
529           else
530             xfree (cref);
531         }
532
533       /* Get the certificate by means of the responder ID. */
534       err = ksba_ocsp_get_responder_id (ocsp, &name, &keyid);
535       if (err)
536         {
537           log_error (_("error getting responder ID: %s\n"),
538                      gcry_strerror (err));
539           return err;
540         }
541       cert = find_cert_bysubject (ctrl, name, keyid);
542       if (!cert)
543         {
544           log_error ("responder certificate ");
545           if (name)
546             log_printf ("'/%s' ", name);
547           if (keyid)
548             {
549               log_printf ("{");
550               dump_serial (keyid);
551               log_printf ("} ");
552             }
553           log_printf ("not found\n");
554         }
555
556       if (cert)
557         {
558           err = check_signature_core (ctrl, cert, s_sig, s_hash,
559                                       signer_fpr_list);
560           ksba_cert_release (cert);
561           if (!err)
562             {
563               ksba_free (name);
564               ksba_free (keyid);
565               gcry_sexp_release (s_hash);
566               return 0; /* Successfully verified the signature. */
567             }
568           log_error ("responder certificate ");
569           if (name)
570             log_printf ("'/%s' ", name);
571           if (keyid)
572             {
573               log_printf ("{");
574               dump_serial (keyid);
575               log_printf ("} ");
576             }
577           log_printf ("did not verify: %s\n", gpg_strerror (err));
578         }
579       ksba_free (name);
580       ksba_free (keyid);
581     }
582
583   gcry_sexp_release (s_hash);
584   log_error (_("no suitable certificate found to verify the OCSP response\n"));
585   return gpg_error (GPG_ERR_NO_PUBKEY);
586 }
587
588
589 /* Check whether the certificate either given by fingerprint CERT_FPR
590    or directly through the CERT object is valid by running an OCSP
591    transaction.  With FORCE_DEFAULT_RESPONDER set only the configured
592    default responder is used. */
593 gpg_error_t
594 ocsp_isvalid (ctrl_t ctrl, ksba_cert_t cert, const char *cert_fpr,
595               int force_default_responder)
596 {
597   gpg_error_t err;
598   ksba_ocsp_t ocsp = NULL;
599   ksba_cert_t issuer_cert = NULL;
600   ksba_sexp_t sigval = NULL;
601   gcry_sexp_t s_sig = NULL;
602   ksba_isotime_t current_time;
603   ksba_isotime_t this_update, next_update, revocation_time, produced_at;
604   ksba_isotime_t tmp_time;
605   ksba_status_t status;
606   ksba_crl_reason_t reason;
607   char *url_buffer = NULL;
608   const char *url;
609   gcry_md_hd_t md = NULL;
610   int i, idx;
611   char *oid;
612   ksba_name_t name;
613   fingerprint_list_t default_signer = NULL;
614
615   /* Get the certificate.  */
616   if (cert)
617     {
618       ksba_cert_ref (cert);
619
620       err = find_issuing_cert (ctrl, cert, &issuer_cert);
621       if (err)
622         {
623           log_error (_("issuer certificate not found: %s\n"),
624                      gpg_strerror (err));
625           goto leave;
626         }
627     }
628   else
629     {
630       cert = get_cert_local (ctrl, cert_fpr);
631       if (!cert)
632         {
633           log_error (_("caller did not return the target certificate\n"));
634           err = gpg_error (GPG_ERR_GENERAL);
635           goto leave;
636         }
637       issuer_cert = get_issuing_cert_local (ctrl, NULL);
638       if (!issuer_cert)
639         {
640           log_error (_("caller did not return the issuing certificate\n"));
641           err = gpg_error (GPG_ERR_GENERAL);
642           goto leave;
643         }
644     }
645
646   /* Create an OCSP instance.  */
647   err = ksba_ocsp_new (&ocsp);
648   if (err)
649     {
650       log_error (_("failed to allocate OCSP context: %s\n"),
651                  gpg_strerror (err));
652       goto leave;
653     }
654
655   /* Figure out the OCSP responder to use.
656      1. Try to get the reponder from the certificate.
657         We do only take http and https style URIs into account.
658      2. If this fails use the default responder, if any.
659    */
660   url = NULL;
661   for (idx=0; !url && !opt.ignore_ocsp_service_url && !force_default_responder
662          && !(err=ksba_cert_get_authority_info_access (cert, idx,
663                                                        &oid, &name)); idx++)
664     {
665       if ( !strcmp (oid, oidstr_ocsp) )
666         {
667           for (i=0; !url && ksba_name_enum (name, i); i++)
668             {
669               char *p = ksba_name_get_uri (name, i);
670               if (p && (!ascii_strncasecmp (p, "http:", 5)
671                         || !ascii_strncasecmp (p, "https:", 6)))
672                 url = url_buffer = p;
673               else
674                 xfree (p);
675             }
676         }
677       ksba_name_release (name);
678       ksba_free (oid);
679     }
680   if (err && gpg_err_code (err) != GPG_ERR_EOF)
681     {
682       log_error (_("can't get authorityInfoAccess: %s\n"), gpg_strerror (err));
683       goto leave;
684     }
685   if (!url)
686     {
687       if (!opt.ocsp_responder || !*opt.ocsp_responder)
688         {
689           log_info (_("no default OCSP responder defined\n"));
690           err = gpg_error (GPG_ERR_CONFIGURATION);
691           goto leave;
692         }
693       if (!opt.ocsp_signer)
694         {
695           log_info (_("no default OCSP signer defined\n"));
696           err = gpg_error (GPG_ERR_CONFIGURATION);
697           goto leave;
698         }
699       url = opt.ocsp_responder;
700       default_signer = opt.ocsp_signer;
701       if (opt.verbose)
702         log_info (_("using default OCSP responder '%s'\n"), url);
703     }
704   else
705     {
706       if (opt.verbose)
707         log_info (_("using OCSP responder '%s'\n"), url);
708     }
709
710   /* Ask the OCSP responder. */
711   err = do_ocsp_request (ctrl, ocsp, url, cert, issuer_cert,
712                          &sigval, produced_at, &md);
713   if (err)
714     goto leave;
715
716   /* It is sometimes useful to know the responder ID. */
717   if (opt.verbose)
718     {
719       char *resp_name;
720       ksba_sexp_t resp_keyid;
721
722       err = ksba_ocsp_get_responder_id (ocsp, &resp_name, &resp_keyid);
723       if (err)
724         log_info (_("error getting responder ID: %s\n"), gpg_strerror (err));
725       else
726         {
727           log_info ("responder id: ");
728           if (resp_name)
729             log_printf ("'/%s' ", resp_name);
730           if (resp_keyid)
731             {
732               log_printf ("{");
733               dump_serial (resp_keyid);
734               log_printf ("} ");
735             }
736           log_printf ("\n");
737         }
738       ksba_free (resp_name);
739       ksba_free (resp_keyid);
740       err = 0;
741     }
742
743   /* We got a useful answer, check that the answer has a valid signature. */
744   if (!sigval || !*produced_at || !md)
745     {
746       err = gpg_error (GPG_ERR_INV_OBJ);
747       goto leave;
748     }
749   if ( (err = canon_sexp_to_gcry (sigval, &s_sig)) )
750     goto leave;
751   xfree (sigval);
752   sigval = NULL;
753   err = check_signature (ctrl, ocsp, s_sig, md, default_signer);
754   if (err)
755     goto leave;
756
757   /* We only support one certificate per request.  Check that the
758      answer matches the right certificate. */
759   err = ksba_ocsp_get_status (ocsp, cert,
760                               &status, this_update, next_update,
761                               revocation_time, &reason);
762   if (err)
763     {
764       log_error (_("error getting OCSP status for target certificate: %s\n"),
765                  gpg_strerror (err));
766       goto leave;
767     }
768
769   /* In case the certificate has been revoked, we better invalidate
770      our cached validation status. */
771   if (status == KSBA_STATUS_REVOKED)
772     {
773       time_t validated_at = 0; /* That is: No cached validation available. */
774       err = ksba_cert_set_user_data (cert, "validated_at",
775                                      &validated_at, sizeof (validated_at));
776       if (err)
777         {
778           log_error ("set_user_data(validated_at) failed: %s\n",
779                      gpg_strerror (err));
780           err = 0; /* The certificate is anyway revoked, and that is a
781                       more important message than the failure of our
782                       cache. */
783         }
784     }
785
786
787   if (opt.verbose)
788     {
789       log_info (_("certificate status is: %s  (this=%s  next=%s)\n"),
790                 status == KSBA_STATUS_GOOD? _("good"):
791                 status == KSBA_STATUS_REVOKED? _("revoked"):
792                 status == KSBA_STATUS_UNKNOWN? _("unknown"):
793                 status == KSBA_STATUS_NONE? _("none"): "?",
794                 this_update, next_update);
795       if (status == KSBA_STATUS_REVOKED)
796         log_info (_("certificate has been revoked at: %s due to: %s\n"),
797                   revocation_time,
798                   reason == KSBA_CRLREASON_UNSPECIFIED?   "unspecified":
799                   reason == KSBA_CRLREASON_KEY_COMPROMISE? "key compromise":
800                   reason == KSBA_CRLREASON_CA_COMPROMISE?   "CA compromise":
801                   reason == KSBA_CRLREASON_AFFILIATION_CHANGED?
802                                                       "affiliation changed":
803                   reason == KSBA_CRLREASON_SUPERSEDED?   "superseded":
804                   reason == KSBA_CRLREASON_CESSATION_OF_OPERATION?
805                                                   "cessation of operation":
806                   reason == KSBA_CRLREASON_CERTIFICATE_HOLD?
807                                                   "certificate on hold":
808                   reason == KSBA_CRLREASON_REMOVE_FROM_CRL?
809                                                   "removed from CRL":
810                   reason == KSBA_CRLREASON_PRIVILEGE_WITHDRAWN?
811                                                   "privilege withdrawn":
812                   reason == KSBA_CRLREASON_AA_COMPROMISE? "AA compromise":
813                   reason == KSBA_CRLREASON_OTHER?   "other":"?");
814
815     }
816
817
818   if (status == KSBA_STATUS_REVOKED)
819     err = gpg_error (GPG_ERR_CERT_REVOKED);
820   else if (status == KSBA_STATUS_UNKNOWN)
821     err = gpg_error (GPG_ERR_NO_DATA);
822   else if (status != KSBA_STATUS_GOOD)
823     err = gpg_error (GPG_ERR_GENERAL);
824
825   /* Allow for some clock skew. */
826   gnupg_get_isotime (current_time);
827   add_seconds_to_isotime (current_time, opt.ocsp_max_clock_skew);
828
829   if (strcmp (this_update, current_time) > 0 )
830     {
831       log_error (_("OCSP responder returned a status in the future\n"));
832       log_info ("used now: %s  this_update: %s\n", current_time, this_update);
833       if (!err)
834         err = gpg_error (GPG_ERR_TIME_CONFLICT);
835     }
836
837   /* Check that THIS_UPDATE is not too far back in the past. */
838   gnupg_copy_time (tmp_time, this_update);
839   add_seconds_to_isotime (tmp_time,
840                           opt.ocsp_max_period+opt.ocsp_max_clock_skew);
841   if (!*tmp_time || strcmp (tmp_time, current_time) < 0 )
842     {
843       log_error (_("OCSP responder returned a non-current status\n"));
844       log_info ("used now: %s  this_update: %s\n",
845                 current_time, this_update);
846       if (!err)
847         err = gpg_error (GPG_ERR_TIME_CONFLICT);
848     }
849
850   /* Check that we are not beyond NEXT_UPDATE  (plus some extra time). */
851   if (*next_update)
852     {
853       gnupg_copy_time (tmp_time, next_update);
854       add_seconds_to_isotime (tmp_time,
855                               opt.ocsp_current_period+opt.ocsp_max_clock_skew);
856       if (!*tmp_time && strcmp (tmp_time, current_time) < 0 )
857         {
858           log_error (_("OCSP responder returned an too old status\n"));
859           log_info ("used now: %s  next_update: %s\n",
860                     current_time, next_update);
861           if (!err)
862             err = gpg_error (GPG_ERR_TIME_CONFLICT);
863         }
864     }
865
866
867  leave:
868   gcry_md_close (md);
869   gcry_sexp_release (s_sig);
870   xfree (sigval);
871   ksba_cert_release (issuer_cert);
872   ksba_cert_release (cert);
873   ksba_ocsp_release (ocsp);
874   xfree (url_buffer);
875   return err;
876 }
877
878
879 /* Release the list of OCSP certificates hold in the CTRL object. */
880 void
881 release_ctrl_ocsp_certs (ctrl_t ctrl)
882 {
883   while (ctrl->ocsp_certs)
884     {
885       cert_ref_t tmp = ctrl->ocsp_certs->next;
886       xfree (ctrl->ocsp_certs);
887       ctrl->ocsp_certs = tmp;
888     }
889 }