Always search missing certifcates using a running Dirmngr's cache.
[gnupg.git] / sm / certchain.c
1 /* certchain.c - certificate chain validation
2  * Copyright (C) 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2007 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h> 
27 #include <time.h>
28 #include <stdarg.h>
29 #include <assert.h>
30
31 #define JNLIB_NEED_LOG_LOGV /* We need log_logv. */
32
33 #include "gpgsm.h"
34 #include <gcrypt.h>
35 #include <ksba.h>
36
37 #include "keydb.h"
38 #include "../kbx/keybox.h" /* for KEYBOX_FLAG_* */
39 #include "i18n.h"
40 #include "tlv.h"
41
42
43 /* Object to keep track of certain root certificates. */
44 struct marktrusted_info_s
45 {
46   struct marktrusted_info_s *next;
47   unsigned char fpr[20];
48 };
49 static struct marktrusted_info_s *marktrusted_info;
50
51
52 /* While running the validation function we want to keep track of the
53    certificates in the chain.  This type is used for that.  */
54 struct chain_item_s
55 {
56   struct chain_item_s *next;
57   ksba_cert_t cert;      /* The certificate.  */
58   int is_root;           /* The certificate is the root certificate.  */
59 };
60 typedef struct chain_item_s *chain_item_t;
61
62
63 static int get_regtp_ca_info (ctrl_t ctrl, ksba_cert_t cert, int *chainlen);
64
65
66 /* This function returns true if we already asked during this session
67    whether the root certificate CERT shall be marked as trusted.  */
68 static int
69 already_asked_marktrusted (ksba_cert_t cert)
70 {
71   unsigned char fpr[20];
72   struct marktrusted_info_s *r;
73
74   gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, fpr, NULL);
75   /* No context switches in the loop! */
76   for (r=marktrusted_info; r; r= r->next)
77     if (!memcmp (r->fpr, fpr, 20))
78       return 1;
79   return 0;
80 }
81
82 /* Flag certificate CERT as already asked whether it shall be marked
83    as trusted.  */
84 static void
85 set_already_asked_marktrusted (ksba_cert_t cert)
86 {
87  unsigned char fpr[20];
88  struct marktrusted_info_s *r;
89
90  gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, fpr, NULL);
91  for (r=marktrusted_info; r; r= r->next)
92    if (!memcmp (r->fpr, fpr, 20))
93      return; /* Already marked. */
94  r = xtrycalloc (1, sizeof *r);
95  if (!r)
96    return;
97  memcpy (r->fpr, fpr, 20);
98  r->next = marktrusted_info;
99  marktrusted_info = r;
100 }
101
102 /* If LISTMODE is true, print FORMAT using LISTMODE to FP.  If
103    LISTMODE is false, use the string to print an log_info or, if
104    IS_ERROR is true, and log_error. */
105 static void
106 do_list (int is_error, int listmode, estream_t fp, const char *format, ...)
107 {
108   va_list arg_ptr;
109
110   va_start (arg_ptr, format) ;
111   if (listmode)
112     {
113       if (fp)
114         {
115           es_fputs ("  [", fp);
116           es_vfprintf (fp, format, arg_ptr);
117           es_fputs ("]\n", fp);
118         }
119     }
120   else
121     {
122       log_logv (is_error? JNLIB_LOG_ERROR: JNLIB_LOG_INFO, format, arg_ptr);
123       log_printf ("\n");
124     }
125   va_end (arg_ptr);
126 }
127
128 /* Return 0 if A and B are equal. */
129 static int
130 compare_certs (ksba_cert_t a, ksba_cert_t b)
131 {
132   const unsigned char *img_a, *img_b;
133   size_t len_a, len_b;
134
135   img_a = ksba_cert_get_image (a, &len_a);
136   if (!img_a)
137     return 1;
138   img_b = ksba_cert_get_image (b, &len_b);
139   if (!img_b)
140     return 1;
141   return !(len_a == len_b && !memcmp (img_a, img_b, len_a));
142 }
143
144
145 /* Return true if CERT has the validityModel extensions and defines
146    the use of the chain model.  */
147 static int
148 has_validation_model_chain (ksba_cert_t cert, int listmode, estream_t listfp)
149 {
150   gpg_error_t err;
151   int idx, yes;
152   const char *oid;
153   size_t off, derlen, objlen, hdrlen;
154   const unsigned char *der;
155   int class, tag, constructed, ndef;
156   char *oidbuf;
157
158   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
159                                              &oid, NULL, &off, &derlen));idx++)
160     if (!strcmp (oid, "1.3.6.1.4.1.8301.3.5") )
161       break;
162   if (err)
163     return 0; /* Not found.  */
164   der = ksba_cert_get_image (cert, NULL);
165   if (!der)
166     {
167       err = gpg_error (GPG_ERR_INV_OBJ); /* Oops  */
168       goto leave;
169     }
170   der += off;
171
172   err = parse_ber_header (&der, &derlen, &class, &tag, &constructed,
173                           &ndef, &objlen, &hdrlen);
174   if (!err && (objlen > derlen || tag != TAG_SEQUENCE))
175     err = gpg_error (GPG_ERR_INV_OBJ);
176   if (err)
177     goto leave;
178   derlen = objlen;
179   err = parse_ber_header (&der, &derlen, &class, &tag, &constructed,
180                           &ndef, &objlen, &hdrlen);
181   if (!err && (objlen > derlen || tag != TAG_OBJECT_ID))
182     err = gpg_error (GPG_ERR_INV_OBJ);
183   if (err)
184     goto leave;
185   oidbuf = ksba_oid_to_str (der, objlen);
186   if (!oidbuf)
187     {
188       err = gpg_error_from_syserror ();
189       goto leave;
190     }
191
192   if (opt.verbose)
193     do_list (0, listmode, listfp,
194              _("validation model requested by certificate: %s"), 
195               !strcmp (oidbuf, "1.3.6.1.4.1.8301.3.5.1")? _("chain") :
196               !strcmp (oidbuf, "1.3.6.1.4.1.8301.3.5.2")? _("shell") :
197               /* */                                       oidbuf);
198   yes = !strcmp (oidbuf, "1.3.6.1.4.1.8301.3.5.1");
199   ksba_free (oidbuf);
200   return yes;
201
202
203  leave:
204   log_error ("error parsing validityModel: %s\n", gpg_strerror (err));
205   return 0;
206 }
207
208
209
210 static int
211 unknown_criticals (ksba_cert_t cert, int listmode, estream_t fp)
212 {
213   static const char *known[] = {
214     "2.5.29.15", /* keyUsage */
215     "2.5.29.17", /* subjectAltName
216                     Japanese DoCoMo certs mark them as critical.  PKIX
217                     only requires them as critical if subjectName is
218                     empty.  I don't know whether our code gracefully
219                     handles such empry subjectNames but that is
220                     another story. */
221     "2.5.29.19", /* basic Constraints */
222     "2.5.29.32", /* certificatePolicies */
223     "2.5.29.37", /* extendedKeyUsage - handled by certlist.c */
224     "1.3.6.1.4.1.8301.3.5", /* validityModel - handled here. */
225     NULL
226   };
227   int rc = 0, i, idx, crit;
228   const char *oid;
229   gpg_error_t err;
230
231   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
232                                              &oid, &crit, NULL, NULL));idx++)
233     {
234       if (!crit)
235         continue;
236       for (i=0; known[i] && strcmp (known[i],oid); i++)
237         ;
238       if (!known[i])
239         {
240           do_list (1, listmode, fp,
241                    _("critical certificate extension %s is not supported"),
242                    oid);
243           rc = gpg_error (GPG_ERR_UNSUPPORTED_CERT);
244         }
245     }
246   /* We ignore the error codes EOF as well as no-value. The later will
247      occur for certificates with no extensions at all. */
248   if (err
249       && gpg_err_code (err) != GPG_ERR_EOF
250       && gpg_err_code (err) != GPG_ERR_NO_VALUE)
251     rc = err;
252
253   return rc;
254 }
255
256
257 /* Check whether CERT is an allowed certificate.  This requires that
258    CERT matches all requirements for such a CA, i.e. the
259    BasicConstraints extension.  The function returns 0 on success and
260    the awlloed length of the chain at CHAINLEN. */
261 static int
262 allowed_ca (ctrl_t ctrl, 
263             ksba_cert_t cert, int *chainlen, int listmode, estream_t fp)
264 {
265   gpg_error_t err;
266   int flag;
267
268   err = ksba_cert_is_ca (cert, &flag, chainlen);
269   if (err)
270     return err;
271   if (!flag)
272     {
273       if (get_regtp_ca_info (ctrl, cert, chainlen))
274         {
275           /* Note that dirmngr takes a different way to cope with such
276              certs. */
277           return 0; /* RegTP issued certificate. */
278         }
279
280       do_list (1, listmode, fp,_("issuer certificate is not marked as a CA"));
281       return gpg_error (GPG_ERR_BAD_CA_CERT);
282     }
283   return 0;
284 }
285
286
287 static int
288 check_cert_policy (ksba_cert_t cert, int listmode, estream_t fplist)
289 {
290   gpg_error_t err;
291   char *policies;
292   FILE *fp;
293   int any_critical;
294
295   err = ksba_cert_get_cert_policies (cert, &policies);
296   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
297     return 0; /* No policy given. */
298   if (err)
299     return err;
300
301   /* STRING is a line delimited list of certificate policies as stored
302      in the certificate.  The line itself is colon delimited where the
303      first field is the OID of the policy and the second field either
304      N or C for normal or critical extension */
305
306   if (opt.verbose > 1 && !listmode)
307     log_info ("certificate's policy list: %s\n", policies);
308
309   /* The check is very minimal but won't give false positives */
310   any_critical = !!strstr (policies, ":C");
311
312   if (!opt.policy_file)
313     { 
314       xfree (policies);
315       if (any_critical)
316         {
317           do_list (1, listmode, fplist,
318                    _("critical marked policy without configured policies"));
319           return gpg_error (GPG_ERR_NO_POLICY_MATCH);
320         }
321       return 0;
322     }
323
324   fp = fopen (opt.policy_file, "r");
325   if (!fp)
326     {
327       if (opt.verbose || errno != ENOENT)
328         log_info (_("failed to open `%s': %s\n"),
329                   opt.policy_file, strerror (errno));
330       xfree (policies);
331       /* With no critical policies this is only a warning */
332       if (!any_critical)
333         {
334           do_list (0, listmode, fplist,
335                    _("note: non-critical certificate policy not allowed"));
336           return 0;
337         }
338       do_list (1, listmode, fplist,
339                _("certificate policy not allowed"));
340       return gpg_error (GPG_ERR_NO_POLICY_MATCH);
341     }
342
343   for (;;) 
344     {
345       int c;
346       char *p, line[256];
347       char *haystack, *allowed;
348
349       /* read line */
350       do
351         {
352           if (!fgets (line, DIM(line)-1, fp) )
353             {
354               gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
355
356               xfree (policies);
357               if (feof (fp))
358                 {
359                   fclose (fp);
360                   /* With no critical policies this is only a warning */
361                   if (!any_critical)
362                     {
363                       do_list (0, listmode, fplist,
364                      _("note: non-critical certificate policy not allowed"));
365                       return 0;
366                     }
367                   do_list (1, listmode, fplist,
368                            _("certificate policy not allowed"));
369                   return gpg_error (GPG_ERR_NO_POLICY_MATCH);
370                 }
371               fclose (fp);
372               return tmperr;
373             }
374       
375           if (!*line || line[strlen(line)-1] != '\n')
376             {
377               /* eat until end of line */
378               while ( (c=getc (fp)) != EOF && c != '\n')
379                 ;
380               fclose (fp);
381               xfree (policies);
382               return gpg_error (*line? GPG_ERR_LINE_TOO_LONG
383                                      : GPG_ERR_INCOMPLETE_LINE);
384             }
385           
386           /* Allow for empty lines and spaces */
387           for (p=line; spacep (p); p++)
388             ;
389         }
390       while (!*p || *p == '\n' || *p == '#');
391   
392       /* parse line */
393       for (allowed=line; spacep (allowed); allowed++)
394         ;
395       p = strpbrk (allowed, " :\n");
396       if (!*p || p == allowed)
397         {
398           fclose (fp);
399           xfree (policies);
400           return gpg_error (GPG_ERR_CONFIGURATION);
401         }
402       *p = 0; /* strip the rest of the line */
403       /* See whether we find ALLOWED (which is an OID) in POLICIES */
404       for (haystack=policies; (p=strstr (haystack, allowed)); haystack = p+1)
405         {
406           if ( !(p == policies || p[-1] == '\n') )
407             continue; /* Does not match the begin of a line. */
408           if (p[strlen (allowed)] != ':')
409             continue; /* The length does not match. */
410           /* Yep - it does match so return okay. */
411           fclose (fp);
412           xfree (policies);
413           return 0;
414         }
415     }
416 }
417
418
419 /* Helper function for find_up.  This resets the key handle and search
420    for an issuer ISSUER with a subjectKeyIdentifier of KEYID.  Returns
421    0 on success or -1 when not found. */
422 static int
423 find_up_search_by_keyid (KEYDB_HANDLE kh,
424                          const char *issuer, ksba_sexp_t keyid)
425 {
426   int rc;
427   ksba_cert_t cert = NULL;
428   ksba_sexp_t subj = NULL;
429
430   keydb_search_reset (kh);
431   while (!(rc = keydb_search_subject (kh, issuer)))
432     {
433       ksba_cert_release (cert); cert = NULL;
434       rc = keydb_get_cert (kh, &cert);
435       if (rc)
436         {
437           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
438           rc = -1;
439           break;
440         }
441       xfree (subj);
442       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj))
443         {
444           if (!cmp_simple_canon_sexp (keyid, subj))
445             break; /* Found matching cert. */
446         }
447     }
448   
449   ksba_cert_release (cert);
450   xfree (subj);
451   return rc? -1:0;
452 }
453
454
455 static void
456 find_up_store_certs_cb (void *cb_value, ksba_cert_t cert)
457 {
458   if (keydb_store_cert (cert, 1, NULL))
459     log_error ("error storing issuer certificate as ephemeral\n");
460   ++*(int*)cb_value;
461 }
462
463
464 /* Helper for find_up().  Locate the certificate for ISSUER using an
465    external lookup.  KH is the keydb context we are currently using.
466    On success 0 is returned and the certificate may be retrieved from
467    the keydb using keydb_get_cert().  KEYID is the keyIdentifier from
468    the AKI or NULL.  */
469 static int
470 find_up_external (ctrl_t ctrl, KEYDB_HANDLE kh,
471                   const char *issuer, ksba_sexp_t keyid)
472 {
473   int rc;
474   strlist_t names = NULL;
475   int count = 0;
476   char *pattern;
477   const char *s;
478       
479   if (opt.verbose)
480     log_info (_("looking up issuer at external location\n"));
481   /* The Dirmngr process is confused about unknown attributes.  As a
482      quick and ugly hack we locate the CN and use the issuer string
483      starting at this attribite.  Fixme: we should have far better
484      parsing for external lookups in the Dirmngr. */
485   s = strstr (issuer, "CN=");
486   if (!s || s == issuer || s[-1] != ',')
487     s = issuer;
488   pattern = xtrymalloc (strlen (s)+2);
489   if (!pattern)
490     return gpg_error_from_syserror ();
491   strcpy (stpcpy (pattern, "/"), s);
492   add_to_strlist (&names, pattern);
493   xfree (pattern);
494
495   rc = gpgsm_dirmngr_lookup (ctrl, names, 0, find_up_store_certs_cb, &count);
496   free_strlist (names);
497
498   if (opt.verbose)
499     log_info (_("number of issuers matching: %d\n"), count);
500   if (rc) 
501     {
502       log_error ("external key lookup failed: %s\n", gpg_strerror (rc));
503       rc = -1;
504     }
505   else if (!count)
506     rc = -1;
507   else
508     {
509       int old;
510       /* The issuers are currently stored in the ephemeral key DB, so
511          we temporary switch to ephemeral mode. */
512       old = keydb_set_ephemeral (kh, 1);
513       if (keyid)
514         rc = find_up_search_by_keyid (kh, issuer, keyid);
515       else
516         {
517           keydb_search_reset (kh);
518           rc = keydb_search_subject (kh, issuer);
519         }
520       keydb_set_ephemeral (kh, old);
521     }
522   return rc;
523 }
524
525
526 /* Helper for find_up().  Ask the dirmngr for the certificate for
527    ISSUER with optional SERIALNO.  KH is the keydb context we are
528    currently using.  With SUBJECT_MODE set, ISSUER is searched as the
529    subject.  On success 0 is returned and the certificate is available
530    in the ephemeral DB.  */
531 static int
532 find_up_dirmngr (ctrl_t ctrl, KEYDB_HANDLE kh,
533                  ksba_sexp_t serialno, const char *issuer, int subject_mode)
534 {
535   int rc;
536   strlist_t names = NULL;
537   int count = 0;
538   char *pattern;
539       
540   if (opt.verbose)
541     log_info (_("looking up issuer from the Dirmngr cache\n"));
542   if (subject_mode)
543     {
544       pattern = xtrymalloc (strlen (issuer)+2);
545       if (pattern)
546         strcpy (stpcpy (pattern, "/"), issuer);
547     }
548   else if (serialno)
549     pattern = gpgsm_format_sn_issuer (serialno, issuer);
550   else
551     {
552       pattern = xtrymalloc (strlen (issuer)+3);
553       if (pattern)
554         strcpy (stpcpy (pattern, "#/"), issuer);
555     }
556   if (!pattern)
557     return gpg_error_from_syserror ();
558   add_to_strlist (&names, pattern);
559   xfree (pattern);
560
561   rc = gpgsm_dirmngr_lookup (ctrl, names, 1, find_up_store_certs_cb, &count);
562   free_strlist (names);
563
564   if (opt.verbose)
565     log_info (_("number of matching certificates: %d\n"), count);
566   if (rc) 
567     log_info (_("dirmngr cache-only key lookup failed: %s\n"),
568               gpg_strerror (rc));
569   return (!rc && count)? 0 : -1;
570 }
571
572
573
574 /* Locate issuing certificate for CERT. ISSUER is the name of the
575    issuer used as a fallback if the other methods don't work.  If
576    FIND_NEXT is true, the function shall return the next possible
577    issuer.  The certificate itself is not directly returned but a
578    keydb_get_cert on the keyDb context KH will return it.  Returns 0
579    on success, -1 if not found or an error code.  */
580 static int
581 find_up (ctrl_t ctrl, KEYDB_HANDLE kh, 
582          ksba_cert_t cert, const char *issuer, int find_next)
583 {
584   ksba_name_t authid;
585   ksba_sexp_t authidno;
586   ksba_sexp_t keyid;
587   int rc = -1;
588
589   if (!ksba_cert_get_auth_key_id (cert, &keyid, &authid, &authidno))
590     {
591       const char *s = ksba_name_enum (authid, 0);
592       if (s && *authidno)
593         {
594           rc = keydb_search_issuer_sn (kh, s, authidno);
595           if (rc)
596               keydb_search_reset (kh);
597           
598           /* In case of an error, try to get the certifcate from the
599              dirmngr.  That is done by trying to put that certifcate
600              into the ephemeral DB and let the code below do the
601              actual retrieve.  Thus there is no error checking.
602              Skipped in find_next mode as usual. */
603           if (rc == -1 && !find_next)
604             find_up_dirmngr (ctrl, kh, authidno, s, 0);
605
606           /* In case of an error try the ephemeral DB.  We can't do
607              that in find_next mode because we can't keep the search
608              state then. */
609           if (rc == -1 && !find_next)
610             { 
611               int old = keydb_set_ephemeral (kh, 1);
612               if (!old)
613                 {
614                   rc = keydb_search_issuer_sn (kh, s, authidno);
615                   if (rc)
616                     keydb_search_reset (kh);
617                 }
618               keydb_set_ephemeral (kh, old);
619             }
620           if (rc) 
621             rc = -1; /* Need to make sure to have this error code. */
622         }
623
624       if (rc == -1 && keyid && !find_next)
625         {
626           /* Not found by AIK.issuer_sn.  Lets try the AIK.ki
627              instead. Loop over all certificates with that issuer as
628              subject and stop for the one with a matching
629              subjectKeyIdentifier. */
630           /* Fixme: Should we also search in the dirmngr?  */
631           rc = find_up_search_by_keyid (kh, issuer, keyid);
632           if (rc)
633             {
634               int old = keydb_set_ephemeral (kh, 1);
635               if (!old)
636                 rc = find_up_search_by_keyid (kh, issuer, keyid);
637               keydb_set_ephemeral (kh, old);
638             }
639           if (rc) 
640             rc = -1; /* Need to make sure to have this error code. */
641         }
642
643       /* If we still didn't found it, try to find it via the subject
644          from the dirmngr-cache.  */
645       if (rc == -1 && !find_next)
646         {
647           if (!find_up_dirmngr (ctrl, kh, NULL, issuer, 1))
648             {
649               int old = keydb_set_ephemeral (kh, 1);
650               if (keyid)
651                 rc = find_up_search_by_keyid (kh, issuer, keyid);
652               else
653                 {
654                   keydb_search_reset (kh);
655                   rc = keydb_search_subject (kh, issuer);
656                 }
657               keydb_set_ephemeral (kh, old);
658             }
659           if (rc) 
660             rc = -1; /* Need to make sure to have this error code. */
661         }
662
663       /* If we still didn't found it, try an external lookup.  */
664       if (rc == -1 && opt.auto_issuer_key_retrieve && !find_next)
665         rc = find_up_external (ctrl, kh, issuer, keyid);
666
667       /* Print a note so that the user does not feel too helpless when
668          an issuer certificate was found and gpgsm prints BAD
669          signature because it is not the correct one. */
670       if (rc == -1)
671         {
672           log_info ("%sissuer certificate ", find_next?"next ":"");
673           if (keyid)
674             {
675               log_printf ("{");
676               gpgsm_dump_serial (keyid);
677               log_printf ("} ");
678             }
679           if (authidno)
680             {
681               log_printf ("(#");
682               gpgsm_dump_serial (authidno);
683               log_printf ("/");
684               gpgsm_dump_string (s);
685               log_printf (") ");
686             }
687           log_printf ("not found using authorityKeyIdentifier\n");
688         }
689       else if (rc)
690         log_error ("failed to find authorityKeyIdentifier: rc=%d\n", rc);
691       xfree (keyid);
692       ksba_name_release (authid);
693       xfree (authidno);
694     }
695   
696   if (rc) /* Not found via authorithyKeyIdentifier, try regular issuer name. */
697     rc = keydb_search_subject (kh, issuer);
698   if (rc == -1 && !find_next)
699     {
700       /* Also try to get it from the Dirmngr cache.  The function
701          merely puts it into the ephemeral database.  */
702       find_up_dirmngr (ctrl, kh, NULL, issuer, 0);
703
704       /* Not found, let us see whether we have one in the ephemeral key DB. */
705       int old = keydb_set_ephemeral (kh, 1);
706       if (!old)
707         {
708           keydb_search_reset (kh);
709           rc = keydb_search_subject (kh, issuer);
710         }
711       keydb_set_ephemeral (kh, old);
712     }
713
714   /* Still not found.  If enabled, try an external lookup.  */
715   if (rc == -1 && opt.auto_issuer_key_retrieve && !find_next)
716     rc = find_up_external (ctrl, kh, issuer, NULL);
717
718   return rc;
719 }
720
721
722 /* Return the next certificate up in the chain starting at START.
723    Returns -1 when there are no more certificates. */
724 int
725 gpgsm_walk_cert_chain (ctrl_t ctrl, ksba_cert_t start, ksba_cert_t *r_next)
726 {
727   int rc = 0; 
728   char *issuer = NULL;
729   char *subject = NULL;
730   KEYDB_HANDLE kh = keydb_new (0);
731
732   *r_next = NULL;
733   if (!kh)
734     {
735       log_error (_("failed to allocated keyDB handle\n"));
736       rc = gpg_error (GPG_ERR_GENERAL);
737       goto leave;
738     }
739
740   issuer = ksba_cert_get_issuer (start, 0);
741   subject = ksba_cert_get_subject (start, 0);
742   if (!issuer)
743     {
744       log_error ("no issuer found in certificate\n");
745       rc = gpg_error (GPG_ERR_BAD_CERT);
746       goto leave;
747     }
748   if (!subject)
749     {
750       log_error ("no subject found in certificate\n");
751       rc = gpg_error (GPG_ERR_BAD_CERT);
752       goto leave;
753     }
754
755   if (!strcmp (issuer, subject))
756     {
757       rc = -1; /* we are at the root */
758       goto leave; 
759     }
760
761   rc = find_up (ctrl, kh, start, issuer, 0);
762   if (rc)
763     {
764       /* It is quite common not to have a certificate, so better don't
765          print an error here.  */
766       if (rc != -1 && opt.verbose > 1)
767         log_error ("failed to find issuer's certificate: rc=%d\n", rc);
768       rc = gpg_error (GPG_ERR_MISSING_CERT);
769       goto leave;
770     }
771
772   rc = keydb_get_cert (kh, r_next);
773   if (rc)
774     {
775       log_error ("keydb_get_cert() failed: rc=%d\n", rc);
776       rc = gpg_error (GPG_ERR_GENERAL);
777     }
778
779  leave:
780   xfree (issuer);
781   xfree (subject);
782   keydb_release (kh); 
783   return rc;
784 }
785
786
787 /* Check whether the CERT is a root certificate.  Returns True if this
788    is the case. */
789 int
790 gpgsm_is_root_cert (ksba_cert_t cert)
791 {
792   char *issuer;
793   char *subject;
794   int yes;
795
796   issuer = ksba_cert_get_issuer (cert, 0);
797   subject = ksba_cert_get_subject (cert, 0);
798   yes = (issuer && subject && !strcmp (issuer, subject));
799   xfree (issuer);
800   xfree (subject);
801   return yes;
802 }
803
804
805 /* This is a helper for gpgsm_validate_chain. */
806 static gpg_error_t 
807 is_cert_still_valid (ctrl_t ctrl, int force_ocsp, int lm, estream_t fp,
808                      ksba_cert_t subject_cert, ksba_cert_t issuer_cert,
809                      int *any_revoked, int *any_no_crl, int *any_crl_too_old)
810 {
811   gpg_error_t err;
812
813   if (opt.no_crl_check && !ctrl->use_ocsp)
814     return 0;
815
816   err = gpgsm_dirmngr_isvalid (ctrl,
817                                subject_cert, issuer_cert, 
818                                force_ocsp? 2 : !!ctrl->use_ocsp);
819   if (err)
820     {
821       if (!lm)
822         gpgsm_cert_log_name (NULL, subject_cert);
823       switch (gpg_err_code (err))
824         {
825         case GPG_ERR_CERT_REVOKED:
826           do_list (1, lm, fp, _("certificate has been revoked"));
827           *any_revoked = 1;
828           /* Store that in the keybox so that key listings are able to
829              return the revoked flag.  We don't care about error,
830              though. */
831           keydb_set_cert_flags (subject_cert, 1, KEYBOX_FLAG_VALIDITY, 0,
832                                 ~0, VALIDITY_REVOKED);
833           break;
834
835         case GPG_ERR_NO_CRL_KNOWN:
836           do_list (1, lm, fp, _("no CRL found for certificate"));
837           *any_no_crl = 1;
838           break;
839
840         case GPG_ERR_NO_DATA:
841           do_list (1, lm, fp, _("the status of the certificate is unknown"));
842           *any_no_crl = 1;
843           break;
844
845         case GPG_ERR_CRL_TOO_OLD:
846           do_list (1, lm, fp, _("the available CRL is too old"));
847           if (!lm)
848             log_info (_("please make sure that the "
849                         "\"dirmngr\" is properly installed\n"));
850           *any_crl_too_old = 1;
851           break;
852           
853         default:
854           do_list (1, lm, fp, _("checking the CRL failed: %s"),
855                    gpg_strerror (err));
856           return err;
857         }
858     }
859   return 0;
860 }
861
862
863 /* Helper for gpgsm_validate_chain to check the validity period of
864    SUBJECT_CERT.  The caller needs to pass EXPTIME which will be
865    updated to the nearest expiration time seen.  A DEPTH of 0 indicates
866    the target certifciate, -1 the final root certificate and other
867    values intermediate certificates. */ 
868 static gpg_error_t
869 check_validity_period (ksba_isotime_t current_time,
870                        ksba_cert_t subject_cert,
871                        ksba_isotime_t exptime,
872                        int listmode, estream_t listfp, int depth)
873 {
874   gpg_error_t err;
875   ksba_isotime_t not_before, not_after;
876
877   err = ksba_cert_get_validity (subject_cert, 0, not_before);
878   if (!err)
879     err = ksba_cert_get_validity (subject_cert, 1, not_after);
880   if (err)
881     {
882       do_list (1, listmode, listfp,
883                _("certificate with invalid validity: %s"), gpg_strerror (err));
884       return gpg_error (GPG_ERR_BAD_CERT);
885     }
886
887   if (*not_after)
888     {
889       if (!*exptime)
890         gnupg_copy_time (exptime, not_after);
891       else if (strcmp (not_after, exptime) < 0 )
892         gnupg_copy_time (exptime, not_after);
893     }
894
895   if (*not_before && strcmp (current_time, not_before) < 0 )
896     {
897       do_list (1, listmode, listfp, 
898                depth ==  0 ? _("certificate not yet valid") :
899                depth == -1 ? _("root certificate not yet valid") :
900                /* other */   _("intermediate certificate not yet valid"));
901       if (!listmode)
902         {
903           log_info ("  (valid from ");
904           gpgsm_dump_time (not_before);
905           log_printf (")\n");
906         }
907       return gpg_error (GPG_ERR_CERT_TOO_YOUNG);
908     } 
909            
910   if (*not_after && strcmp (current_time, not_after) > 0 )
911     {
912       do_list (opt.ignore_expiration?0:1, listmode, listfp,
913                depth == 0  ? _("certificate has expired") :
914                depth == -1 ? _("root certificate has expired") :
915                /* other  */  _("intermediate certificate has expired"));
916       if (!listmode)
917         {
918           log_info ("  (expired at ");
919           gpgsm_dump_time (not_after);
920           log_printf (")\n");
921         }
922       if (opt.ignore_expiration)
923         log_info ("WARNING: ignoring expiration\n");
924       else
925         return gpg_error (GPG_ERR_CERT_EXPIRED);
926     }      
927       
928   return 0;
929 }
930
931 /* This is a variant of check_validity_period used with the chain
932    model.  The dextra contraint here is that notBefore and notAfter
933    must exists and if the additional argument CHECK_TIME is given this
934    time is used to check the validity period of SUBJECT_CERT.  */
935 static gpg_error_t
936 check_validity_period_cm (ksba_isotime_t current_time,
937                           ksba_isotime_t check_time,
938                           ksba_cert_t subject_cert,
939                           ksba_isotime_t exptime,
940                           int listmode, estream_t listfp, int depth)
941 {
942   gpg_error_t err;
943   ksba_isotime_t not_before, not_after;
944
945   err = ksba_cert_get_validity (subject_cert, 0, not_before);
946   if (!err)
947     err = ksba_cert_get_validity (subject_cert, 1, not_after);
948   if (err)
949     {
950       do_list (1, listmode, listfp,
951                _("certificate with invalid validity: %s"), gpg_strerror (err));
952       return gpg_error (GPG_ERR_BAD_CERT);
953     }
954   if (!*not_before || !*not_after)
955     {
956       do_list (1, listmode, listfp,
957                _("required certificate attributes missing: %s%s%s"),
958                !*not_before? "notBefore":"",
959                (!*not_before && !*not_after)? ", ":"",
960                !*not_before? "notAfter":"");
961       return gpg_error (GPG_ERR_BAD_CERT);
962     }
963   if (strcmp (not_before, not_after) > 0 )
964     {
965       do_list (1, listmode, listfp,
966                _("certificate with invalid validity"));
967       log_info ("  (valid from ");
968       gpgsm_dump_time (not_before);
969       log_printf (" expired at ");
970       gpgsm_dump_time (not_after);
971       log_printf (")\n");
972       return gpg_error (GPG_ERR_BAD_CERT);
973     }
974   
975   if (!*exptime)
976     gnupg_copy_time (exptime, not_after);
977   else if (strcmp (not_after, exptime) < 0 )
978     gnupg_copy_time (exptime, not_after);
979
980   if (strcmp (current_time, not_before) < 0 )
981     {
982       do_list (1, listmode, listfp, 
983                depth ==  0 ? _("certificate not yet valid") :
984                depth == -1 ? _("root certificate not yet valid") :
985                /* other */   _("intermediate certificate not yet valid"));
986       if (!listmode)
987         {
988           log_info ("  (valid from ");
989           gpgsm_dump_time (not_before);
990           log_printf (")\n");
991         }
992       return gpg_error (GPG_ERR_CERT_TOO_YOUNG);
993     } 
994
995   if (*check_time
996       && (strcmp (check_time, not_before) < 0 
997           || strcmp (check_time, not_after) > 0))
998     {
999       /* Note that we don't need a case for the root certificate
1000          because its own consitency has already been checked.  */
1001       do_list(opt.ignore_expiration?0:1, listmode, listfp,
1002               depth == 0 ? 
1003               _("signature not created during lifetime of certificate") :
1004               depth == 1 ?
1005               _("certificate not created during lifetime of issuer") :
1006               _("intermediate certificate not created during lifetime "
1007                 "of issuer"));
1008       if (!listmode)
1009         {
1010           log_info (depth== 0? _("  (  signature created at ") :
1011                     /* */      _("  (certificate created at ") );
1012           gpgsm_dump_time (check_time);
1013           log_printf (")\n");
1014           log_info (depth==0? _("  (certificate valid from ") :
1015                     /* */     _("  (     issuer valid from ") );
1016           gpgsm_dump_time (not_before);
1017           log_info (" to ");
1018           gpgsm_dump_time (not_after);
1019           log_printf (")\n");
1020         }
1021       if (opt.ignore_expiration)
1022         log_info ("WARNING: ignoring expiration\n");
1023       else
1024         return gpg_error (GPG_ERR_CERT_EXPIRED);
1025     }
1026
1027   return 0;
1028 }
1029
1030
1031
1032 /* Ask the user whether he wants to mark the certificate CERT trusted.
1033    Returns true if the CERT is the trusted.  We also check whether the
1034    agent is at all enabled to allow marktrusted and don't call it in
1035    this session again if it is not.  */
1036 static int
1037 ask_marktrusted (ctrl_t ctrl, ksba_cert_t cert, int listmode)
1038 {
1039   static int no_more_questions; 
1040   int rc;
1041   char *fpr;
1042   int success = 0;
1043
1044   fpr = gpgsm_get_fingerprint_string (cert, GCRY_MD_SHA1);
1045   log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
1046   xfree (fpr);
1047   
1048   if (no_more_questions)
1049     rc = gpg_error (GPG_ERR_NOT_SUPPORTED);
1050   else
1051     rc = gpgsm_agent_marktrusted (ctrl, cert);
1052   if (!rc)
1053     {
1054       log_info (_("root certificate has now been marked as trusted\n"));
1055       success = 1;
1056     }
1057   else if (!listmode)
1058     {
1059       gpgsm_dump_cert ("issuer", cert);
1060       log_info ("after checking the fingerprint, you may want "
1061                 "to add it manually to the list of trusted certificates.\n");
1062     }
1063
1064   if (gpg_err_code (rc) == GPG_ERR_NOT_SUPPORTED)
1065     {
1066       if (!no_more_questions)
1067         log_info (_("interactive marking as trusted "
1068                     "not enabled in gpg-agent\n"));
1069       no_more_questions = 1;
1070     }
1071   else if (gpg_err_code (rc) == GPG_ERR_CANCELED)
1072     {
1073       log_info (_("interactive marking as trusted "
1074                   "disabled for this session\n"));
1075       no_more_questions = 1;
1076     }
1077   else
1078     set_already_asked_marktrusted (cert);
1079
1080   return success;
1081 }
1082
1083
1084
1085 \f
1086 /* Validate a chain and optionally return the nearest expiration time
1087    in R_EXPTIME. With LISTMODE set to 1 a special listmode is
1088    activated where only information about the certificate is printed
1089    to LISTFP and no output is send to the usual log stream.  If
1090    CHECKTIME_ARG is set, it is used only in the chain model instead of the
1091    current time.
1092
1093    Defined flag bits
1094
1095    VALIDATE_FLAG_NO_DIRMNGR  - Do not do any dirmngr isvalid checks.
1096    VALIDATE_FLAG_CHAIN_MODEL - Check according to chain model.
1097 */
1098 static int
1099 do_validate_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t checktime_arg,
1100                    ksba_isotime_t r_exptime,
1101                    int listmode, estream_t listfp, unsigned int flags,
1102                    struct rootca_flags_s *rootca_flags)
1103 {
1104   int rc = 0, depth, maxdepth;
1105   char *issuer = NULL;
1106   char *subject = NULL;
1107   KEYDB_HANDLE kh = NULL;
1108   ksba_cert_t subject_cert = NULL, issuer_cert = NULL;
1109   ksba_isotime_t current_time;
1110   ksba_isotime_t check_time;
1111   ksba_isotime_t exptime;
1112   int any_expired = 0;
1113   int any_revoked = 0;
1114   int any_no_crl = 0;
1115   int any_crl_too_old = 0;
1116   int any_no_policy_match = 0;
1117   int is_qualified = -1; /* Indicates whether the certificate stems
1118                             from a qualified root certificate.
1119                             -1 = unknown, 0 = no, 1 = yes. */
1120   chain_item_t chain = NULL; /* A list of all certificates in the chain.  */
1121
1122
1123   gnupg_get_isotime (current_time);
1124
1125   if ( (flags & VALIDATE_FLAG_CHAIN_MODEL) )
1126     {
1127       if (!strcmp (checktime_arg, "19700101T000000"))
1128         {
1129           do_list (1, listmode, listfp, 
1130                    _("WARNING: creation time of signature not known - "
1131                      "assuming current time"));
1132           gnupg_copy_time (check_time, current_time);
1133         }
1134       else
1135         gnupg_copy_time (check_time, checktime_arg);
1136     }
1137   else
1138     *check_time = 0;
1139
1140   if (r_exptime)
1141     *r_exptime = 0;
1142   *exptime = 0;
1143
1144   if (opt.no_chain_validation && !listmode)
1145     {
1146       log_info ("WARNING: bypassing certificate chain validation\n");
1147       return 0;
1148     }
1149
1150   kh = keydb_new (0);
1151   if (!kh)
1152     {
1153       log_error (_("failed to allocated keyDB handle\n"));
1154       rc = gpg_error (GPG_ERR_GENERAL);
1155       goto leave;
1156     }
1157
1158   if (DBG_X509 && !listmode)
1159     gpgsm_dump_cert ("target", cert);
1160
1161   subject_cert = cert;
1162   ksba_cert_ref (subject_cert);
1163   maxdepth = 50;
1164   depth = 0;
1165
1166   for (;;)
1167     {
1168       int is_root;
1169       gpg_error_t istrusted_rc = -1;
1170
1171       /* Put the certificate on our list.  */
1172       {
1173         chain_item_t ci;
1174
1175         ci = xtrycalloc (1, sizeof *ci);
1176         if (!ci)
1177           {
1178             rc = gpg_error_from_syserror ();
1179             goto leave;
1180           }
1181         ksba_cert_ref (subject_cert);
1182         ci->cert = subject_cert;
1183         ci->next = chain;
1184         chain = ci;
1185       }
1186
1187       xfree (issuer);
1188       xfree (subject);
1189       issuer = ksba_cert_get_issuer (subject_cert, 0);
1190       subject = ksba_cert_get_subject (subject_cert, 0);
1191
1192       if (!issuer)
1193         {
1194           do_list (1, listmode, listfp,  _("no issuer found in certificate"));
1195           rc = gpg_error (GPG_ERR_BAD_CERT);
1196           goto leave;
1197         }
1198
1199
1200       /* Is this a self-issued certificate (i.e. the root
1201          certificate)?  This is actually the same test as done by
1202          gpgsm_is_root_cert but here we want to keep the issuer and
1203          subject for later use.  */
1204       is_root = (subject && !strcmp (issuer, subject));
1205       if (is_root)
1206         {
1207           chain->is_root = 1;
1208           /* Check early whether the certificate is listed as trusted.
1209              We used to do this only later but changed it to call the
1210              check right here so that we can access special flags
1211              associated with that specific root certificate.  */
1212           istrusted_rc = gpgsm_agent_istrusted (ctrl, subject_cert,
1213                                                 rootca_flags);
1214           audit_log_cert (ctrl->audit, AUDIT_ROOT_TRUSTED,
1215                           subject_cert, istrusted_rc);
1216           /* If the chain model extended attribute is used, make sure
1217              that our chain model flag is set. */
1218           if (has_validation_model_chain (subject_cert, listmode, listfp))
1219             rootca_flags->chain_model = 1;
1220         }
1221       
1222
1223       /* Check the validity period. */
1224       if ( (flags & VALIDATE_FLAG_CHAIN_MODEL) )
1225         rc = check_validity_period_cm (current_time, check_time, subject_cert,
1226                                        exptime, listmode, listfp,
1227                                        (depth && is_root)? -1: depth);
1228       else
1229         rc = check_validity_period (current_time, subject_cert,
1230                                     exptime, listmode, listfp,
1231                                     (depth && is_root)? -1: depth);
1232       if (gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED)
1233         {
1234           any_expired = 1;
1235           rc = 0;
1236         }
1237       else if (rc)
1238         goto leave;
1239         
1240
1241       /* Assert that we understand all critical extensions. */
1242       rc = unknown_criticals (subject_cert, listmode, listfp);
1243       if (rc)
1244         goto leave;
1245
1246       /* Do a policy check. */
1247       if (!opt.no_policy_check)
1248         {
1249           rc = check_cert_policy (subject_cert, listmode, listfp);
1250           if (gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH)
1251             {
1252               any_no_policy_match = 1;
1253               rc = 1;
1254             }
1255           else if (rc)
1256             goto leave;
1257         }
1258
1259
1260       /* If this is the root certificate we are at the end of the chain.  */
1261       if (is_root)
1262         { 
1263           if (!istrusted_rc)
1264             ; /* No need to check the certificate for a trusted one. */
1265           else if (gpgsm_check_cert_sig (subject_cert, subject_cert) )
1266             {
1267               /* We only check the signature if the certificate is not
1268                  trusted for better diagnostics. */
1269               do_list (1, listmode, listfp,
1270                        _("self-signed certificate has a BAD signature"));
1271               if (DBG_X509)
1272                 {
1273                   gpgsm_dump_cert ("self-signing cert", subject_cert);
1274                 }
1275               rc = gpg_error (depth? GPG_ERR_BAD_CERT_CHAIN
1276                                    : GPG_ERR_BAD_CERT);
1277               goto leave;
1278             }
1279           if (!rootca_flags->relax)
1280             {
1281               rc = allowed_ca (ctrl, subject_cert, NULL, listmode, listfp);
1282               if (rc)
1283                 goto leave;
1284             }
1285               
1286           
1287           /* Set the flag for qualified signatures.  This flag is
1288              deduced from a list of root certificates allowed for
1289              qualified signatures. */
1290           if (is_qualified == -1)
1291             {
1292               gpg_error_t err;
1293               size_t buflen;
1294               char buf[1];
1295               
1296               if (!ksba_cert_get_user_data (cert, "is_qualified", 
1297                                             &buf, sizeof (buf),
1298                                             &buflen) && buflen)
1299                 {
1300                   /* We already checked this for this certificate,
1301                      thus we simply take it from the user data. */
1302                   is_qualified = !!*buf;
1303                 }    
1304               else
1305                 {
1306                   /* Need to consult the list of root certificates for
1307                      qualified signatures. */
1308                   err = gpgsm_is_in_qualified_list (ctrl, subject_cert, NULL);
1309                   if (!err)
1310                     is_qualified = 1;
1311                   else if ( gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1312                     is_qualified = 0;
1313                   else
1314                     log_error ("checking the list of qualified "
1315                                "root certificates failed: %s\n",
1316                                gpg_strerror (err));
1317                   if ( is_qualified != -1 )
1318                     {
1319                       /* Cache the result but don't care too much
1320                          about an error. */
1321                       buf[0] = !!is_qualified;
1322                       err = ksba_cert_set_user_data (subject_cert,
1323                                                      "is_qualified", buf, 1);
1324                       if (err)
1325                         log_error ("set_user_data(is_qualified) failed: %s\n",
1326                                    gpg_strerror (err)); 
1327                     }
1328                 }
1329             }
1330
1331
1332           /* Act on the check for a trusted root certificates. */
1333           rc = istrusted_rc;
1334           if (!rc)
1335             ;
1336           else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
1337             {
1338               do_list (0, listmode, listfp, 
1339                        _("root certificate is not marked trusted"));
1340               /* If we already figured out that the certificate is
1341                  expired it does not make much sense to ask the user
1342                  whether we wants to trust the root certificate.  We
1343                  should do this only if the certificate under question
1344                  will then be usable.  */
1345               if ( !any_expired
1346                    && (!listmode || !already_asked_marktrusted (subject_cert))
1347                    && ask_marktrusted (ctrl, subject_cert, listmode) )
1348                 rc = 0;
1349             }
1350           else 
1351             {
1352               log_error (_("checking the trust list failed: %s\n"),
1353                          gpg_strerror (rc));
1354             }
1355           
1356           if (rc)
1357             goto leave;
1358
1359           /* Check for revocations etc. */
1360           if ((flags & VALIDATE_FLAG_NO_DIRMNGR))
1361             ;
1362           else if (opt.no_trusted_cert_crl_check || rootca_flags->relax)
1363             ; 
1364           else
1365             rc = is_cert_still_valid (ctrl, 
1366                                       (flags & VALIDATE_FLAG_CHAIN_MODEL),
1367                                       listmode, listfp,
1368                                       subject_cert, subject_cert,
1369                                       &any_revoked, &any_no_crl,
1370                                       &any_crl_too_old);
1371           if (rc)
1372             goto leave;
1373
1374           break;  /* Okay: a self-signed certicate is an end-point. */
1375         } /* End is_root.  */
1376
1377       
1378       /* Take care that the chain does not get too long. */
1379       if ((depth+1) > maxdepth)
1380         {
1381           do_list (1, listmode, listfp, _("certificate chain too long\n"));
1382           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
1383           goto leave;
1384         }
1385
1386       /* Find the next cert up the tree. */
1387       keydb_search_reset (kh);
1388       rc = find_up (ctrl, kh, subject_cert, issuer, 0);
1389       if (rc)
1390         {
1391           if (rc == -1)
1392             {
1393               do_list (0, listmode, listfp, _("issuer certificate not found"));
1394               if (!listmode)
1395                 {
1396                   log_info ("issuer certificate: #/");
1397                   gpgsm_dump_string (issuer);
1398                   log_printf ("\n");
1399                 }
1400             }
1401           else
1402             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
1403           rc = gpg_error (GPG_ERR_MISSING_CERT);
1404           goto leave;
1405         }
1406
1407       ksba_cert_release (issuer_cert); issuer_cert = NULL;
1408       rc = keydb_get_cert (kh, &issuer_cert);
1409       if (rc)
1410         {
1411           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
1412           rc = gpg_error (GPG_ERR_GENERAL);
1413           goto leave;
1414         }
1415
1416     try_another_cert:
1417       if (DBG_X509)
1418         {
1419           log_debug ("got issuer's certificate:\n");
1420           gpgsm_dump_cert ("issuer", issuer_cert);
1421         }
1422
1423       rc = gpgsm_check_cert_sig (issuer_cert, subject_cert);
1424       if (rc)
1425         {
1426           do_list (0, listmode, listfp, _("certificate has a BAD signature"));
1427           if (DBG_X509)
1428             {
1429               gpgsm_dump_cert ("signing issuer", issuer_cert);
1430               gpgsm_dump_cert ("signed subject", subject_cert);
1431             }
1432           if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
1433             {
1434               /* We now try to find other issuer certificates which
1435                  might have been used.  This is required because some
1436                  CAs are reusing the issuer and subject DN for new
1437                  root certificates. */
1438               /* FIXME: Do this only if we don't have an
1439                  AKI.keyIdentifier */
1440               rc = find_up (ctrl, kh, subject_cert, issuer, 1);
1441               if (!rc)
1442                 {
1443                   ksba_cert_t tmp_cert;
1444
1445                   rc = keydb_get_cert (kh, &tmp_cert);
1446                   if (rc || !compare_certs (issuer_cert, tmp_cert))
1447                     {
1448                       /* The find next did not work or returned an
1449                          identical certificate.  We better stop here
1450                          to avoid infinite checks. */
1451                       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
1452                       ksba_cert_release (tmp_cert);
1453                     }
1454                   else
1455                     {
1456                       do_list (0, listmode, listfp,
1457                                _("found another possible matching "
1458                                  "CA certificate - trying again"));
1459                       ksba_cert_release (issuer_cert); 
1460                       issuer_cert = tmp_cert;
1461                       goto try_another_cert;
1462                     }
1463                 }
1464             }
1465
1466           /* We give a more descriptive error code than the one
1467              returned from the signature checking. */
1468           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
1469           goto leave;
1470         }
1471
1472       is_root = gpgsm_is_root_cert (issuer_cert);
1473       istrusted_rc = -1;
1474
1475
1476       /* Check that a CA is allowed to issue certificates. */
1477       {
1478         int chainlen;
1479
1480         rc = allowed_ca (ctrl, issuer_cert, &chainlen, listmode, listfp);
1481         if (rc)
1482           {
1483             /* Not allowed.  Check whether this is a trusted root
1484                certificate and whether we allow special exceptions.
1485                We could carry the result of the test over to the
1486                regular root check at the top of the loop but for
1487                clarity we won't do that.  Given that the majority of
1488                certificates carry proper BasicContraints our way of
1489                overriding an error in the way is justified for
1490                performance reasons. */
1491             if (is_root)
1492               {
1493                 istrusted_rc = gpgsm_agent_istrusted (ctrl, issuer_cert,
1494                                                       rootca_flags);
1495                 if (!istrusted_rc && rootca_flags->relax)
1496                   {
1497                     /* Ignore the error due to the relax flag.  */
1498                     rc = 0;
1499                     chainlen = -1;
1500                   }
1501               }
1502           }
1503         if (rc)
1504           goto leave;
1505         if (chainlen >= 0 && depth > chainlen)
1506           {
1507             do_list (1, listmode, listfp,
1508                      _("certificate chain longer than allowed by CA (%d)"),
1509                      chainlen);
1510             rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
1511             goto leave;
1512           }
1513       }
1514
1515       /* Is the certificate allowed to sign other certificates. */
1516       if (!listmode)
1517         {
1518           rc = gpgsm_cert_use_cert_p (issuer_cert);
1519           if (rc)
1520             {
1521               char numbuf[50];
1522               sprintf (numbuf, "%d", rc);
1523               gpgsm_status2 (ctrl, STATUS_ERROR, "certcert.issuer.keyusage",
1524                              numbuf, NULL);
1525               goto leave;
1526             }
1527         }
1528
1529       /* Check for revocations etc.  Note that for a root certificate
1530          this test is done a second time later. This should eventually
1531          be fixed. */
1532       if ((flags & VALIDATE_FLAG_NO_DIRMNGR))
1533         rc = 0;
1534       else if (is_root && (opt.no_trusted_cert_crl_check
1535                            || (!istrusted_rc && rootca_flags->relax)))
1536         rc = 0; 
1537       else
1538         rc = is_cert_still_valid (ctrl, 
1539                                   (flags & VALIDATE_FLAG_CHAIN_MODEL),
1540                                   listmode, listfp,
1541                                   subject_cert, issuer_cert,
1542                                   &any_revoked, &any_no_crl, &any_crl_too_old);
1543       if (rc)
1544         goto leave;
1545
1546
1547       if (opt.verbose && !listmode)
1548         log_info (depth == 0 ? _("certificate is good\n") :
1549                   !is_root   ? _("intermediate certificate is good\n") :
1550                   /* other */  _("root certificate is good\n"));
1551
1552       /* Under the chain model the next check time is the creation
1553          time of the subject certificate.  */
1554       if ( (flags & VALIDATE_FLAG_CHAIN_MODEL) )
1555         {
1556           rc = ksba_cert_get_validity (subject_cert, 0, check_time);
1557           if (rc)
1558             {
1559               /* That will never happen as we have already checked
1560                  this above.  */
1561               BUG ();
1562             }
1563         }
1564
1565       /* For the next round the current issuer becomes the new subject.  */
1566       keydb_search_reset (kh);
1567       ksba_cert_release (subject_cert);
1568       subject_cert = issuer_cert;
1569       issuer_cert = NULL;
1570       depth++;
1571     } /* End chain traversal. */
1572
1573   if (!listmode)
1574     {
1575       if (opt.no_policy_check)
1576         log_info ("policies not checked due to %s option\n",
1577                   "--disable-policy-checks");
1578       if (opt.no_crl_check && !ctrl->use_ocsp)
1579         log_info ("CRLs not checked due to %s option\n",
1580                   "--disable-crl-checks");
1581     }
1582
1583   if (!rc)
1584     { /* If we encountered an error somewhere during the checks, set
1585          the error code to the most critical one */
1586       if (any_revoked)
1587         rc = gpg_error (GPG_ERR_CERT_REVOKED);
1588       else if (any_expired)
1589         rc = gpg_error (GPG_ERR_CERT_EXPIRED);
1590       else if (any_no_crl)
1591         rc = gpg_error (GPG_ERR_NO_CRL_KNOWN);
1592       else if (any_crl_too_old)
1593         rc = gpg_error (GPG_ERR_CRL_TOO_OLD);
1594       else if (any_no_policy_match)
1595         rc = gpg_error (GPG_ERR_NO_POLICY_MATCH);
1596     }
1597   
1598  leave:
1599   /* If we have traversed a complete chain up to the root we will
1600      reset the ephemeral flag for all these certificates.  This is done
1601      regardless of any error because those errors may only be
1602      transient. */
1603   if (chain && chain->is_root)
1604     {
1605       gpg_error_t err;
1606       chain_item_t ci;
1607       
1608       for (ci = chain; ci; ci = ci->next)
1609         {
1610           /* Note that it is possible for the last certificate in the
1611              chain (i.e. our target certificate) that it has not yet
1612              been stored in the keybox and thus the flag can't be set.
1613              We ignore this error becuase it will later be stored
1614              anyway.  */
1615           err = keydb_set_cert_flags (ci->cert, 1, KEYBOX_FLAG_BLOB, 0,
1616                                       KEYBOX_FLAG_BLOB_EPHEMERAL, 0);
1617           if (!ci->next && gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1618             ;
1619           else if (err)
1620             log_error ("clearing ephemeral flag failed: %s\n",
1621                        gpg_strerror (err)); 
1622         }
1623     }
1624
1625   /* If we have figured something about the qualified signature
1626      capability of the certificate under question, store the result as
1627      user data in all certificates of the chain.  We do this even if the
1628      validation itself failed.  */
1629   if (is_qualified != -1)
1630     {
1631       gpg_error_t err;
1632       chain_item_t ci;
1633       char buf[1];
1634
1635       buf[0] = !!is_qualified;
1636       
1637       for (ci = chain; ci; ci = ci->next)
1638         {
1639           err = ksba_cert_set_user_data (ci->cert, "is_qualified", buf, 1);
1640           if (err)
1641             {
1642               log_error ("set_user_data(is_qualified) failed: %s\n",
1643                          gpg_strerror (err)); 
1644               if (!rc)
1645                 rc = err;
1646             }
1647         }
1648     }
1649
1650   /* If auditing has been enabled, record what is in the chain.  */
1651   if (ctrl->audit)
1652     {
1653       chain_item_t ci;
1654
1655       audit_log (ctrl->audit, AUDIT_CHAIN_BEGIN);
1656       for (ci = chain; ci; ci = ci->next)
1657         {
1658           audit_log_cert (ctrl->audit,
1659                           ci->is_root? AUDIT_CHAIN_ROOTCERT : AUDIT_CHAIN_CERT,
1660                           ci->cert, 0);
1661         }
1662       audit_log (ctrl->audit, AUDIT_CHAIN_END);
1663     }
1664
1665   if (r_exptime)
1666     gnupg_copy_time (r_exptime, exptime);
1667   xfree (issuer);
1668   xfree (subject);
1669   keydb_release (kh); 
1670   while (chain)
1671     {
1672       chain_item_t ci_next = chain->next;
1673       ksba_cert_release (chain->cert);
1674       xfree (chain);
1675       chain = ci_next;
1676     }
1677   ksba_cert_release (issuer_cert);
1678   ksba_cert_release (subject_cert);
1679   return rc;
1680 }
1681
1682
1683 /* Validate a certificate chain.  For a description see
1684    do_validate_chain.  This function is a wrapper to handle a root
1685    certificate with the chain_model flag set.  If RETFLAGS is not
1686    NULL, flags indicating now the verification was done are stored
1687    there.  The only defined flag for RETFLAGS is
1688    VALIDATE_FLAG_CHAIN_MODEL.
1689
1690    If you are verifying a signature you should set CHECKTIME to the
1691    creation time of the signature.  If your are verifying a
1692    certificate, set it nil (i.e. the empty string).  If the creation
1693    date of the signature is not known use the special date
1694    "19700101T000000" which is treated in a special way here. */
1695 int
1696 gpgsm_validate_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t checktime,
1697                       ksba_isotime_t r_exptime,
1698                       int listmode, estream_t listfp, unsigned int flags,
1699                       unsigned int *retflags)
1700 {
1701   int rc;
1702   struct rootca_flags_s rootca_flags;
1703   unsigned int dummy_retflags;
1704
1705   if (!retflags)
1706     retflags = &dummy_retflags;
1707
1708   if (ctrl->validation_model == 1)
1709     flags |= VALIDATE_FLAG_CHAIN_MODEL;
1710
1711   *retflags = (flags & VALIDATE_FLAG_CHAIN_MODEL);
1712   memset (&rootca_flags, 0, sizeof rootca_flags);
1713
1714   rc = do_validate_chain (ctrl, cert, checktime, 
1715                           r_exptime, listmode, listfp, flags,
1716                           &rootca_flags);
1717   if (gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED
1718       && !(flags & VALIDATE_FLAG_CHAIN_MODEL)
1719       && (rootca_flags.valid && rootca_flags.chain_model))
1720     {
1721       do_list (0, listmode, listfp, _("switching to chain model"));
1722       rc = do_validate_chain (ctrl, cert, checktime,
1723                               r_exptime, listmode, listfp, 
1724                               (flags |= VALIDATE_FLAG_CHAIN_MODEL),
1725                               &rootca_flags);
1726       *retflags |= VALIDATE_FLAG_CHAIN_MODEL;
1727     }
1728
1729   if (opt.verbose)
1730     do_list (0, listmode, listfp, _("validation model used: %s"), 
1731              (*retflags & VALIDATE_FLAG_CHAIN_MODEL)?
1732              _("chain"):_("shell"));
1733   
1734   return rc;
1735 }
1736
1737
1738 /* Check that the given certificate is valid but DO NOT check any
1739    constraints.  We assume that the issuers certificate is already in
1740    the DB and that this one is valid; which it should be because it
1741    has been checked using this function. */
1742 int
1743 gpgsm_basic_cert_check (ctrl_t ctrl, ksba_cert_t cert)
1744 {
1745   int rc = 0;
1746   char *issuer = NULL;
1747   char *subject = NULL;
1748   KEYDB_HANDLE kh;
1749   ksba_cert_t issuer_cert = NULL;
1750   
1751   if (opt.no_chain_validation)
1752     {
1753       log_info ("WARNING: bypassing basic certificate checks\n");
1754       return 0;
1755     }
1756
1757   kh = keydb_new (0);
1758   if (!kh)
1759     {
1760       log_error (_("failed to allocated keyDB handle\n"));
1761       rc = gpg_error (GPG_ERR_GENERAL);
1762       goto leave;
1763     }
1764
1765   issuer = ksba_cert_get_issuer (cert, 0);
1766   subject = ksba_cert_get_subject (cert, 0);
1767   if (!issuer)
1768     {
1769       log_error ("no issuer found in certificate\n");
1770       rc = gpg_error (GPG_ERR_BAD_CERT);
1771       goto leave;
1772     }
1773
1774   if (subject && !strcmp (issuer, subject))
1775     {
1776       rc = gpgsm_check_cert_sig (cert, cert);
1777       if (rc)
1778         {
1779           log_error ("self-signed certificate has a BAD signature: %s\n",
1780                      gpg_strerror (rc));
1781           if (DBG_X509)
1782             {
1783               gpgsm_dump_cert ("self-signing cert", cert);
1784             }
1785           rc = gpg_error (GPG_ERR_BAD_CERT);
1786           goto leave;
1787         }
1788     }
1789   else
1790     {
1791       /* Find the next cert up the tree. */
1792       keydb_search_reset (kh);
1793       rc = find_up (ctrl, kh, cert, issuer, 0);
1794       if (rc)
1795         {
1796           if (rc == -1)
1797             {
1798               log_info ("issuer certificate (#/");
1799               gpgsm_dump_string (issuer);
1800               log_printf (") not found\n");
1801             }
1802           else
1803             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
1804           rc = gpg_error (GPG_ERR_MISSING_CERT);
1805           goto leave;
1806         }
1807       
1808       ksba_cert_release (issuer_cert); issuer_cert = NULL;
1809       rc = keydb_get_cert (kh, &issuer_cert);
1810       if (rc)
1811         {
1812           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
1813           rc = gpg_error (GPG_ERR_GENERAL);
1814           goto leave;
1815         }
1816
1817       rc = gpgsm_check_cert_sig (issuer_cert, cert);
1818       if (rc)
1819         {
1820           log_error ("certificate has a BAD signature: %s\n",
1821                      gpg_strerror (rc));
1822           if (DBG_X509)
1823             {
1824               gpgsm_dump_cert ("signing issuer", issuer_cert);
1825               gpgsm_dump_cert ("signed subject", cert);
1826             }
1827           rc = gpg_error (GPG_ERR_BAD_CERT);
1828           goto leave;
1829         }
1830       if (opt.verbose)
1831         log_info (_("certificate is good\n"));
1832     }
1833
1834  leave:
1835   xfree (issuer);
1836   xfree (subject);
1837   keydb_release (kh); 
1838   ksba_cert_release (issuer_cert);
1839   return rc;
1840 }
1841
1842
1843
1844 /* Check whether the certificate CERT has been issued by the German
1845    authority for qualified signature.  They do not set the
1846    basicConstraints and thus we need this workaround.  It works by
1847    looking up the root certificate and checking whether that one is
1848    listed as a qualified certificate for Germany. 
1849
1850    We also try to cache this data but as long as don't keep a
1851    reference to the certificate this won't be used.
1852
1853    Returns: True if CERT is a RegTP issued CA cert (i.e. the root
1854    certificate itself or one of the CAs).  In that case CHAINLEN will
1855    receive the length of the chain which is either 0 or 1.
1856 */
1857 static int
1858 get_regtp_ca_info (ctrl_t ctrl, ksba_cert_t cert, int *chainlen)
1859 {
1860   gpg_error_t err;
1861   ksba_cert_t next;
1862   int rc = 0;
1863   int i, depth;
1864   char country[3];
1865   ksba_cert_t array[4];
1866   char buf[2];
1867   size_t buflen;
1868   int dummy_chainlen;
1869
1870   if (!chainlen)
1871     chainlen = &dummy_chainlen;
1872
1873   *chainlen = 0;
1874   err = ksba_cert_get_user_data (cert, "regtp_ca_chainlen", 
1875                                  &buf, sizeof (buf), &buflen);
1876   if (!err)
1877     {
1878       /* Got info. */
1879       if (buflen < 2 || !*buf)
1880         return 0; /* Nothing found. */
1881       *chainlen = buf[1];
1882       return 1; /* This is a regtp CA. */
1883     }
1884   else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1885     {
1886       log_error ("ksba_cert_get_user_data(%s) failed: %s\n",
1887                  "regtp_ca_chainlen", gpg_strerror (err));
1888       return 0; /* Nothing found.  */
1889     }
1890
1891   /* Need to gather the info.  This requires to walk up the chain
1892      until we have found the root.  Because we are only interested in
1893      German Bundesnetzagentur (former RegTP) derived certificates 3
1894      levels are enough.  (The German signature law demands a 3 tier
1895      hierachy; thus there is only one CA between the EE and the Root
1896      CA.)  */
1897   memset (&array, 0, sizeof array);
1898
1899   depth = 0;
1900   ksba_cert_ref (cert);
1901   array[depth++] = cert;
1902   ksba_cert_ref (cert);
1903   while (depth < DIM(array) && !(rc=gpgsm_walk_cert_chain (ctrl, cert, &next)))
1904     {
1905       ksba_cert_release (cert);
1906       ksba_cert_ref (next);
1907       array[depth++] = next;
1908       cert = next;
1909     }
1910   ksba_cert_release (cert);
1911   if (rc != -1 || !depth || depth == DIM(array) )
1912     {
1913       /* We did not reached the root. */
1914       goto leave;
1915     }
1916
1917   /* If this is a German signature law issued certificate, we store
1918      additional additional information. */
1919   if (!gpgsm_is_in_qualified_list (NULL, array[depth-1], country)
1920       && !strcmp (country, "de"))
1921     {
1922       /* Setting the pathlen for the root CA and the CA flag for the
1923          next one is all what we need to do. */
1924       err = ksba_cert_set_user_data (array[depth-1], "regtp_ca_chainlen",
1925                                      "\x01\x01", 2);
1926       if (!err && depth > 1)
1927         err = ksba_cert_set_user_data (array[depth-2], "regtp_ca_chainlen",
1928                                        "\x01\x00", 2);
1929       if (err)
1930         log_error ("ksba_set_user_data(%s) failed: %s\n",
1931                    "regtp_ca_chainlen", gpg_strerror (err)); 
1932       for (i=0; i < depth; i++)
1933         ksba_cert_release (array[i]);
1934       *chainlen = (depth>1? 0:1);
1935       return 1;
1936     }
1937
1938  leave:
1939   /* Nothing special with this certificate. Mark the target
1940      certificate anyway to avoid duplicate lookups. */ 
1941   err = ksba_cert_set_user_data (cert, "regtp_ca_chainlen", "", 1);
1942   if (err)
1943     log_error ("ksba_set_user_data(%s) failed: %s\n",
1944                "regtp_ca_chainlen", gpg_strerror (err)); 
1945   for (i=0; i < depth; i++)
1946     ksba_cert_release (array[i]);
1947   return 0;
1948 }