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