Support DSA2.
[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           audit_log_cert (ctrl->audit, AUDIT_ROOT_TRUSTED,
1131                           subject_cert, istrusted_rc);
1132           /* If the chain model extended attribute is used, make sure
1133              that our chain model flag is set. */
1134           if (has_validation_model_chain (subject_cert, listmode, listfp))
1135             rootca_flags->chain_model = 1;
1136         }
1137       
1138
1139       /* Check the validity period. */
1140       if ( (flags & VALIDATE_FLAG_CHAIN_MODEL) )
1141         rc = check_validity_period_cm (current_time, check_time, subject_cert,
1142                                        exptime, listmode, listfp,
1143                                        (depth && is_root)? -1: depth);
1144       else
1145         rc = check_validity_period (current_time, subject_cert,
1146                                     exptime, listmode, listfp,
1147                                     (depth && is_root)? -1: depth);
1148       if (gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED)
1149         {
1150           any_expired = 1;
1151           rc = 0;
1152         }
1153       else if (rc)
1154         goto leave;
1155         
1156
1157       /* Assert that we understand all critical extensions. */
1158       rc = unknown_criticals (subject_cert, listmode, listfp);
1159       if (rc)
1160         goto leave;
1161
1162       /* Do a policy check. */
1163       if (!opt.no_policy_check)
1164         {
1165           rc = check_cert_policy (subject_cert, listmode, listfp);
1166           if (gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH)
1167             {
1168               any_no_policy_match = 1;
1169               rc = 1;
1170             }
1171           else if (rc)
1172             goto leave;
1173         }
1174
1175
1176       /* If this is the root certificate we are at the end of the chain.  */
1177       if (is_root)
1178         { 
1179           if (!istrusted_rc)
1180             ; /* No need to check the certificate for a trusted one. */
1181           else if (gpgsm_check_cert_sig (subject_cert, subject_cert) )
1182             {
1183               /* We only check the signature if the certificate is not
1184                  trusted for better diagnostics. */
1185               do_list (1, listmode, listfp,
1186                        _("self-signed certificate has a BAD signature"));
1187               if (DBG_X509)
1188                 {
1189                   gpgsm_dump_cert ("self-signing cert", subject_cert);
1190                 }
1191               rc = gpg_error (depth? GPG_ERR_BAD_CERT_CHAIN
1192                                    : GPG_ERR_BAD_CERT);
1193               goto leave;
1194             }
1195           if (!rootca_flags->relax)
1196             {
1197               rc = allowed_ca (subject_cert, NULL, listmode, listfp);
1198               if (rc)
1199                 goto leave;
1200             }
1201               
1202           
1203           /* Set the flag for qualified signatures.  This flag is
1204              deduced from a list of root certificates allowed for
1205              qualified signatures. */
1206           if (is_qualified == -1)
1207             {
1208               gpg_error_t err;
1209               size_t buflen;
1210               char buf[1];
1211               
1212               if (!ksba_cert_get_user_data (cert, "is_qualified", 
1213                                             &buf, sizeof (buf),
1214                                             &buflen) && buflen)
1215                 {
1216                   /* We already checked this for this certificate,
1217                      thus we simply take it from the user data. */
1218                   is_qualified = !!*buf;
1219                 }    
1220               else
1221                 {
1222                   /* Need to consult the list of root certificates for
1223                      qualified signatures. */
1224                   err = gpgsm_is_in_qualified_list (ctrl, subject_cert, NULL);
1225                   if (!err)
1226                     is_qualified = 1;
1227                   else if ( gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1228                     is_qualified = 0;
1229                   else
1230                     log_error ("checking the list of qualified "
1231                                "root certificates failed: %s\n",
1232                                gpg_strerror (err));
1233                   if ( is_qualified != -1 )
1234                     {
1235                       /* Cache the result but don't care too much
1236                          about an error. */
1237                       buf[0] = !!is_qualified;
1238                       err = ksba_cert_set_user_data (subject_cert,
1239                                                      "is_qualified", buf, 1);
1240                       if (err)
1241                         log_error ("set_user_data(is_qualified) failed: %s\n",
1242                                    gpg_strerror (err)); 
1243                     }
1244                 }
1245             }
1246
1247
1248           /* Act on the check for a trusted root certificates. */
1249           rc = istrusted_rc;
1250           if (!rc)
1251             ;
1252           else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
1253             {
1254               do_list (0, listmode, listfp, 
1255                        _("root certificate is not marked trusted"));
1256               /* If we already figured out that the certificate is
1257                  expired it does not make much sense to ask the user
1258                  whether we wants to trust the root certificate.  We
1259                  should do this only if the certificate under question
1260                  will then be usable.  */
1261               if ( !any_expired
1262                    && (!listmode || !already_asked_marktrusted (subject_cert))
1263                    && ask_marktrusted (ctrl, subject_cert, listmode) )
1264                 rc = 0;
1265             }
1266           else 
1267             {
1268               log_error (_("checking the trust list failed: %s\n"),
1269                          gpg_strerror (rc));
1270             }
1271           
1272           if (rc)
1273             goto leave;
1274
1275           /* Check for revocations etc. */
1276           if ((flags & VALIDATE_FLAG_NO_DIRMNGR))
1277             ;
1278           else if (opt.no_trusted_cert_crl_check || rootca_flags->relax)
1279             ; 
1280           else
1281             rc = is_cert_still_valid (ctrl, 
1282                                       (flags & VALIDATE_FLAG_CHAIN_MODEL),
1283                                       listmode, listfp,
1284                                       subject_cert, subject_cert,
1285                                       &any_revoked, &any_no_crl,
1286                                       &any_crl_too_old);
1287           if (rc)
1288             goto leave;
1289
1290           break;  /* Okay: a self-signed certicate is an end-point. */
1291         } /* End is_root.  */
1292
1293       
1294       /* Take care that the chain does not get too long. */
1295       if ((depth+1) > maxdepth)
1296         {
1297           do_list (1, listmode, listfp, _("certificate chain too long\n"));
1298           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
1299           goto leave;
1300         }
1301
1302       /* Find the next cert up the tree. */
1303       keydb_search_reset (kh);
1304       rc = find_up (kh, subject_cert, issuer, 0);
1305       if (rc)
1306         {
1307           if (rc == -1)
1308             {
1309               do_list (0, listmode, listfp, _("issuer certificate not found"));
1310               if (!listmode)
1311                 {
1312                   log_info ("issuer certificate: #/");
1313                   gpgsm_dump_string (issuer);
1314                   log_printf ("\n");
1315                 }
1316             }
1317           else
1318             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
1319           rc = gpg_error (GPG_ERR_MISSING_CERT);
1320           goto leave;
1321         }
1322
1323       ksba_cert_release (issuer_cert); issuer_cert = NULL;
1324       rc = keydb_get_cert (kh, &issuer_cert);
1325       if (rc)
1326         {
1327           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
1328           rc = gpg_error (GPG_ERR_GENERAL);
1329           goto leave;
1330         }
1331
1332     try_another_cert:
1333       if (DBG_X509)
1334         {
1335           log_debug ("got issuer's certificate:\n");
1336           gpgsm_dump_cert ("issuer", issuer_cert);
1337         }
1338
1339       rc = gpgsm_check_cert_sig (issuer_cert, subject_cert);
1340       if (rc)
1341         {
1342           do_list (0, listmode, listfp, _("certificate has a BAD signature"));
1343           if (DBG_X509)
1344             {
1345               gpgsm_dump_cert ("signing issuer", issuer_cert);
1346               gpgsm_dump_cert ("signed subject", subject_cert);
1347             }
1348           if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
1349             {
1350               /* We now try to find other issuer certificates which
1351                  might have been used.  This is required because some
1352                  CAs are reusing the issuer and subject DN for new
1353                  root certificates. */
1354               /* FIXME: Do this only if we don't have an
1355                  AKI.keyIdentifier */
1356               rc = find_up (kh, subject_cert, issuer, 1);
1357               if (!rc)
1358                 {
1359                   ksba_cert_t tmp_cert;
1360
1361                   rc = keydb_get_cert (kh, &tmp_cert);
1362                   if (rc || !compare_certs (issuer_cert, tmp_cert))
1363                     {
1364                       /* The find next did not work or returned an
1365                          identical certificate.  We better stop here
1366                          to avoid infinite checks. */
1367                       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
1368                       ksba_cert_release (tmp_cert);
1369                     }
1370                   else
1371                     {
1372                       do_list (0, listmode, listfp,
1373                                _("found another possible matching "
1374                                  "CA certificate - trying again"));
1375                       ksba_cert_release (issuer_cert); 
1376                       issuer_cert = tmp_cert;
1377                       goto try_another_cert;
1378                     }
1379                 }
1380             }
1381
1382           /* We give a more descriptive error code than the one
1383              returned from the signature checking. */
1384           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
1385           goto leave;
1386         }
1387
1388       is_root = gpgsm_is_root_cert (issuer_cert);
1389       istrusted_rc = -1;
1390
1391
1392       /* Check that a CA is allowed to issue certificates. */
1393       {
1394         int chainlen;
1395
1396         rc = allowed_ca (issuer_cert, &chainlen, listmode, listfp);
1397         if (rc)
1398           {
1399             /* Not allowed.  Check whether this is a trusted root
1400                certificate and whether we allow special exceptions.
1401                We could carry the result of the test over to the
1402                regular root check at the top of the loop but for
1403                clarity we won't do that.  Given that the majority of
1404                certificates carry proper BasicContraints our way of
1405                overriding an error in the way is justified for
1406                performance reasons. */
1407             if (is_root)
1408               {
1409                 istrusted_rc = gpgsm_agent_istrusted (ctrl, issuer_cert,
1410                                                       rootca_flags);
1411                 if (!istrusted_rc && rootca_flags->relax)
1412                   {
1413                     /* Ignore the error due to the relax flag.  */
1414                     rc = 0;
1415                     chainlen = -1;
1416                   }
1417               }
1418           }
1419         if (rc)
1420           goto leave;
1421         if (chainlen >= 0 && depth > chainlen)
1422           {
1423             do_list (1, listmode, listfp,
1424                      _("certificate chain longer than allowed by CA (%d)"),
1425                      chainlen);
1426             rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
1427             goto leave;
1428           }
1429       }
1430
1431       /* Is the certificate allowed to sign other certificates. */
1432       if (!listmode)
1433         {
1434           rc = gpgsm_cert_use_cert_p (issuer_cert);
1435           if (rc)
1436             {
1437               char numbuf[50];
1438               sprintf (numbuf, "%d", rc);
1439               gpgsm_status2 (ctrl, STATUS_ERROR, "certcert.issuer.keyusage",
1440                              numbuf, NULL);
1441               goto leave;
1442             }
1443         }
1444
1445       /* Check for revocations etc.  Note that for a root certificate
1446          this test is done a second time later. This should eventually
1447          be fixed. */
1448       if ((flags & VALIDATE_FLAG_NO_DIRMNGR))
1449         rc = 0;
1450       else if (is_root && (opt.no_trusted_cert_crl_check
1451                            || (!istrusted_rc && rootca_flags->relax)))
1452         rc = 0; 
1453       else
1454         rc = is_cert_still_valid (ctrl, 
1455                                   (flags & VALIDATE_FLAG_CHAIN_MODEL),
1456                                   listmode, listfp,
1457                                   subject_cert, issuer_cert,
1458                                   &any_revoked, &any_no_crl, &any_crl_too_old);
1459       if (rc)
1460         goto leave;
1461
1462
1463       if (opt.verbose && !listmode)
1464         log_info (depth == 0 ? _("certificate is good\n") :
1465                   !is_root   ? _("intermediate certificate is good\n") :
1466                   /* other */  _("root certificate is good\n"));
1467
1468       /* Under the chain model the next check time is the creation
1469          time of the subject certificate.  */
1470       if ( (flags & VALIDATE_FLAG_CHAIN_MODEL) )
1471         {
1472           rc = ksba_cert_get_validity (subject_cert, 0, check_time);
1473           if (rc)
1474             {
1475               /* That will never happen as we have already checked
1476                  this above.  */
1477               BUG ();
1478             }
1479         }
1480
1481       /* For the next round the current issuer becomes the new subject.  */
1482       keydb_search_reset (kh);
1483       ksba_cert_release (subject_cert);
1484       subject_cert = issuer_cert;
1485       issuer_cert = NULL;
1486       depth++;
1487     } /* End chain traversal. */
1488
1489   if (!listmode)
1490     {
1491       if (opt.no_policy_check)
1492         log_info ("policies not checked due to %s option\n",
1493                   "--disable-policy-checks");
1494       if (opt.no_crl_check && !ctrl->use_ocsp)
1495         log_info ("CRLs not checked due to %s option\n",
1496                   "--disable-crl-checks");
1497     }
1498
1499   if (!rc)
1500     { /* If we encountered an error somewhere during the checks, set
1501          the error code to the most critical one */
1502       if (any_revoked)
1503         rc = gpg_error (GPG_ERR_CERT_REVOKED);
1504       else if (any_expired)
1505         rc = gpg_error (GPG_ERR_CERT_EXPIRED);
1506       else if (any_no_crl)
1507         rc = gpg_error (GPG_ERR_NO_CRL_KNOWN);
1508       else if (any_crl_too_old)
1509         rc = gpg_error (GPG_ERR_CRL_TOO_OLD);
1510       else if (any_no_policy_match)
1511         rc = gpg_error (GPG_ERR_NO_POLICY_MATCH);
1512     }
1513   
1514  leave:
1515   /* If we have traversed a complete chain up to the root we will
1516      reset the ephemeral flag for all these certificates.  This is done
1517      regardless of any error because those errors may only be
1518      transient. */
1519   if (chain && chain->is_root)
1520     {
1521       gpg_error_t err;
1522       chain_item_t ci;
1523       
1524       for (ci = chain; ci; ci = ci->next)
1525         {
1526           /* Note that it is possible for the last certificate in the
1527              chain (i.e. our target certificate) that it has not yet
1528              been stored in the keybox and thus the flag can't be set.
1529              We ignore this error becuase it will later be stored
1530              anyway.  */
1531           err = keydb_set_cert_flags (ci->cert, 1, KEYBOX_FLAG_BLOB, 0,
1532                                       KEYBOX_FLAG_BLOB_EPHEMERAL, 0);
1533           if (!ci->next && gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1534             ;
1535           else if (err)
1536             log_error ("clearing ephemeral flag failed: %s\n",
1537                        gpg_strerror (err)); 
1538         }
1539     }
1540
1541   /* If we have figured something about the qualified signature
1542      capability of the certificate under question, store the result as
1543      user data in all certificates of the chain.  We do this even if the
1544      validation itself failed.  */
1545   if (is_qualified != -1)
1546     {
1547       gpg_error_t err;
1548       chain_item_t ci;
1549       char buf[1];
1550
1551       buf[0] = !!is_qualified;
1552       
1553       for (ci = chain; ci; ci = ci->next)
1554         {
1555           err = ksba_cert_set_user_data (ci->cert, "is_qualified", buf, 1);
1556           if (err)
1557             {
1558               log_error ("set_user_data(is_qualified) failed: %s\n",
1559                          gpg_strerror (err)); 
1560               if (!rc)
1561                 rc = err;
1562             }
1563         }
1564     }
1565
1566   /* If auditing has been enabled, record what is in the chain.  */
1567   if (ctrl->audit)
1568     {
1569       chain_item_t ci;
1570
1571       audit_log (ctrl->audit, AUDIT_CHAIN_BEGIN);
1572       for (ci = chain; ci; ci = ci->next)
1573         {
1574           audit_log_cert (ctrl->audit,
1575                           ci->is_root? AUDIT_CHAIN_ROOTCERT : AUDIT_CHAIN_CERT,
1576                           ci->cert, 0);
1577         }
1578       audit_log (ctrl->audit, AUDIT_CHAIN_END);
1579     }
1580
1581   if (r_exptime)
1582     gnupg_copy_time (r_exptime, exptime);
1583   xfree (issuer);
1584   xfree (subject);
1585   keydb_release (kh); 
1586   while (chain)
1587     {
1588       chain_item_t ci_next = chain->next;
1589       ksba_cert_release (chain->cert);
1590       xfree (chain);
1591       chain = ci_next;
1592     }
1593   ksba_cert_release (issuer_cert);
1594   ksba_cert_release (subject_cert);
1595   return rc;
1596 }
1597
1598
1599 /* Validate a certificate chain.  For a description see
1600    do_validate_chain.  This function is a wrapper to handle a root
1601    certificate with the chain_model flag set.  If RETFLAGS is not
1602    NULL, flags indicating now the verification was done are stored
1603    there.  The only defined flag for RETFLAGS is
1604    VALIDATE_FLAG_CHAIN_MODEL.
1605
1606    If you are verifying a signature you should set CHECKTIME to the
1607    creation time of the signature.  If your are verifying a
1608    certificate, set it nil (i.e. the empty string).  If the creation
1609    date of the signature is not known use the special date
1610    "19700101T000000" which is treated in a special way here. */
1611 int
1612 gpgsm_validate_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t checktime,
1613                       ksba_isotime_t r_exptime,
1614                       int listmode, estream_t listfp, unsigned int flags,
1615                       unsigned int *retflags)
1616 {
1617   int rc;
1618   struct rootca_flags_s rootca_flags;
1619   unsigned int dummy_retflags;
1620
1621   if (!retflags)
1622     retflags = &dummy_retflags;
1623
1624   if (ctrl->validation_model == 1)
1625     flags |= VALIDATE_FLAG_CHAIN_MODEL;
1626
1627   *retflags = (flags & VALIDATE_FLAG_CHAIN_MODEL);
1628   memset (&rootca_flags, 0, sizeof rootca_flags);
1629
1630   rc = do_validate_chain (ctrl, cert, checktime, 
1631                           r_exptime, listmode, listfp, flags,
1632                           &rootca_flags);
1633   if (gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED
1634       && !(flags & VALIDATE_FLAG_CHAIN_MODEL)
1635       && (rootca_flags.valid && rootca_flags.chain_model))
1636     {
1637       do_list (0, listmode, listfp, _("switching to chain model"));
1638       rc = do_validate_chain (ctrl, cert, checktime,
1639                               r_exptime, listmode, listfp, 
1640                               (flags |= VALIDATE_FLAG_CHAIN_MODEL),
1641                               &rootca_flags);
1642       *retflags |= VALIDATE_FLAG_CHAIN_MODEL;
1643     }
1644
1645   if (opt.verbose)
1646     do_list (0, listmode, listfp, _("validation model used: %s"), 
1647              (*retflags & VALIDATE_FLAG_CHAIN_MODEL)?
1648              _("chain"):_("shell"));
1649   
1650   return rc;
1651 }
1652
1653
1654 /* Check that the given certificate is valid but DO NOT check any
1655    constraints.  We assume that the issuers certificate is already in
1656    the DB and that this one is valid; which it should be because it
1657    has been checked using this function. */
1658 int
1659 gpgsm_basic_cert_check (ksba_cert_t cert)
1660 {
1661   int rc = 0;
1662   char *issuer = NULL;
1663   char *subject = NULL;
1664   KEYDB_HANDLE kh;
1665   ksba_cert_t issuer_cert = NULL;
1666   
1667   if (opt.no_chain_validation)
1668     {
1669       log_info ("WARNING: bypassing basic certificate checks\n");
1670       return 0;
1671     }
1672
1673   kh = keydb_new (0);
1674   if (!kh)
1675     {
1676       log_error (_("failed to allocated keyDB handle\n"));
1677       rc = gpg_error (GPG_ERR_GENERAL);
1678       goto leave;
1679     }
1680
1681   issuer = ksba_cert_get_issuer (cert, 0);
1682   subject = ksba_cert_get_subject (cert, 0);
1683   if (!issuer)
1684     {
1685       log_error ("no issuer found in certificate\n");
1686       rc = gpg_error (GPG_ERR_BAD_CERT);
1687       goto leave;
1688     }
1689
1690   if (subject && !strcmp (issuer, subject))
1691     {
1692       rc = gpgsm_check_cert_sig (cert, cert);
1693       if (rc)
1694         {
1695           log_error ("self-signed certificate has a BAD signature: %s\n",
1696                      gpg_strerror (rc));
1697           if (DBG_X509)
1698             {
1699               gpgsm_dump_cert ("self-signing cert", cert);
1700             }
1701           rc = gpg_error (GPG_ERR_BAD_CERT);
1702           goto leave;
1703         }
1704     }
1705   else
1706     {
1707       /* Find the next cert up the tree. */
1708       keydb_search_reset (kh);
1709       rc = find_up (kh, cert, issuer, 0);
1710       if (rc)
1711         {
1712           if (rc == -1)
1713             {
1714               log_info ("issuer certificate (#/");
1715               gpgsm_dump_string (issuer);
1716               log_printf (") not found\n");
1717             }
1718           else
1719             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
1720           rc = gpg_error (GPG_ERR_MISSING_CERT);
1721           goto leave;
1722         }
1723       
1724       ksba_cert_release (issuer_cert); issuer_cert = NULL;
1725       rc = keydb_get_cert (kh, &issuer_cert);
1726       if (rc)
1727         {
1728           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
1729           rc = gpg_error (GPG_ERR_GENERAL);
1730           goto leave;
1731         }
1732
1733       rc = gpgsm_check_cert_sig (issuer_cert, cert);
1734       if (rc)
1735         {
1736           log_error ("certificate has a BAD signature: %s\n",
1737                      gpg_strerror (rc));
1738           if (DBG_X509)
1739             {
1740               gpgsm_dump_cert ("signing issuer", issuer_cert);
1741               gpgsm_dump_cert ("signed subject", cert);
1742             }
1743           rc = gpg_error (GPG_ERR_BAD_CERT);
1744           goto leave;
1745         }
1746       if (opt.verbose)
1747         log_info (_("certificate is good\n"));
1748     }
1749
1750  leave:
1751   xfree (issuer);
1752   xfree (subject);
1753   keydb_release (kh); 
1754   ksba_cert_release (issuer_cert);
1755   return rc;
1756 }
1757
1758
1759
1760 /* Check whether the certificate CERT has been issued by the German
1761    authority for qualified signature.  They do not set the
1762    basicConstraints and thus we need this workaround.  It works by
1763    looking up the root certificate and checking whether that one is
1764    listed as a qualified certificate for Germany. 
1765
1766    We also try to cache this data but as long as don't keep a
1767    reference to the certificate this won't be used.
1768
1769    Returns: True if CERT is a RegTP issued CA cert (i.e. the root
1770    certificate itself or one of the CAs).  In that case CHAINLEN will
1771    receive the length of the chain which is either 0 or 1.
1772 */
1773 static int
1774 get_regtp_ca_info (ksba_cert_t cert, int *chainlen)
1775 {
1776   gpg_error_t err;
1777   ksba_cert_t next;
1778   int rc = 0;
1779   int i, depth;
1780   char country[3];
1781   ksba_cert_t array[4];
1782   char buf[2];
1783   size_t buflen;
1784   int dummy_chainlen;
1785
1786   if (!chainlen)
1787     chainlen = &dummy_chainlen;
1788
1789   *chainlen = 0;
1790   err = ksba_cert_get_user_data (cert, "regtp_ca_chainlen", 
1791                                  &buf, sizeof (buf), &buflen);
1792   if (!err)
1793     {
1794       /* Got info. */
1795       if (buflen < 2 || !*buf)
1796         return 0; /* Nothing found. */
1797       *chainlen = buf[1];
1798       return 1; /* This is a regtp CA. */
1799     }
1800   else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1801     {
1802       log_error ("ksba_cert_get_user_data(%s) failed: %s\n",
1803                  "regtp_ca_chainlen", gpg_strerror (err));
1804       return 0; /* Nothing found.  */
1805     }
1806
1807   /* Need to gather the info.  This requires to walk up the chain
1808      until we have found the root.  Because we are only interested in
1809      German Bundesnetzagentur (former RegTP) derived certificates 3
1810      levels are enough.  (The German signature law demands a 3 tier
1811      hierachy; thus there is only one CA between the EE and the Root
1812      CA.)  */
1813   memset (&array, 0, sizeof array);
1814
1815   depth = 0;
1816   ksba_cert_ref (cert);
1817   array[depth++] = cert;
1818   ksba_cert_ref (cert);
1819   while (depth < DIM(array) && !(rc=gpgsm_walk_cert_chain (cert, &next)))
1820     {
1821       ksba_cert_release (cert);
1822       ksba_cert_ref (next);
1823       array[depth++] = next;
1824       cert = next;
1825     }
1826   ksba_cert_release (cert);
1827   if (rc != -1 || !depth || depth == DIM(array) )
1828     {
1829       /* We did not reached the root. */
1830       goto leave;
1831     }
1832
1833   /* If this is a German signature law issued certificate, we store
1834      additional additional information. */
1835   if (!gpgsm_is_in_qualified_list (NULL, array[depth-1], country)
1836       && !strcmp (country, "de"))
1837     {
1838       /* Setting the pathlen for the root CA and the CA flag for the
1839          next one is all what we need to do. */
1840       err = ksba_cert_set_user_data (array[depth-1], "regtp_ca_chainlen",
1841                                      "\x01\x01", 2);
1842       if (!err && depth > 1)
1843         err = ksba_cert_set_user_data (array[depth-2], "regtp_ca_chainlen",
1844                                        "\x01\x00", 2);
1845       if (err)
1846         log_error ("ksba_set_user_data(%s) failed: %s\n",
1847                    "regtp_ca_chainlen", gpg_strerror (err)); 
1848       for (i=0; i < depth; i++)
1849         ksba_cert_release (array[i]);
1850       *chainlen = (depth>1? 0:1);
1851       return 1;
1852     }
1853
1854  leave:
1855   /* Nothing special with this certificate. Mark the target
1856      certificate anyway to avoid duplicate lookups. */ 
1857   err = ksba_cert_set_user_data (cert, "regtp_ca_chainlen", "", 1);
1858   if (err)
1859     log_error ("ksba_set_user_data(%s) failed: %s\n",
1860                "regtp_ca_chainlen", gpg_strerror (err)); 
1861   for (i=0; i < depth; i++)
1862     ksba_cert_release (array[i]);
1863   return 0;
1864 }