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