Finished implementation of the "relax" flag.
[gnupg.git] / sm / certchain.c
1 /* certchain.c - certificate chain validation
2  * Copyright (C) 2001, 2002, 2003, 2004, 2005,
3  *               2006 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 2 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, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20  * USA.
21  */
22
23 #include <config.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <unistd.h> 
29 #include <time.h>
30 #include <stdarg.h>
31 #include <assert.h>
32
33 #define JNLIB_NEED_LOG_LOGV /* We need log_logv. */
34
35 #include "gpgsm.h"
36 #include <gcrypt.h>
37 #include <ksba.h>
38
39 #include "keydb.h"
40 #include "../kbx/keybox.h" /* for KEYBOX_FLAG_* */
41 #include "i18n.h"
42
43
44 static int get_regtp_ca_info (ksba_cert_t cert, int *chainlen);
45
46
47
48 /* If LISTMODE is true, print FORMAT using LISTMODE to FP.  If
49    LISTMODE is false, use the string to print an log_info or, if
50    IS_ERROR is true, and log_error. */
51 static void
52 do_list (int is_error, int listmode, FILE *fp, const char *format, ...)
53 {
54   va_list arg_ptr;
55
56   va_start (arg_ptr, format) ;
57   if (listmode)
58     {
59       if (fp)
60         {
61           fputs ("  [", fp);
62           vfprintf (fp, format, arg_ptr);
63           fputs ("]\n", fp);
64         }
65     }
66   else
67     {
68       log_logv (is_error? JNLIB_LOG_ERROR: JNLIB_LOG_INFO, format, arg_ptr);
69       log_printf ("\n");
70     }
71   va_end (arg_ptr);
72 }
73
74 /* Return 0 if A and B are equal. */
75 static int
76 compare_certs (ksba_cert_t a, ksba_cert_t b)
77 {
78   const unsigned char *img_a, *img_b;
79   size_t len_a, len_b;
80
81   img_a = ksba_cert_get_image (a, &len_a);
82   if (!img_a)
83     return 1;
84   img_b = ksba_cert_get_image (b, &len_b);
85   if (!img_b)
86     return 1;
87   return !(len_a == len_b && !memcmp (img_a, img_b, len_a));
88 }
89
90
91 static int
92 unknown_criticals (ksba_cert_t cert, int listmode, FILE *fp)
93 {
94   static const char *known[] = {
95     "2.5.29.15", /* keyUsage */
96     "2.5.29.19", /* basic Constraints */
97     "2.5.29.32", /* certificatePolicies */
98     "2.5.29.37", /* extendedKeyUsage - handled by certlist.c */
99     NULL
100   };
101   int rc = 0, i, idx, crit;
102   const char *oid;
103   gpg_error_t err;
104
105   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
106                                              &oid, &crit, NULL, NULL));idx++)
107     {
108       if (!crit)
109         continue;
110       for (i=0; known[i] && strcmp (known[i],oid); i++)
111         ;
112       if (!known[i])
113         {
114           do_list (1, listmode, fp,
115                    _("critical certificate extension %s is not supported"),
116                    oid);
117           rc = gpg_error (GPG_ERR_UNSUPPORTED_CERT);
118         }
119     }
120   /* We ignore the error codes EOF as well as no-value. The later will
121      occur for certificates with no extensions at all. */
122   if (err
123       && gpg_err_code (err) != GPG_ERR_EOF
124       && gpg_err_code (err) != GPG_ERR_NO_VALUE)
125     rc = err;
126
127   return rc;
128 }
129
130
131 /* Check whether CERT is an allowed certificate.  This requires that
132    CERT matches all requirements for such a CA, i.e. the
133    BasicConstraints extension.  The function returns 0 on success and
134    the awlloed length of the chain at CHAINLEN. */
135 static int
136 allowed_ca (ksba_cert_t cert, int *chainlen, int listmode, FILE *fp)
137 {
138   gpg_error_t err;
139   int flag;
140
141   err = ksba_cert_is_ca (cert, &flag, chainlen);
142   if (err)
143     return err;
144   if (!flag)
145     {
146       if (get_regtp_ca_info (cert, chainlen))
147         {
148           /* Note that dirmngr takes a different way to cope with such
149              certs. */
150           return 0; /* RegTP issued certificate. */
151         }
152
153       do_list (1, listmode, fp,_("issuer certificate is not marked as a CA"));
154       return gpg_error (GPG_ERR_BAD_CA_CERT);
155     }
156   return 0;
157 }
158
159
160 static int
161 check_cert_policy (ksba_cert_t cert, int listmode, FILE *fplist)
162 {
163   gpg_error_t err;
164   char *policies;
165   FILE *fp;
166   int any_critical;
167
168   err = ksba_cert_get_cert_policies (cert, &policies);
169   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
170     return 0; /* no policy given */
171   if (err)
172     return err;
173
174   /* STRING is a line delimited list of certifiate policies as stored
175      in the certificate.  The line itself is colon delimited where the
176      first field is the OID of the policy and the second field either
177      N or C for normal or critical extension */
178
179   if (opt.verbose > 1 && !listmode)
180     log_info ("certificate's policy list: %s\n", policies);
181
182   /* The check is very minimal but won't give false positives */
183   any_critical = !!strstr (policies, ":C");
184
185   if (!opt.policy_file)
186     { 
187       xfree (policies);
188       if (any_critical)
189         {
190           do_list (1, listmode, fplist,
191                    _("critical marked policy without configured policies"));
192           return gpg_error (GPG_ERR_NO_POLICY_MATCH);
193         }
194       return 0;
195     }
196
197   fp = fopen (opt.policy_file, "r");
198   if (!fp)
199     {
200       if (opt.verbose || errno != ENOENT)
201         log_info (_("failed to open `%s': %s\n"),
202                   opt.policy_file, strerror (errno));
203       xfree (policies);
204       /* With no critical policies this is only a warning */
205       if (!any_critical)
206         {
207           do_list (0, listmode, fplist,
208                    _("note: non-critical certificate policy not allowed"));
209           return 0;
210         }
211       do_list (1, listmode, fplist,
212                _("certificate policy not allowed"));
213       return gpg_error (GPG_ERR_NO_POLICY_MATCH);
214     }
215
216   for (;;) 
217     {
218       int c;
219       char *p, line[256];
220       char *haystack, *allowed;
221
222       /* read line */
223       do
224         {
225           if (!fgets (line, DIM(line)-1, fp) )
226             {
227               gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
228
229               xfree (policies);
230               if (feof (fp))
231                 {
232                   fclose (fp);
233                   /* With no critical policies this is only a warning */
234                   if (!any_critical)
235                     {
236                       do_list (0, listmode, fplist,
237                      _("note: non-critical certificate policy not allowed"));
238                       return 0;
239                     }
240                   do_list (1, listmode, fplist,
241                            _("certificate policy not allowed"));
242                   return gpg_error (GPG_ERR_NO_POLICY_MATCH);
243                 }
244               fclose (fp);
245               return tmperr;
246             }
247       
248           if (!*line || line[strlen(line)-1] != '\n')
249             {
250               /* eat until end of line */
251               while ( (c=getc (fp)) != EOF && c != '\n')
252                 ;
253               fclose (fp);
254               xfree (policies);
255               return gpg_error (*line? GPG_ERR_LINE_TOO_LONG
256                                      : GPG_ERR_INCOMPLETE_LINE);
257             }
258           
259           /* Allow for empty lines and spaces */
260           for (p=line; spacep (p); p++)
261             ;
262         }
263       while (!*p || *p == '\n' || *p == '#');
264   
265       /* parse line */
266       for (allowed=line; spacep (allowed); allowed++)
267         ;
268       p = strpbrk (allowed, " :\n");
269       if (!*p || p == allowed)
270         {
271           fclose (fp);
272           xfree (policies);
273           return gpg_error (GPG_ERR_CONFIGURATION);
274         }
275       *p = 0; /* strip the rest of the line */
276       /* See whether we find ALLOWED (which is an OID) in POLICIES */
277       for (haystack=policies; (p=strstr (haystack, allowed)); haystack = p+1)
278         {
279           if ( !(p == policies || p[-1] == '\n') )
280             continue; /* Does not match the begin of a line. */
281           if (p[strlen (allowed)] != ':')
282             continue; /* The length does not match. */
283           /* Yep - it does match so return okay. */
284           fclose (fp);
285           xfree (policies);
286           return 0;
287         }
288     }
289 }
290
291
292 /* Helper function for find_up.  This resets the key handle and search
293    for an issuer ISSUER with a subjectKeyIdentifier of KEYID.  Returns
294    0 obn success or -1 when not found. */
295 static int
296 find_up_search_by_keyid (KEYDB_HANDLE kh,
297                          const char *issuer, ksba_sexp_t keyid)
298 {
299   int rc;
300   ksba_cert_t cert = NULL;
301   ksba_sexp_t subj = NULL;
302
303   keydb_search_reset (kh);
304   while (!(rc = keydb_search_subject (kh, issuer)))
305     {
306       ksba_cert_release (cert); cert = NULL;
307       rc = keydb_get_cert (kh, &cert);
308       if (rc)
309         {
310           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
311           rc = -1;
312           break;
313         }
314       xfree (subj);
315       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj))
316         {
317           if (!cmp_simple_canon_sexp (keyid, subj))
318             break; /* Found matching cert. */
319         }
320     }
321   
322   ksba_cert_release (cert);
323   xfree (subj);
324   return rc? -1:0;
325 }
326
327
328 static void
329 find_up_store_certs_cb (void *cb_value, ksba_cert_t cert)
330 {
331   if (keydb_store_cert (cert, 1, NULL))
332     log_error ("error storing issuer certificate as ephemeral\n");
333   ++*(int*)cb_value;
334 }
335
336
337 /* Helper for find_up().  Locate the certificate for ISSUER using an
338    external lookup.  KH is the keydb context we are currently using.
339    On success 0 is returned and the certificate may be retrieved from
340    the keydb using keydb_get_cert().  KEYID is the keyIdentifier from
341    the AKI or NULL. */
342 static int
343 find_up_external (KEYDB_HANDLE kh, const char *issuer, ksba_sexp_t keyid)
344 {
345   int rc;
346   strlist_t names = NULL;
347   int count = 0;
348   char *pattern;
349   const char *s;
350       
351   if (opt.verbose)
352     log_info (_("looking up issuer at external location\n"));
353   /* The DIRMNGR process is confused about unknown attributes.  As a
354      quick and ugly hack we locate the CN and use the issuer string
355      starting at this attribite.  Fixme: we should have far better
356      parsing in the dirmngr. */
357   s = strstr (issuer, "CN=");
358   if (!s || s == issuer || s[-1] != ',')
359     s = issuer;
360
361   pattern = xtrymalloc (strlen (s)+2);
362   if (!pattern)
363     return gpg_error_from_syserror ();
364   strcpy (stpcpy (pattern, "/"), s);
365   add_to_strlist (&names, pattern);
366   xfree (pattern);
367
368   rc = gpgsm_dirmngr_lookup (NULL, names, find_up_store_certs_cb, &count);
369   free_strlist (names);
370
371   if (opt.verbose)
372     log_info (_("number of issuers matching: %d\n"), count);
373   if (rc) 
374     {
375       log_error ("external key lookup failed: %s\n", gpg_strerror (rc));
376       rc = -1;
377     }
378   else if (!count)
379     rc = -1;
380   else
381     {
382       int old;
383       /* The issuers are currently stored in the ephemeral key DB, so
384          we temporary switch to ephemeral mode. */
385       old = keydb_set_ephemeral (kh, 1);
386       if (keyid)
387         rc = find_up_search_by_keyid (kh, issuer, keyid);
388       else
389         {
390           keydb_search_reset (kh);
391           rc = keydb_search_subject (kh, issuer);
392         }
393       keydb_set_ephemeral (kh, old);
394     }
395   return rc;
396 }
397
398
399 /* Locate issuing certificate for CERT. ISSUER is the name of the
400    issuer used as a fallback if the other methods don't work.  If
401    FIND_NEXT is true, the function shall return the next possible
402    issuer.  The certificate itself is not directly returned but a
403    keydb_get_cert on the keyDb context KH will return it.  Returns 0
404    on success, -1 if not found or an error code.  */
405 static int
406 find_up (KEYDB_HANDLE kh, ksba_cert_t cert, const char *issuer, int find_next)
407 {
408   ksba_name_t authid;
409   ksba_sexp_t authidno;
410   ksba_sexp_t keyid;
411   int rc = -1;
412
413   if (!ksba_cert_get_auth_key_id (cert, &keyid, &authid, &authidno))
414     {
415       const char *s = ksba_name_enum (authid, 0);
416       if (s && *authidno)
417         {
418           rc = keydb_search_issuer_sn (kh, s, authidno);
419           if (rc)
420               keydb_search_reset (kh);
421           
422           /* In case of an error try the ephemeral DB.  We can't do
423              that in find_next mode because we can't keep the search
424              state then. */
425           if (rc == -1 && !find_next)
426             { 
427               int old = keydb_set_ephemeral (kh, 1);
428               if (!old)
429                 {
430                   rc = keydb_search_issuer_sn (kh, s, authidno);
431                   if (rc)
432                     keydb_search_reset (kh);
433                 }
434               keydb_set_ephemeral (kh, old);
435             }
436
437         }
438
439       if (rc == -1 && keyid && !find_next)
440         {
441           /* Not found by AIK.issuer_sn.  Lets try the AIY.ki
442              instead. Loop over all certificates with that issuer as
443              subject and stop for the one with a matching
444              subjectKeyIdentifier. */
445           rc = find_up_search_by_keyid (kh, issuer, keyid);
446           if (rc)
447             {
448               int old = keydb_set_ephemeral (kh, 1);
449               if (!old)
450                 rc = find_up_search_by_keyid (kh, issuer, keyid);
451               keydb_set_ephemeral (kh, old);
452             }
453           if (rc) 
454             rc = -1; /* Need to make sure to have this error code. */
455         }
456
457       /* If we still didn't found it, try an external lookup.  */
458       if (rc == -1 && opt.auto_issuer_key_retrieve && !find_next)
459         rc = find_up_external (kh, issuer, keyid);
460
461       /* Print a note so that the user does not feel too helpless when
462          an issuer certificate was found and gpgsm prints BAD
463          signature because it is not the correct one. */
464       if (rc == -1)
465         {
466           log_info ("%sissuer certificate ", find_next?"next ":"");
467           if (keyid)
468             {
469               log_printf ("{");
470               gpgsm_dump_serial (keyid);
471               log_printf ("} ");
472             }
473           if (authidno)
474             {
475               log_printf ("(#");
476               gpgsm_dump_serial (authidno);
477               log_printf ("/");
478               gpgsm_dump_string (s);
479               log_printf (") ");
480             }
481           log_printf ("not found using authorityKeyIdentifier\n");
482         }
483       else if (rc)
484         log_error ("failed to find authorityKeyIdentifier: rc=%d\n", rc);
485       xfree (keyid);
486       ksba_name_release (authid);
487       xfree (authidno);
488     }
489   
490   if (rc) /* Not found via authorithyKeyIdentifier, try regular issuer name. */
491     rc = keydb_search_subject (kh, issuer);
492   if (rc == -1 && !find_next)
493     {
494       /* Not found, lets see whether we have one in the ephemeral key DB. */
495       int old = keydb_set_ephemeral (kh, 1);
496       if (!old)
497         {
498           keydb_search_reset (kh);
499           rc = keydb_search_subject (kh, issuer);
500         }
501       keydb_set_ephemeral (kh, old);
502     }
503
504   /* Still not found.  If enabled, try an external lookup.  */
505   if (rc == -1 && opt.auto_issuer_key_retrieve && !find_next)
506     rc = find_up_external (kh, issuer, NULL);
507
508   return rc;
509 }
510
511
512 /* Return the next certificate up in the chain starting at START.
513    Returns -1 when there are no more certificates. */
514 int
515 gpgsm_walk_cert_chain (ksba_cert_t start, ksba_cert_t *r_next)
516 {
517   int rc = 0; 
518   char *issuer = NULL;
519   char *subject = NULL;
520   KEYDB_HANDLE kh = keydb_new (0);
521
522   *r_next = NULL;
523   if (!kh)
524     {
525       log_error (_("failed to allocated keyDB handle\n"));
526       rc = gpg_error (GPG_ERR_GENERAL);
527       goto leave;
528     }
529
530   issuer = ksba_cert_get_issuer (start, 0);
531   subject = ksba_cert_get_subject (start, 0);
532   if (!issuer)
533     {
534       log_error ("no issuer found in certificate\n");
535       rc = gpg_error (GPG_ERR_BAD_CERT);
536       goto leave;
537     }
538   if (!subject)
539     {
540       log_error ("no subject found in certificate\n");
541       rc = gpg_error (GPG_ERR_BAD_CERT);
542       goto leave;
543     }
544
545   if (!strcmp (issuer, subject))
546     {
547       rc = -1; /* we are at the root */
548       goto leave; 
549     }
550
551   rc = find_up (kh, start, issuer, 0);
552   if (rc)
553     {
554       /* it is quite common not to have a certificate, so better don't
555          print an error here */
556       if (rc != -1 && opt.verbose > 1)
557         log_error ("failed to find issuer's certificate: rc=%d\n", rc);
558       rc = gpg_error (GPG_ERR_MISSING_CERT);
559       goto leave;
560     }
561
562   rc = keydb_get_cert (kh, r_next);
563   if (rc)
564     {
565       log_error ("keydb_get_cert() failed: rc=%d\n", rc);
566       rc = gpg_error (GPG_ERR_GENERAL);
567     }
568
569  leave:
570   xfree (issuer);
571   xfree (subject);
572   keydb_release (kh); 
573   return rc;
574 }
575
576
577 /* Check whether the CERT is a root certificate.  Returns True if this
578    is the case. */
579 int
580 gpgsm_is_root_cert (ksba_cert_t cert)
581 {
582   char *issuer;
583   char *subject;
584   int yes;
585
586   issuer = ksba_cert_get_issuer (cert, 0);
587   subject = ksba_cert_get_subject (cert, 0);
588   yes = (issuer && subject && !strcmp (issuer, subject));
589   xfree (issuer);
590   xfree (subject);
591   return yes;
592 }
593
594
595 /* This is a helper for gpgsm_validate_chain. */
596 static gpg_error_t 
597 is_cert_still_valid (ctrl_t ctrl, int lm, FILE *fp,
598                      ksba_cert_t subject_cert, ksba_cert_t issuer_cert,
599                      int *any_revoked, int *any_no_crl, int *any_crl_too_old)
600 {
601   if (!opt.no_crl_check || ctrl->use_ocsp)
602     {
603       gpg_error_t err;
604
605       err = gpgsm_dirmngr_isvalid (ctrl,
606                                    subject_cert, issuer_cert, ctrl->use_ocsp);
607       if (err)
608         {
609           /* Fixme: We should change the wording because we may
610              have used OCSP. */
611           if (!lm)
612             gpgsm_cert_log_name (NULL, subject_cert);
613           switch (gpg_err_code (err))
614             {
615             case GPG_ERR_CERT_REVOKED:
616               do_list (1, lm, fp, _("certificate has been revoked"));
617               *any_revoked = 1;
618               /* Store that in the keybox so that key listings are
619                  able to return the revoked flag.  We don't care
620                  about error, though. */
621               keydb_set_cert_flags (subject_cert, KEYBOX_FLAG_VALIDITY, 0,
622                                     VALIDITY_REVOKED);
623               break;
624             case GPG_ERR_NO_CRL_KNOWN:
625               do_list (1, lm, fp, _("no CRL found for certificate"));
626               *any_no_crl = 1;
627               break;
628             case GPG_ERR_CRL_TOO_OLD:
629               do_list (1, lm, fp, _("the available CRL is too old"));
630               if (!lm)
631                 log_info (_("please make sure that the "
632                             "\"dirmngr\" is properly installed\n"));
633               *any_crl_too_old = 1;
634               break;
635             default:
636               do_list (1, lm, fp, _("checking the CRL failed: %s"),
637                        gpg_strerror (err));
638               return err;
639             }
640         }
641     }
642   return 0;
643 }
644
645
646 \f
647 /* Validate a chain and optionally return the nearest expiration time
648    in R_EXPTIME. With LISTMODE set to 1 a special listmode is
649    activated where only information about the certificate is printed
650    to FP and no output is send to the usual log stream. 
651
652    Defined flag bits: 0 - do not do any dirmngr isvalid checks.
653 */
654 int
655 gpgsm_validate_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t r_exptime,
656                       int listmode, FILE *fp, unsigned int flags)
657 {
658   int rc = 0, depth = 0, maxdepth;
659   char *issuer = NULL;
660   char *subject = NULL;
661   KEYDB_HANDLE kh = NULL;
662   ksba_cert_t subject_cert = NULL, issuer_cert = NULL;
663   ksba_isotime_t current_time;
664   ksba_isotime_t exptime;
665   int any_expired = 0;
666   int any_revoked = 0;
667   int any_no_crl = 0;
668   int any_crl_too_old = 0;
669   int any_no_policy_match = 0;
670   int is_qualified = -1; /* Indicates whether the certificate stems
671                             from a qualified root certificate.
672                             -1 = unknown, 0 = no, 1 = yes. */
673   int lm = listmode;
674
675   gnupg_get_isotime (current_time);
676   if (r_exptime)
677     *r_exptime = 0;
678   *exptime = 0;
679
680   if (opt.no_chain_validation && !listmode)
681     {
682       log_info ("WARNING: bypassing certificate chain validation\n");
683       return 0;
684     }
685
686   kh = keydb_new (0);
687   if (!kh)
688     {
689       log_error (_("failed to allocated keyDB handle\n"));
690       rc = gpg_error (GPG_ERR_GENERAL);
691       goto leave;
692     }
693
694   if (DBG_X509 && !listmode)
695     gpgsm_dump_cert ("target", cert);
696
697   subject_cert = cert;
698   ksba_cert_ref (subject_cert);
699   maxdepth = 50;
700
701   for (;;)
702     {
703       int is_root;
704       gpg_error_t istrusted_rc;
705       struct rootca_flags_s rootca_flags;
706
707       xfree (issuer);
708       xfree (subject);
709       issuer = ksba_cert_get_issuer (subject_cert, 0);
710       subject = ksba_cert_get_subject (subject_cert, 0);
711
712       if (!issuer)
713         {
714           do_list (1, lm, fp,  _("no issuer found in certificate"));
715           rc = gpg_error (GPG_ERR_BAD_CERT);
716           goto leave;
717         }
718
719       /* Is this a self-issued certificate (i.e. the root certificate)? */
720       is_root = (subject && !strcmp (issuer, subject));
721       if (is_root)
722         {
723           /* Check early whether the certificate is listed as trusted.
724              We used to do this only later but changed it to call the
725              check right here so that we can access special flags
726              associated with that specific root certificate.  */
727           istrusted_rc = gpgsm_agent_istrusted (ctrl, subject_cert,
728                                                 &rootca_flags);
729         }
730       
731
732       /* Check the validity period. */
733       {
734         ksba_isotime_t not_before, not_after;
735
736         rc = ksba_cert_get_validity (subject_cert, 0, not_before);
737         if (!rc)
738           rc = ksba_cert_get_validity (subject_cert, 1, not_after);
739         if (rc)
740           {
741             do_list (1, lm, fp, _("certificate with invalid validity: %s"),
742                      gpg_strerror (rc));
743             rc = gpg_error (GPG_ERR_BAD_CERT);
744             goto leave;
745           }
746
747         if (*not_after)
748           {
749             if (!*exptime)
750               gnupg_copy_time (exptime, not_after);
751             else if (strcmp (not_after, exptime) < 0 )
752               gnupg_copy_time (exptime, not_after);
753           }
754
755         if (*not_before && strcmp (current_time, not_before) < 0 )
756           {
757             do_list (1, lm, fp, _("certificate not yet valid"));
758             if (!lm)
759               {
760                 log_info ("(valid from ");
761                 gpgsm_dump_time (not_before);
762                 log_printf (")\n");
763               }
764             rc = gpg_error (GPG_ERR_CERT_TOO_YOUNG);
765             goto leave;
766           }            
767         if (*not_after && strcmp (current_time, not_after) > 0 )
768           {
769             do_list (opt.ignore_expiration?0:1, lm, fp,
770                      _("certificate has expired"));
771             if (!lm)
772               {
773                 log_info ("(expired at ");
774                 gpgsm_dump_time (not_after);
775                 log_printf (")\n");
776               }
777             if (opt.ignore_expiration)
778                 log_info ("WARNING: ignoring expiration\n");
779             else
780               any_expired = 1;
781           }            
782       }
783
784       /* Assert that we understand all critical extensions. */
785       rc = unknown_criticals (subject_cert, listmode, fp);
786       if (rc)
787         goto leave;
788
789       /* Do a policy check. */
790       if (!opt.no_policy_check)
791         {
792           rc = check_cert_policy (subject_cert, listmode, fp);
793           if (gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH)
794             {
795               any_no_policy_match = 1;
796               rc = 1;
797             }
798           else if (rc)
799             goto leave;
800         }
801
802
803       /* Is this a self-issued certificate? */
804       if (is_root)
805         { 
806           if (!istrusted_rc)
807             ; /* No need to check the certificate for a trusted one. */
808           else if (gpgsm_check_cert_sig (subject_cert, subject_cert) )
809             {
810               /* We only check the signature if the certificate is not
811                  trusted for better diagnostics. */
812               do_list (1, lm, fp,
813                        _("self-signed certificate has a BAD signature"));
814               if (DBG_X509)
815                 {
816                   gpgsm_dump_cert ("self-signing cert", subject_cert);
817                 }
818               rc = gpg_error (depth? GPG_ERR_BAD_CERT_CHAIN
819                                    : GPG_ERR_BAD_CERT);
820               goto leave;
821             }
822           if (!rootca_flags.relax)
823             {
824               rc = allowed_ca (subject_cert, NULL, listmode, fp);
825               if (rc)
826                 goto leave;
827             }
828               
829           
830           /* Set the flag for qualified signatures.  This flag is
831              deduced from a list of root certificates allowed for
832              qualified signatures. */
833           if (is_qualified == -1)
834             {
835               gpg_error_t err;
836               size_t buflen;
837               char buf[1];
838               
839               if (!ksba_cert_get_user_data (cert, "is_qualified", 
840                                             &buf, sizeof (buf),
841                                             &buflen) && buflen)
842                 {
843                   /* We already checked this for this certificate,
844                      thus we simply take it from the user data. */
845                   is_qualified = !!*buf;
846                 }    
847               else
848                 {
849                   /* Need to consult the list of root certificates for
850                      qualified signatures. */
851                   err = gpgsm_is_in_qualified_list (ctrl, subject_cert, NULL);
852                   if (!err)
853                     is_qualified = 1;
854                   else if ( gpg_err_code (err) == GPG_ERR_NOT_FOUND)
855                     is_qualified = 0;
856                   else
857                     log_error ("checking the list of qualified "
858                                "root certificates failed: %s\n",
859                                gpg_strerror (err));
860                   if ( is_qualified != -1 )
861                     {
862                       /* Cache the result but don't care too much
863                          about an error. */
864                       buf[0] = !!is_qualified;
865                       err = ksba_cert_set_user_data (subject_cert,
866                                                      "is_qualified", buf, 1);
867                       if (err)
868                         log_error ("set_user_data(is_qualified) failed: %s\n",
869                                    gpg_strerror (err)); 
870                     }
871                 }
872             }
873
874
875           /* Act on the check for a trusted root certificates. */
876           rc = istrusted_rc;
877           if (!rc)
878             ;
879           else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
880             {
881               do_list (0, lm, fp, _("root certificate is not marked trusted"));
882               /* If we already figured out that the certificate is
883                  expired it does not make much sense to ask the user
884                  whether we wants to trust the root certificate.  He
885                  should do this only if the certificate under question
886                  will then be usable. */
887               if (!lm && !any_expired)
888                 {
889                   int rc2;
890                   char *fpr = gpgsm_get_fingerprint_string (subject_cert,
891                                                             GCRY_MD_SHA1);
892                   log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
893                   xfree (fpr);
894                   rc2 = gpgsm_agent_marktrusted (ctrl, subject_cert);
895                   if (!rc2)
896                     {
897                       log_info (_("root certificate has now"
898                                   " been marked as trusted\n"));
899                       rc = 0;
900                     }
901                   else 
902                     {
903                       gpgsm_dump_cert ("issuer", subject_cert);
904                       log_info ("after checking the fingerprint, you may want "
905                                 "to add it manually to the list of trusted "
906                                 "certificates.\n");
907                     }
908                 }
909             }
910           else 
911             {
912               log_error (_("checking the trust list failed: %s\n"),
913                          gpg_strerror (rc));
914             }
915           
916           if (rc)
917             goto leave;
918
919           /* Check for revocations etc. */
920           if ((flags & 1))
921             ;
922           else if (opt.no_trusted_cert_crl_check || rootca_flags.relax)
923             ; 
924           else
925             rc = is_cert_still_valid (ctrl, lm, fp,
926                                       subject_cert, subject_cert,
927                                       &any_revoked, &any_no_crl,
928                                       &any_crl_too_old);
929           if (rc)
930             goto leave;
931
932           break;  /* Okay: a self-signed certicate is an end-point. */
933         }
934       
935       /* Take care that the chain does not get too long. */
936       depth++;
937       if (depth > maxdepth)
938         {
939           do_list (1, lm, fp, _("certificate chain too long\n"));
940           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
941           goto leave;
942         }
943
944       /* Find the next cert up the tree. */
945       keydb_search_reset (kh);
946       rc = find_up (kh, subject_cert, issuer, 0);
947       if (rc)
948         {
949           if (rc == -1)
950             {
951               do_list (0, lm, fp, _("issuer certificate not found"));
952               if (!lm)
953                 {
954                   log_info ("issuer certificate: #/");
955                   gpgsm_dump_string (issuer);
956                   log_printf ("\n");
957                 }
958             }
959           else
960             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
961           rc = gpg_error (GPG_ERR_MISSING_CERT);
962           goto leave;
963         }
964
965       ksba_cert_release (issuer_cert); issuer_cert = NULL;
966       rc = keydb_get_cert (kh, &issuer_cert);
967       if (rc)
968         {
969           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
970           rc = gpg_error (GPG_ERR_GENERAL);
971           goto leave;
972         }
973
974     try_another_cert:
975       if (DBG_X509)
976         {
977           log_debug ("got issuer's certificate:\n");
978           gpgsm_dump_cert ("issuer", issuer_cert);
979         }
980
981       rc = gpgsm_check_cert_sig (issuer_cert, subject_cert);
982       if (rc)
983         {
984           do_list (0, lm, fp, _("certificate has a BAD signature"));
985           if (DBG_X509)
986             {
987               gpgsm_dump_cert ("signing issuer", issuer_cert);
988               gpgsm_dump_cert ("signed subject", subject_cert);
989             }
990           if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
991             {
992               /* We now try to find other issuer certificates which
993                  might have been used.  This is required because some
994                  CAs are reusing the issuer and subject DN for new
995                  root certificates. */
996               /* FIXME: Do this only if we don't have an
997                  AKI.keyIdentifier */
998               rc = find_up (kh, subject_cert, issuer, 1);
999               if (!rc)
1000                 {
1001                   ksba_cert_t tmp_cert;
1002
1003                   rc = keydb_get_cert (kh, &tmp_cert);
1004                   if (rc || !compare_certs (issuer_cert, tmp_cert))
1005                     {
1006                       /* The find next did not work or returned an
1007                          identical certificate.  We better stop here
1008                          to avoid infinite checks. */
1009                       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
1010                       ksba_cert_release (tmp_cert);
1011                     }
1012                   else
1013                     {
1014                       do_list (0, lm, fp, _("found another possible matching "
1015                                             "CA certificate - trying again"));
1016                       ksba_cert_release (issuer_cert); 
1017                       issuer_cert = tmp_cert;
1018                       goto try_another_cert;
1019                     }
1020                 }
1021             }
1022
1023           /* We give a more descriptive error code than the one
1024              returned from the signature checking. */
1025           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
1026           goto leave;
1027         }
1028
1029       is_root = 0;
1030       istrusted_rc = -1;
1031
1032       /* Check that a CA is allowed to issue certificates. */
1033       {
1034         int chainlen;
1035
1036         rc = allowed_ca (issuer_cert, &chainlen, listmode, fp);
1037         if (rc)
1038           {
1039             /* Not allowed.  Check whether this is a trusted root
1040                certificate and whether we allow special exceptions.
1041                We could carry the result of the test over to the
1042                regular root check at the top of the loop but for
1043                clarity we won't do that.  Given that the majority of
1044                certificates carry proper BasicContraints our way of
1045                overriding an error in the way is justified for
1046                performance reasons. */
1047             if (gpgsm_is_root_cert (issuer_cert))
1048               {
1049                 is_root = 1;
1050                 istrusted_rc = gpgsm_agent_istrusted (ctrl, issuer_cert,
1051                                                       &rootca_flags);
1052                 if (!istrusted_rc && rootca_flags.relax)
1053                   {
1054                     /* Ignore the error due to the relax flag.  */
1055                     rc = 0;
1056                     chainlen = -1;
1057                   }
1058               }
1059           }
1060         if (rc)
1061           goto leave;
1062         if (chainlen >= 0 && (depth - 1) > chainlen)
1063           {
1064             do_list (1, lm, fp,
1065                      _("certificate chain longer than allowed by CA (%d)"),
1066                      chainlen);
1067             rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
1068             goto leave;
1069           }
1070       }
1071
1072       /* Is the certificate allowed to sign other certificates. */
1073       if (!listmode)
1074         {
1075           rc = gpgsm_cert_use_cert_p (issuer_cert);
1076           if (rc)
1077             {
1078               char numbuf[50];
1079               sprintf (numbuf, "%d", rc);
1080               gpgsm_status2 (ctrl, STATUS_ERROR, "certcert.issuer.keyusage",
1081                              numbuf, NULL);
1082               goto leave;
1083             }
1084         }
1085
1086       /* Check for revocations etc.  Note that for a root certioficate
1087          this test is done a second time later. This should eventually
1088          be fixed. */
1089       if ((flags & 1))
1090         rc = 0;
1091       else if (is_root && (opt.no_trusted_cert_crl_check
1092                            || (!istrusted_rc && rootca_flags.relax)))
1093         ; 
1094       else
1095         rc = is_cert_still_valid (ctrl, lm, fp,
1096                                   subject_cert, issuer_cert,
1097                                   &any_revoked, &any_no_crl, &any_crl_too_old);
1098       if (rc)
1099         goto leave;
1100
1101
1102       if (opt.verbose && !listmode)
1103         log_info ("certificate is good\n");
1104
1105       /* For the next round the current issuer becomes the new subject.  */
1106       keydb_search_reset (kh);
1107       ksba_cert_release (subject_cert);
1108       subject_cert = issuer_cert;
1109       issuer_cert = NULL;
1110     } /* End chain traversal. */
1111
1112   if (!listmode)
1113     {
1114       if (opt.no_policy_check)
1115         log_info ("policies not checked due to %s option\n",
1116                   "--disable-policy-checks");
1117       if (opt.no_crl_check && !ctrl->use_ocsp)
1118         log_info ("CRLs not checked due to %s option\n",
1119                   "--disable-crl-checks");
1120     }
1121
1122   if (!rc)
1123     { /* If we encountered an error somewhere during the checks, set
1124          the error code to the most critical one */
1125       if (any_revoked)
1126         rc = gpg_error (GPG_ERR_CERT_REVOKED);
1127       else if (any_expired)
1128         rc = gpg_error (GPG_ERR_CERT_EXPIRED);
1129       else if (any_no_crl)
1130         rc = gpg_error (GPG_ERR_NO_CRL_KNOWN);
1131       else if (any_crl_too_old)
1132         rc = gpg_error (GPG_ERR_CRL_TOO_OLD);
1133       else if (any_no_policy_match)
1134         rc = gpg_error (GPG_ERR_NO_POLICY_MATCH);
1135     }
1136   
1137  leave:
1138   if (is_qualified != -1)
1139     {
1140       /* We figured something about the qualified signature capability
1141          of the certificate under question.  Store the result as user
1142          data in the certificate object.  We do this even if the
1143          validation itself failed. */
1144       /* Fixme: We should set this flag for all certificates in the
1145          chain for optimizing reasons. */
1146       char buf[1];
1147       gpg_error_t err;
1148
1149       buf[0] = !!is_qualified;
1150       err = ksba_cert_set_user_data (cert, "is_qualified", buf, 1);
1151       if (err)
1152         {
1153           log_error ("set_user_data(is_qualified) failed: %s\n",
1154                      gpg_strerror (err)); 
1155           if (!rc)
1156             rc = err;
1157         }
1158     }
1159   if (r_exptime)
1160     gnupg_copy_time (r_exptime, exptime);
1161   xfree (issuer);
1162   xfree (subject);
1163   keydb_release (kh); 
1164   ksba_cert_release (issuer_cert);
1165   ksba_cert_release (subject_cert);
1166   return rc;
1167 }
1168
1169
1170 /* Check that the given certificate is valid but DO NOT check any
1171    constraints.  We assume that the issuers certificate is already in
1172    the DB and that this one is valid; which it should be because it
1173    has been checked using this function. */
1174 int
1175 gpgsm_basic_cert_check (ksba_cert_t cert)
1176 {
1177   int rc = 0;
1178   char *issuer = NULL;
1179   char *subject = NULL;
1180   KEYDB_HANDLE kh;
1181   ksba_cert_t issuer_cert = NULL;
1182   
1183   if (opt.no_chain_validation)
1184     {
1185       log_info ("WARNING: bypassing basic certificate checks\n");
1186       return 0;
1187     }
1188
1189   kh = keydb_new (0);
1190   if (!kh)
1191     {
1192       log_error (_("failed to allocated keyDB handle\n"));
1193       rc = gpg_error (GPG_ERR_GENERAL);
1194       goto leave;
1195     }
1196
1197   issuer = ksba_cert_get_issuer (cert, 0);
1198   subject = ksba_cert_get_subject (cert, 0);
1199   if (!issuer)
1200     {
1201       log_error ("no issuer found in certificate\n");
1202       rc = gpg_error (GPG_ERR_BAD_CERT);
1203       goto leave;
1204     }
1205
1206   if (subject && !strcmp (issuer, subject))
1207     {
1208       rc = gpgsm_check_cert_sig (cert, cert);
1209       if (rc)
1210         {
1211           log_error ("self-signed certificate has a BAD signature: %s\n",
1212                      gpg_strerror (rc));
1213           if (DBG_X509)
1214             {
1215               gpgsm_dump_cert ("self-signing cert", cert);
1216             }
1217           rc = gpg_error (GPG_ERR_BAD_CERT);
1218           goto leave;
1219         }
1220     }
1221   else
1222     {
1223       /* Find the next cert up the tree. */
1224       keydb_search_reset (kh);
1225       rc = find_up (kh, cert, issuer, 0);
1226       if (rc)
1227         {
1228           if (rc == -1)
1229             {
1230               log_info ("issuer certificate (#/");
1231               gpgsm_dump_string (issuer);
1232               log_printf (") not found\n");
1233             }
1234           else
1235             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
1236           rc = gpg_error (GPG_ERR_MISSING_CERT);
1237           goto leave;
1238         }
1239       
1240       ksba_cert_release (issuer_cert); issuer_cert = NULL;
1241       rc = keydb_get_cert (kh, &issuer_cert);
1242       if (rc)
1243         {
1244           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
1245           rc = gpg_error (GPG_ERR_GENERAL);
1246           goto leave;
1247         }
1248
1249       rc = gpgsm_check_cert_sig (issuer_cert, cert);
1250       if (rc)
1251         {
1252           log_error ("certificate has a BAD signature: %s\n",
1253                      gpg_strerror (rc));
1254           if (DBG_X509)
1255             {
1256               gpgsm_dump_cert ("signing issuer", issuer_cert);
1257               gpgsm_dump_cert ("signed subject", cert);
1258             }
1259           rc = gpg_error (GPG_ERR_BAD_CERT);
1260           goto leave;
1261         }
1262       if (opt.verbose)
1263         log_info ("certificate is good\n");
1264     }
1265
1266  leave:
1267   xfree (issuer);
1268   keydb_release (kh); 
1269   ksba_cert_release (issuer_cert);
1270   return rc;
1271 }
1272
1273
1274
1275 /* Check whether the certificate CERT has been issued by the German
1276    authority for qualified signature.  They do not set the
1277    basicConstraints and thus we need this workaround.  It works by
1278    looking up the root certificate and checking whether that one is
1279    listed as a qualified certificate for Germany. 
1280
1281    We also try to cache this data but as long as don't keep a
1282    reference to the certificate this won't be used.
1283
1284    Returns: True if CERT is a RegTP issued CA cert (i.e. the root
1285    certificate itself or one of the CAs).  In that case CHAINLEN will
1286    receive the length of the chain which is either 0 or 1.
1287 */
1288 static int
1289 get_regtp_ca_info (ksba_cert_t cert, int *chainlen)
1290 {
1291   gpg_error_t err;
1292   ksba_cert_t next;
1293   int rc = 0;
1294   int i, depth;
1295   char country[3];
1296   ksba_cert_t array[4];
1297   char buf[2];
1298   size_t buflen;
1299   int dummy_chainlen;
1300
1301   if (!chainlen)
1302     chainlen = &dummy_chainlen;
1303
1304   *chainlen = 0;
1305   err = ksba_cert_get_user_data (cert, "regtp_ca_chainlen", 
1306                                  &buf, sizeof (buf), &buflen);
1307   if (!err)
1308     {
1309       /* Got info. */
1310       if (buflen < 2 || !*buf)
1311         return 0; /* Nothing found. */
1312       *chainlen = buf[1];
1313       return 1; /* This is a regtp CA. */
1314     }
1315   else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1316     {
1317       log_error ("ksba_cert_get_user_data(%s) failed: %s\n",
1318                  "regtp_ca_chainlen", gpg_strerror (err));
1319       return 0; /* Nothing found.  */
1320     }
1321
1322   /* Need to gather the info.  This requires to walk up the chain
1323      until we have found the root.  Because we are only interested in
1324      German Bundesnetzagentur (former RegTP) derived certificates 3
1325      levels are enough.  (The German signature law demands a 3 tier
1326      hierachy; thus there is only one CA between the EE and the Root
1327      CA.)  */
1328   memset (&array, 0, sizeof array);
1329
1330   depth = 0;
1331   ksba_cert_ref (cert);
1332   array[depth++] = cert;
1333   ksba_cert_ref (cert);
1334   while (depth < DIM(array) && !(rc=gpgsm_walk_cert_chain (cert, &next)))
1335     {
1336       ksba_cert_release (cert);
1337       ksba_cert_ref (next);
1338       array[depth++] = next;
1339       cert = next;
1340     }
1341   ksba_cert_release (cert);
1342   if (rc != -1 || !depth || depth == DIM(array) )
1343     {
1344       /* We did not reached the root. */
1345       goto leave;
1346     }
1347
1348   /* If this is a German signature law issued certificate, we store
1349      additional additional information. */
1350   if (!gpgsm_is_in_qualified_list (NULL, array[depth-1], country)
1351       && !strcmp (country, "de"))
1352     {
1353       /* Setting the pathlen for the root CA and the CA flag for the
1354          next one is all what we need to do. */
1355       err = ksba_cert_set_user_data (array[depth-1], "regtp_ca_chainlen",
1356                                      "\x01\x01", 2);
1357       if (!err && depth > 1)
1358         err = ksba_cert_set_user_data (array[depth-2], "regtp_ca_chainlen",
1359                                        "\x01\x00", 2);
1360       if (err)
1361         log_error ("ksba_set_user_data(%s) failed: %s\n",
1362                    "regtp_ca_chainlen", gpg_strerror (err)); 
1363       for (i=0; i < depth; i++)
1364         ksba_cert_release (array[i]);
1365       *chainlen = (depth>1? 0:1);
1366       return 1;
1367     }
1368
1369  leave:
1370   /* Nothing special with this certificate. Mark the target
1371      certificate anyway to avoid duplicate lookups. */ 
1372   err = ksba_cert_set_user_data (cert, "regtp_ca_chainlen", "", 1);
1373   if (err)
1374     log_error ("ksba_set_user_data(%s) failed: %s\n",
1375                "regtp_ca_chainlen", gpg_strerror (err)); 
1376   for (i=0; i < depth; i++)
1377     ksba_cert_release (array[i]);
1378   return 0;
1379 }