8a3a84c932df5e314b408d813f9247eeb1008849
[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   maxdepth = 50;
699
700   for (;;)
701     {
702       xfree (issuer);
703       xfree (subject);
704       issuer = ksba_cert_get_issuer (subject_cert, 0);
705       subject = ksba_cert_get_subject (subject_cert, 0);
706
707       if (!issuer)
708         {
709           do_list (1, lm, fp,  _("no issuer found in certificate"));
710           rc = gpg_error (GPG_ERR_BAD_CERT);
711           goto leave;
712         }
713
714       {
715         ksba_isotime_t not_before, not_after;
716
717         rc = ksba_cert_get_validity (subject_cert, 0, not_before);
718         if (!rc)
719           rc = ksba_cert_get_validity (subject_cert, 1, not_after);
720         if (rc)
721           {
722             do_list (1, lm, fp, _("certificate with invalid validity: %s"),
723                      gpg_strerror (rc));
724             rc = gpg_error (GPG_ERR_BAD_CERT);
725             goto leave;
726           }
727
728         if (*not_after)
729           {
730             if (!*exptime)
731               gnupg_copy_time (exptime, not_after);
732             else if (strcmp (not_after, exptime) < 0 )
733               gnupg_copy_time (exptime, not_after);
734           }
735
736         if (*not_before && strcmp (current_time, not_before) < 0 )
737           {
738             do_list (1, lm, fp, _("certificate not yet valid"));
739             if (!lm)
740               {
741                 log_info ("(valid from ");
742                 gpgsm_dump_time (not_before);
743                 log_printf (")\n");
744               }
745             rc = gpg_error (GPG_ERR_CERT_TOO_YOUNG);
746             goto leave;
747           }            
748         if (*not_after && strcmp (current_time, not_after) > 0 )
749           {
750             do_list (opt.ignore_expiration?0:1, lm, fp,
751                      _("certificate has expired"));
752             if (!lm)
753               {
754                 log_info ("(expired at ");
755                 gpgsm_dump_time (not_after);
756                 log_printf (")\n");
757               }
758             if (opt.ignore_expiration)
759                 log_info ("WARNING: ignoring expiration\n");
760             else
761               any_expired = 1;
762           }            
763       }
764
765       rc = unknown_criticals (subject_cert, listmode, fp);
766       if (rc)
767         goto leave;
768
769       if (!opt.no_policy_check)
770         {
771           rc = check_cert_policy (subject_cert, listmode, fp);
772           if (gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH)
773             {
774               any_no_policy_match = 1;
775               rc = 1;
776             }
777           else if (rc)
778             goto leave;
779         }
780
781
782       /* Is this a self-issued certificate? */
783       if (subject && !strcmp (issuer, subject))
784         {  /* Yes. */
785           gpg_error_t istrusted_rc;
786           struct rootca_flags_s rootca_flags;
787
788           /* Check early whether the certificate is listed as trusted.
789              We used to do this only later but changed it to call the
790              check right here so that we can access special flags
791              associated with that specific root certificate.  */
792           istrusted_rc = gpgsm_agent_istrusted (ctrl, subject_cert,
793                                                 &rootca_flags);
794
795           /* Note, that we could save the following signature check
796              because nobody would be so dump to set up a faked chain
797              and fail in creating a valid self-signed certificate. */
798           if (gpgsm_check_cert_sig (subject_cert, subject_cert) )
799             {
800               do_list (1, lm, fp,
801                        _("self-signed certificate has a BAD signature"));
802               if (DBG_X509)
803                 {
804                   gpgsm_dump_cert ("self-signing cert", subject_cert);
805                 }
806               rc = gpg_error (depth? GPG_ERR_BAD_CERT_CHAIN
807                                    : GPG_ERR_BAD_CERT);
808               goto leave;
809             }
810           if (!rootca_flags.relax)
811             {
812               rc = allowed_ca (subject_cert, NULL, listmode, fp);
813               if (rc)
814                 goto leave;
815             }
816               
817           
818           /* Set the flag for qualified signatures.  This flag is
819              deduced from a list of root certificates allowed for
820              qualified signatures. */
821           if (is_qualified == -1)
822             {
823               gpg_error_t err;
824               size_t buflen;
825               char buf[1];
826               
827               if (!ksba_cert_get_user_data (cert, "is_qualified", 
828                                             &buf, sizeof (buf),
829                                             &buflen) && buflen)
830                 {
831                   /* We already checked this for this certificate,
832                      thus we simply take it from the user data. */
833                   is_qualified = !!*buf;
834                 }    
835               else
836                 {
837                   /* Need to consult the list of root certificates for
838                      qualified signatures. */
839                   err = gpgsm_is_in_qualified_list (ctrl, subject_cert, NULL);
840                   if (!err)
841                     is_qualified = 1;
842                   else if ( gpg_err_code (err) == GPG_ERR_NOT_FOUND)
843                     is_qualified = 0;
844                   else
845                     log_error ("checking the list of qualified "
846                                "root certificates failed: %s\n",
847                                gpg_strerror (err));
848                   if ( is_qualified != -1 )
849                     {
850                       /* Cache the result but don't care too much
851                          about an error. */
852                       buf[0] = !!is_qualified;
853                       err = ksba_cert_set_user_data (subject_cert,
854                                                      "is_qualified", buf, 1);
855                       if (err)
856                         log_error ("set_user_data(is_qualified) failed: %s\n",
857                                    gpg_strerror (err)); 
858                     }
859                 }
860             }
861
862
863           /* Act on the check for a trusted root certificates. */
864           rc = istrusted_rc;
865           if (!rc)
866             ;
867           else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
868             {
869               do_list (0, lm, fp, _("root certificate is not marked trusted"));
870               /* If we already figured out that the certificate is
871                  expired it does not make much sense to ask the user
872                  whether we wants to trust the root certificate.  He
873                  should do this only if the certificate under question
874                  will then be usable. */
875               if (!lm && !any_expired)
876                 {
877                   int rc2;
878                   char *fpr = gpgsm_get_fingerprint_string (subject_cert,
879                                                             GCRY_MD_SHA1);
880                   log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
881                   xfree (fpr);
882                   rc2 = gpgsm_agent_marktrusted (ctrl, subject_cert);
883                   if (!rc2)
884                     {
885                       log_info (_("root certificate has now"
886                                   " been marked as trusted\n"));
887                       rc = 0;
888                     }
889                   else 
890                     {
891                       gpgsm_dump_cert ("issuer", subject_cert);
892                       log_info ("after checking the fingerprint, you may want "
893                                 "to add it manually to the list of trusted "
894                                 "certificates.\n");
895                     }
896                 }
897             }
898           else 
899             {
900               log_error (_("checking the trust list failed: %s\n"),
901                          gpg_strerror (rc));
902             }
903           
904           if (rc)
905             goto leave;
906
907           /* Check for revocations etc. */
908           if ((flags & 1))
909             ;
910           else if (opt.no_trusted_cert_crl_check || rootca_flags.relax)
911             ; 
912           else
913             rc = is_cert_still_valid (ctrl, lm, fp,
914                                       subject_cert, subject_cert,
915                                       &any_revoked, &any_no_crl,
916                                       &any_crl_too_old);
917           if (rc)
918             goto leave;
919
920           break;  /* Okay: a self-signed certicate is an end-point. */
921         }
922       
923       depth++;
924       if (depth > maxdepth)
925         {
926           do_list (1, lm, fp, _("certificate chain too long\n"));
927           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
928           goto leave;
929         }
930
931       /* find the next cert up the tree */
932       keydb_search_reset (kh);
933       rc = find_up (kh, subject_cert, issuer, 0);
934       if (rc)
935         {
936           if (rc == -1)
937             {
938               do_list (0, lm, fp, _("issuer certificate not found"));
939               if (!lm)
940                 {
941                   log_info ("issuer certificate: #/");
942                   gpgsm_dump_string (issuer);
943                   log_printf ("\n");
944                 }
945             }
946           else
947             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
948           rc = gpg_error (GPG_ERR_MISSING_CERT);
949           goto leave;
950         }
951
952       ksba_cert_release (issuer_cert); issuer_cert = NULL;
953       rc = keydb_get_cert (kh, &issuer_cert);
954       if (rc)
955         {
956           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
957           rc = gpg_error (GPG_ERR_GENERAL);
958           goto leave;
959         }
960
961     try_another_cert:
962       if (DBG_X509)
963         {
964           log_debug ("got issuer's certificate:\n");
965           gpgsm_dump_cert ("issuer", issuer_cert);
966         }
967
968       rc = gpgsm_check_cert_sig (issuer_cert, subject_cert);
969       if (rc)
970         {
971           do_list (0, lm, fp, _("certificate has a BAD signature"));
972           if (DBG_X509)
973             {
974               gpgsm_dump_cert ("signing issuer", issuer_cert);
975               gpgsm_dump_cert ("signed subject", subject_cert);
976             }
977           if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
978             {
979               /* We now try to find other issuer certificates which
980                  might have been used.  This is required because some
981                  CAs are reusing the issuer and subject DN for new
982                  root certificates. */
983               /* FIXME: Do this only if we don't have an
984                  AKI.keyIdentifier */
985               rc = find_up (kh, subject_cert, issuer, 1);
986               if (!rc)
987                 {
988                   ksba_cert_t tmp_cert;
989
990                   rc = keydb_get_cert (kh, &tmp_cert);
991                   if (rc || !compare_certs (issuer_cert, tmp_cert))
992                     {
993                       /* The find next did not work or returned an
994                          identical certificate.  We better stop here
995                          to avoid infinite checks. */
996                       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
997                       ksba_cert_release (tmp_cert);
998                     }
999                   else
1000                     {
1001                       do_list (0, lm, fp, _("found another possible matching "
1002                                             "CA certificate - trying again"));
1003                       ksba_cert_release (issuer_cert); 
1004                       issuer_cert = tmp_cert;
1005                       goto try_another_cert;
1006                     }
1007                 }
1008             }
1009
1010           /* We give a more descriptive error code than the one
1011              returned from the signature checking. */
1012           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
1013           goto leave;
1014         }
1015
1016       {
1017         int chainlen;
1018         rc = allowed_ca (issuer_cert, &chainlen, listmode, fp);
1019         if (rc)
1020           goto leave;
1021         if (chainlen >= 0 && (depth - 1) > chainlen)
1022           {
1023             do_list (1, lm, fp,
1024                      _("certificate chain longer than allowed by CA (%d)"),
1025                      chainlen);
1026             rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
1027             goto leave;
1028           }
1029       }
1030
1031       if (!listmode)
1032         {
1033           rc = gpgsm_cert_use_cert_p (issuer_cert);
1034           if (rc)
1035             {
1036               char numbuf[50];
1037               sprintf (numbuf, "%d", rc);
1038               gpgsm_status2 (ctrl, STATUS_ERROR, "certcert.issuer.keyusage",
1039                              numbuf, NULL);
1040               goto leave;
1041             }
1042         }
1043
1044       /* Check for revocations etc. */
1045       if ((flags & 1))
1046         rc = 0;
1047       else
1048         rc = is_cert_still_valid (ctrl, lm, fp,
1049                                   subject_cert, issuer_cert,
1050                                   &any_revoked, &any_no_crl, &any_crl_too_old);
1051       if (rc)
1052         goto leave;
1053
1054
1055       if (opt.verbose && !listmode)
1056         log_info ("certificate is good\n");
1057       
1058       keydb_search_reset (kh);
1059       subject_cert = issuer_cert;
1060       issuer_cert = NULL;
1061     } /* End chain traversal. */
1062
1063   if (!listmode)
1064     {
1065       if (opt.no_policy_check)
1066         log_info ("policies not checked due to %s option\n",
1067                   "--disable-policy-checks");
1068       if (opt.no_crl_check && !ctrl->use_ocsp)
1069         log_info ("CRLs not checked due to %s option\n",
1070                   "--disable-crl-checks");
1071     }
1072
1073   if (!rc)
1074     { /* If we encountered an error somewhere during the checks, set
1075          the error code to the most critical one */
1076       if (any_revoked)
1077         rc = gpg_error (GPG_ERR_CERT_REVOKED);
1078       else if (any_expired)
1079         rc = gpg_error (GPG_ERR_CERT_EXPIRED);
1080       else if (any_no_crl)
1081         rc = gpg_error (GPG_ERR_NO_CRL_KNOWN);
1082       else if (any_crl_too_old)
1083         rc = gpg_error (GPG_ERR_CRL_TOO_OLD);
1084       else if (any_no_policy_match)
1085         rc = gpg_error (GPG_ERR_NO_POLICY_MATCH);
1086     }
1087   
1088  leave:
1089   if (is_qualified != -1)
1090     {
1091       /* We figured something about the qualified signature capability
1092          of the certificate under question.  Store the result as user
1093          data in the certificate object.  We do this even if the
1094          validation itself failed. */
1095       /* Fixme: We should set this flag for all certificates in the
1096          chain for optimizing reasons. */
1097       char buf[1];
1098       gpg_error_t err;
1099
1100       buf[0] = !!is_qualified;
1101       err = ksba_cert_set_user_data (cert, "is_qualified", buf, 1);
1102       if (err)
1103         {
1104           log_error ("set_user_data(is_qualified) failed: %s\n",
1105                      gpg_strerror (err)); 
1106           if (!rc)
1107             rc = err;
1108         }
1109     }
1110   if (r_exptime)
1111     gnupg_copy_time (r_exptime, exptime);
1112   xfree (issuer);
1113   keydb_release (kh); 
1114   ksba_cert_release (issuer_cert);
1115   if (subject_cert != cert)
1116     ksba_cert_release (subject_cert);
1117   return rc;
1118 }
1119
1120
1121 /* Check that the given certificate is valid but DO NOT check any
1122    constraints.  We assume that the issuers certificate is already in
1123    the DB and that this one is valid; which it should be because it
1124    has been checked using this function. */
1125 int
1126 gpgsm_basic_cert_check (ksba_cert_t cert)
1127 {
1128   int rc = 0;
1129   char *issuer = NULL;
1130   char *subject = NULL;
1131   KEYDB_HANDLE kh;
1132   ksba_cert_t issuer_cert = NULL;
1133   
1134   if (opt.no_chain_validation)
1135     {
1136       log_info ("WARNING: bypassing basic certificate checks\n");
1137       return 0;
1138     }
1139
1140   kh = keydb_new (0);
1141   if (!kh)
1142     {
1143       log_error (_("failed to allocated keyDB handle\n"));
1144       rc = gpg_error (GPG_ERR_GENERAL);
1145       goto leave;
1146     }
1147
1148   issuer = ksba_cert_get_issuer (cert, 0);
1149   subject = ksba_cert_get_subject (cert, 0);
1150   if (!issuer)
1151     {
1152       log_error ("no issuer found in certificate\n");
1153       rc = gpg_error (GPG_ERR_BAD_CERT);
1154       goto leave;
1155     }
1156
1157   if (subject && !strcmp (issuer, subject))
1158     {
1159       rc = gpgsm_check_cert_sig (cert, cert);
1160       if (rc)
1161         {
1162           log_error ("self-signed certificate has a BAD signature: %s\n",
1163                      gpg_strerror (rc));
1164           if (DBG_X509)
1165             {
1166               gpgsm_dump_cert ("self-signing cert", cert);
1167             }
1168           rc = gpg_error (GPG_ERR_BAD_CERT);
1169           goto leave;
1170         }
1171     }
1172   else
1173     {
1174       /* Find the next cert up the tree. */
1175       keydb_search_reset (kh);
1176       rc = find_up (kh, cert, issuer, 0);
1177       if (rc)
1178         {
1179           if (rc == -1)
1180             {
1181               log_info ("issuer certificate (#/");
1182               gpgsm_dump_string (issuer);
1183               log_printf (") not found\n");
1184             }
1185           else
1186             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
1187           rc = gpg_error (GPG_ERR_MISSING_CERT);
1188           goto leave;
1189         }
1190       
1191       ksba_cert_release (issuer_cert); issuer_cert = NULL;
1192       rc = keydb_get_cert (kh, &issuer_cert);
1193       if (rc)
1194         {
1195           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
1196           rc = gpg_error (GPG_ERR_GENERAL);
1197           goto leave;
1198         }
1199
1200       rc = gpgsm_check_cert_sig (issuer_cert, cert);
1201       if (rc)
1202         {
1203           log_error ("certificate has a BAD signature: %s\n",
1204                      gpg_strerror (rc));
1205           if (DBG_X509)
1206             {
1207               gpgsm_dump_cert ("signing issuer", issuer_cert);
1208               gpgsm_dump_cert ("signed subject", cert);
1209             }
1210           rc = gpg_error (GPG_ERR_BAD_CERT);
1211           goto leave;
1212         }
1213       if (opt.verbose)
1214         log_info ("certificate is good\n");
1215     }
1216
1217  leave:
1218   xfree (issuer);
1219   keydb_release (kh); 
1220   ksba_cert_release (issuer_cert);
1221   return rc;
1222 }
1223
1224
1225
1226 /* Check whether the certificate CERT has been issued by the German
1227    authority for qualified signature.  They do not set the
1228    basicConstraints and thus we need this workaround.  It works by
1229    looking up the root certificate and checking whether that one is
1230    listed as a qualified certificate for Germany. 
1231
1232    We also try to cache this data but as long as don't keep a
1233    reference to the certificate this won't be used.
1234
1235    Returns: True if CERT is a RegTP issued CA cert (i.e. the root
1236    certificate itself or one of the CAs).  In that case CHAINLEN will
1237    receive the length of the chain which is either 0 or 1.
1238 */
1239 static int
1240 get_regtp_ca_info (ksba_cert_t cert, int *chainlen)
1241 {
1242   gpg_error_t err;
1243   ksba_cert_t next;
1244   int rc = 0;
1245   int i, depth;
1246   char country[3];
1247   ksba_cert_t array[4];
1248   char buf[2];
1249   size_t buflen;
1250   int dummy_chainlen;
1251
1252   if (!chainlen)
1253     chainlen = &dummy_chainlen;
1254
1255   *chainlen = 0;
1256   err = ksba_cert_get_user_data (cert, "regtp_ca_chainlen", 
1257                                  &buf, sizeof (buf), &buflen);
1258   if (!err)
1259     {
1260       /* Got info. */
1261       if (buflen < 2 || !*buf)
1262         return 0; /* Nothing found. */
1263       *chainlen = buf[1];
1264       return 1; /* This is a regtp CA. */
1265     }
1266   else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1267     {
1268       log_error ("ksba_cert_get_user_data(%s) failed: %s\n",
1269                  "regtp_ca_chainlen", gpg_strerror (err));
1270       return 0; /* Nothing found.  */
1271     }
1272
1273   /* Need to gather the info.  This requires to walk up the chain
1274      until we have found the root.  Because we are only interested in
1275      German Bundesnetzagentur (former RegTP) derived certificates 3
1276      levels are enough.  (The German signature law demands a 3 tier
1277      hierachy; thus there is only one CA between the EE and the Root
1278      CA.)  */
1279   memset (&array, 0, sizeof array);
1280
1281   depth = 0;
1282   ksba_cert_ref (cert);
1283   array[depth++] = cert;
1284   ksba_cert_ref (cert);
1285   while (depth < DIM(array) && !(rc=gpgsm_walk_cert_chain (cert, &next)))
1286     {
1287       ksba_cert_release (cert);
1288       ksba_cert_ref (next);
1289       array[depth++] = next;
1290       cert = next;
1291     }
1292   ksba_cert_release (cert);
1293   if (rc != -1 || !depth || depth == DIM(array) )
1294     {
1295       /* We did not reached the root. */
1296       goto leave;
1297     }
1298
1299   /* If this is a German signature law issued certificate, we store
1300      additional additional information. */
1301   if (!gpgsm_is_in_qualified_list (NULL, array[depth-1], country)
1302       && !strcmp (country, "de"))
1303     {
1304       /* Setting the pathlen for the root CA and the CA flag for the
1305          next one is all what we need to do. */
1306       err = ksba_cert_set_user_data (array[depth-1], "regtp_ca_chainlen",
1307                                      "\x01\x01", 2);
1308       if (!err && depth > 1)
1309         err = ksba_cert_set_user_data (array[depth-2], "regtp_ca_chainlen",
1310                                        "\x01\x00", 2);
1311       if (err)
1312         log_error ("ksba_set_user_data(%s) failed: %s\n",
1313                    "regtp_ca_chainlen", gpg_strerror (err)); 
1314       for (i=0; i < depth; i++)
1315         ksba_cert_release (array[i]);
1316       *chainlen = (depth>1? 0:1);
1317       return 1;
1318     }
1319
1320  leave:
1321   /* Nothing special with this certificate. Mark the target
1322      certificate anyway to avoid duplicate lookups. */ 
1323   err = ksba_cert_set_user_data (cert, "regtp_ca_chainlen", "", 1);
1324   if (err)
1325     log_error ("ksba_set_user_data(%s) failed: %s\n",
1326                "regtp_ca_chainlen", gpg_strerror (err)); 
1327   for (i=0; i < depth; i++)
1328     ksba_cert_release (array[i]);
1329   return 0;
1330 }