* configure.ac: Require libksba 0.9.11.
[gnupg.git] / sm / certchain.c
1 /* certchain.c - certificate chain validation
2  * Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h> 
27 #include <time.h>
28 #include <stdarg.h>
29 #include <assert.h>
30
31 #define JNLIB_NEED_LOG_LOGV /* We need log_logv. */
32
33 #include "gpgsm.h"
34 #include <gcrypt.h>
35 #include <ksba.h>
36
37 #include "keydb.h"
38 #include "../kbx/keybox.h" /* for KEYBOX_FLAG_* */
39 #include "i18n.h"
40
41
42 /* If LISTMODE is true, print FORMAT using LISTMODE to FP.  If
43    LISTMODE is false, use the string to print an log_info or, if
44    IS_ERROR is true, and log_error. */
45 static void
46 do_list (int is_error, int listmode, FILE *fp, const char *format, ...)
47 {
48   va_list arg_ptr;
49
50   va_start (arg_ptr, format) ;
51   if (listmode)
52     {
53       if (fp)
54         {
55           fputs ("  [", fp);
56           vfprintf (fp, format, arg_ptr);
57           fputs ("]\n", fp);
58         }
59     }
60   else
61     {
62       log_logv (is_error? JNLIB_LOG_ERROR: JNLIB_LOG_INFO, format, arg_ptr);
63       log_printf ("\n");
64     }
65   va_end (arg_ptr);
66 }
67
68 /* Return 0 if A and B are equal. */
69 static int
70 compare_certs (ksba_cert_t a, ksba_cert_t b)
71 {
72   const unsigned char *img_a, *img_b;
73   size_t len_a, len_b;
74
75   img_a = ksba_cert_get_image (a, &len_a);
76   if (!img_a)
77     return 1;
78   img_b = ksba_cert_get_image (b, &len_b);
79   if (!img_b)
80     return 1;
81   return !(len_a == len_b && !memcmp (img_a, img_b, len_a));
82 }
83
84
85 static int
86 unknown_criticals (ksba_cert_t cert, int listmode, FILE *fp)
87 {
88   static const char *known[] = {
89     "2.5.29.15", /* keyUsage */
90     "2.5.29.19", /* basic Constraints */
91     "2.5.29.32", /* certificatePolicies */
92     "2.5.29.37", /* extendedKeyUsage - handled by certlist.c */
93     NULL
94   };
95   int rc = 0, i, idx, crit;
96   const char *oid;
97   gpg_error_t err;
98
99   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
100                                              &oid, &crit, NULL, NULL));idx++)
101     {
102       if (!crit)
103         continue;
104       for (i=0; known[i] && strcmp (known[i],oid); i++)
105         ;
106       if (!known[i])
107         {
108           do_list (1, listmode, fp,
109                    _("critical certificate extension %s is not supported"),
110                    oid);
111           rc = gpg_error (GPG_ERR_UNSUPPORTED_CERT);
112         }
113     }
114   if (err && gpg_err_code (err) != GPG_ERR_EOF)
115     rc = err;
116
117   return rc;
118 }
119
120 static int
121 allowed_ca (ksba_cert_t cert, int *chainlen, int listmode, FILE *fp)
122 {
123   gpg_error_t err;
124   int flag;
125
126   err = ksba_cert_is_ca (cert, &flag, chainlen);
127   if (err)
128     return err;
129   if (!flag)
130     {
131       do_list (1, listmode, fp,_("issuer certificate is not marked as a CA"));
132       return gpg_error (GPG_ERR_BAD_CA_CERT);
133     }
134   return 0;
135 }
136
137
138 static int
139 check_cert_policy (ksba_cert_t cert, int listmode, FILE *fplist)
140 {
141   gpg_error_t err;
142   char *policies;
143   FILE *fp;
144   int any_critical;
145
146   err = ksba_cert_get_cert_policies (cert, &policies);
147   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
148     return 0; /* no policy given */
149   if (err)
150     return err;
151
152   /* STRING is a line delimited list of certifiate policies as stored
153      in the certificate.  The line itself is colon delimited where the
154      first field is the OID of the policy and the second field either
155      N or C for normal or critical extension */
156
157   if (opt.verbose > 1 && !listmode)
158     log_info ("certificate's policy list: %s\n", policies);
159
160   /* The check is very minimal but won't give false positives */
161   any_critical = !!strstr (policies, ":C");
162
163   if (!opt.policy_file)
164     { 
165       xfree (policies);
166       if (any_critical)
167         {
168           do_list (1, listmode, fplist,
169                    _("critical marked policy without configured policies"));
170           return gpg_error (GPG_ERR_NO_POLICY_MATCH);
171         }
172       return 0;
173     }
174
175   fp = fopen (opt.policy_file, "r");
176   if (!fp)
177     {
178       log_error ("failed to open `%s': %s\n",
179                  opt.policy_file, strerror (errno));
180       xfree (policies);
181       /* With no critical policies this is only a warning */
182       if (!any_critical)
183         {
184           do_list (0, listmode, fplist,
185                    _("note: non-critical certificate policy not allowed"));
186           return 0;
187         }
188       do_list (1, listmode, fplist,
189                _("certificate policy not allowed"));
190       return gpg_error (GPG_ERR_NO_POLICY_MATCH);
191     }
192
193   for (;;) 
194     {
195       int c;
196       char *p, line[256];
197       char *haystack, *allowed;
198
199       /* read line */
200       do
201         {
202           if (!fgets (line, DIM(line)-1, fp) )
203             {
204               gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
205
206               xfree (policies);
207               if (feof (fp))
208                 {
209                   fclose (fp);
210                   /* With no critical policies this is only a warning */
211                   if (!any_critical)
212                     {
213                       do_list (0, listmode, fplist,
214                      _("note: non-critical certificate policy not allowed"));
215                       return 0;
216                     }
217                   do_list (1, listmode, fplist,
218                            _("certificate policy not allowed"));
219                   return gpg_error (GPG_ERR_NO_POLICY_MATCH);
220                 }
221               fclose (fp);
222               return tmperr;
223             }
224       
225           if (!*line || line[strlen(line)-1] != '\n')
226             {
227               /* eat until end of line */
228               while ( (c=getc (fp)) != EOF && c != '\n')
229                 ;
230               fclose (fp);
231               xfree (policies);
232               return gpg_error (*line? GPG_ERR_LINE_TOO_LONG
233                                      : GPG_ERR_INCOMPLETE_LINE);
234             }
235           
236           /* Allow for empty lines and spaces */
237           for (p=line; spacep (p); p++)
238             ;
239         }
240       while (!*p || *p == '\n' || *p == '#');
241   
242       /* parse line */
243       for (allowed=line; spacep (allowed); allowed++)
244         ;
245       p = strpbrk (allowed, " :\n");
246       if (!*p || p == allowed)
247         {
248           fclose (fp);
249           xfree (policies);
250           return gpg_error (GPG_ERR_CONFIGURATION);
251         }
252       *p = 0; /* strip the rest of the line */
253       /* See whether we find ALLOWED (which is an OID) in POLICIES */
254       for (haystack=policies; (p=strstr (haystack, allowed)); haystack = p+1)
255         {
256           if ( !(p == policies || p[-1] == '\n') )
257             continue; /* Does not match the begin of a line. */
258           if (p[strlen (allowed)] != ':')
259             continue; /* The length does not match. */
260           /* Yep - it does match so return okay. */
261           fclose (fp);
262           xfree (policies);
263           return 0;
264         }
265     }
266 }
267
268
269 /* Helper fucntion for find_up.  This resets the key handle and search
270    for an issuer ISSUER with a subjectKeyIdentifier of KEYID.  Returns
271    0 obn success or -1 when not found. */
272 static int
273 find_up_search_by_keyid (KEYDB_HANDLE kh,
274                          const char *issuer, ksba_sexp_t keyid)
275 {
276   int rc;
277   ksba_cert_t cert = NULL;
278   ksba_sexp_t subj = NULL;
279
280   keydb_search_reset (kh);
281   while (!(rc = keydb_search_subject (kh, issuer)))
282     {
283       ksba_cert_release (cert); cert = NULL;
284       rc = keydb_get_cert (kh, &cert);
285       if (rc)
286         {
287           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
288           rc = -1;
289           break;
290         }
291       xfree (subj);
292       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj))
293         {
294           if (!cmp_simple_canon_sexp (keyid, subj))
295             break; /* Found matching cert. */
296         }
297     }
298   
299   ksba_cert_release (cert);
300   xfree (subj);
301   return rc? -1:0;
302 }
303
304
305 static void
306 find_up_store_certs_cb (void *cb_value, ksba_cert_t cert)
307 {
308   if (keydb_store_cert (cert, 1, NULL))
309     log_error ("error storing issuer certificate as ephemeral\n");
310   ++*(int*)cb_value;
311 }
312
313
314 /* Helper for find_up().  Locate the certificate for ISSUER using an
315    external lookup.  KH is the keydb context we are currently using.
316    On success 0 is returned and the certificate may be retrieved from
317    the keydb using keydb_get_cert().  KEYID is the keyIdentifier from
318    the AKI or NULL. */
319 static int
320 find_up_external (KEYDB_HANDLE kh, const char *issuer, ksba_sexp_t keyid)
321 {
322   int rc;
323   strlist_t names = NULL;
324   int count = 0;
325   char *pattern;
326   const char *s;
327       
328   if (opt.verbose)
329     log_info (_("looking up issuer at external location\n"));
330   /* The DIRMNGR process is confused about unknown attributes.  As a
331      quick and ugly hack we locate the CN and use the issuer string
332      starting at this attribite.  Fixme: we should have far better
333      parsing in the dirmngr. */
334   s = strstr (issuer, "CN=");
335   if (!s || s == issuer || s[-1] != ',')
336     s = issuer;
337
338   pattern = xtrymalloc (strlen (s)+2);
339   if (!pattern)
340     return gpg_error_from_errno (errno);
341   strcpy (stpcpy (pattern, "/"), s);
342   add_to_strlist (&names, pattern);
343   xfree (pattern);
344
345   rc = gpgsm_dirmngr_lookup (NULL, names, find_up_store_certs_cb, &count);
346   free_strlist (names);
347
348   if (opt.verbose)
349     log_info (_("number of issuers matching: %d\n"), count);
350   if (rc) 
351     {
352       log_error ("external key lookup failed: %s\n", gpg_strerror (rc));
353       rc = -1;
354     }
355   else if (!count)
356     rc = -1;
357   else
358     {
359       int old;
360       /* The issuers are currently stored in the ephemeral key DB, so
361          we temporary switch to ephemeral mode. */
362       old = keydb_set_ephemeral (kh, 1);
363       if (keyid)
364         rc = find_up_search_by_keyid (kh, issuer, keyid);
365       else
366         {
367           keydb_search_reset (kh);
368           rc = keydb_search_subject (kh, issuer);
369         }
370       keydb_set_ephemeral (kh, old);
371     }
372   return rc;
373 }
374
375
376 /* Locate issuing certificate for CERT. ISSUER is the name of the
377    issuer used as a fallback if the other methods don't work.  If
378    FIND_NEXT is true, the function shall return the next possible
379    issuer.  The certificate itself is not directly returned but a
380    keydb_get_cert on the keyDb context KH will return it.  Returns 0
381    on success, -1 if not found or an error code.  */
382 static int
383 find_up (KEYDB_HANDLE kh, ksba_cert_t cert, const char *issuer, int find_next)
384 {
385   ksba_name_t authid;
386   ksba_sexp_t authidno;
387   ksba_sexp_t keyid;
388   int rc = -1;
389
390   if (!ksba_cert_get_auth_key_id (cert, &keyid, &authid, &authidno))
391     {
392       const char *s = ksba_name_enum (authid, 0);
393       if (s && *authidno)
394         {
395           rc = keydb_search_issuer_sn (kh, s, authidno);
396           if (rc)
397               keydb_search_reset (kh);
398           
399           /* In case of an error try the ephemeral DB.  We can't do
400              that in find_next mode because we can't keep the search
401              state then. */
402           if (rc == -1 && !find_next)
403             { 
404               int old = keydb_set_ephemeral (kh, 1);
405               if (!old)
406                 {
407                   rc = keydb_search_issuer_sn (kh, s, authidno);
408                   if (rc)
409                     keydb_search_reset (kh);
410                 }
411               keydb_set_ephemeral (kh, old);
412             }
413
414         }
415
416       if (rc == -1 && keyid && !find_next)
417         {
418           /* Not found by AIK.issuer_sn.  Lets try the AIY.ki
419              instead. Loop over all certificates with that issuer as
420              subject and stop for the one with a matching
421              subjectKeyIdentifier. */
422           rc = find_up_search_by_keyid (kh, issuer, keyid);
423           if (rc)
424             {
425               int old = keydb_set_ephemeral (kh, 1);
426               if (!old)
427                 rc = find_up_search_by_keyid (kh, issuer, keyid);
428               keydb_set_ephemeral (kh, old);
429             }
430           if (rc) 
431             rc = -1; /* Need to make sure to have this error code. */
432         }
433
434       /* If we still didn't found it, try an external lookup.  */
435       if (rc == -1 && opt.auto_issuer_key_retrieve && !find_next)
436         rc = find_up_external (kh, issuer, keyid);
437
438       /* Print a note so that the user does not feel too helpless when
439          an issuer certificate was found and gpgsm prints BAD
440          signature because it is not the correct one. */
441       if (rc == -1)
442         {
443           log_info ("%sissuer certificate ", find_next?"next ":"");
444           if (keyid)
445             {
446               log_printf ("{");
447               gpgsm_dump_serial (keyid);
448               log_printf ("} ");
449             }
450           if (authidno)
451             {
452               log_printf ("(#");
453               gpgsm_dump_serial (authidno);
454               log_printf ("/");
455               gpgsm_dump_string (s);
456               log_printf (") ");
457             }
458           log_printf ("not found using authorityKeyIdentifier\n");
459         }
460       else if (rc)
461         log_error ("failed to find authorityKeyIdentifier: rc=%d\n", rc);
462       xfree (keyid);
463       ksba_name_release (authid);
464       xfree (authidno);
465     }
466   
467   if (rc) /* Not found via authorithyKeyIdentifier, try regular issuer name. */
468     rc = keydb_search_subject (kh, issuer);
469   if (rc == -1 && !find_next)
470     {
471       /* Not found, lets see whether we have one in the ephemeral key DB. */
472       int old = keydb_set_ephemeral (kh, 1);
473       if (!old)
474         {
475           keydb_search_reset (kh);
476           rc = keydb_search_subject (kh, issuer);
477         }
478       keydb_set_ephemeral (kh, old);
479     }
480
481   /* Still not found.  If enabled, try an external lookup.  */
482   if (rc == -1 && opt.auto_issuer_key_retrieve && !find_next)
483     rc = find_up_external (kh, issuer, NULL);
484
485   return rc;
486 }
487
488
489 /* Return the next certificate up in the chain starting at START.
490    Returns -1 when there are no more certificates. */
491 int
492 gpgsm_walk_cert_chain (ksba_cert_t start, ksba_cert_t *r_next)
493 {
494   int rc = 0; 
495   char *issuer = NULL;
496   char *subject = NULL;
497   KEYDB_HANDLE kh = keydb_new (0);
498
499   *r_next = NULL;
500   if (!kh)
501     {
502       log_error (_("failed to allocated keyDB handle\n"));
503       rc = gpg_error (GPG_ERR_GENERAL);
504       goto leave;
505     }
506
507   issuer = ksba_cert_get_issuer (start, 0);
508   subject = ksba_cert_get_subject (start, 0);
509   if (!issuer)
510     {
511       log_error ("no issuer found in certificate\n");
512       rc = gpg_error (GPG_ERR_BAD_CERT);
513       goto leave;
514     }
515   if (!subject)
516     {
517       log_error ("no subject found in certificate\n");
518       rc = gpg_error (GPG_ERR_BAD_CERT);
519       goto leave;
520     }
521
522   if (!strcmp (issuer, subject))
523     {
524       rc = -1; /* we are at the root */
525       goto leave; 
526     }
527
528   rc = find_up (kh, start, issuer, 0);
529   if (rc)
530     {
531       /* it is quite common not to have a certificate, so better don't
532          print an error here */
533       if (rc != -1 && opt.verbose > 1)
534         log_error ("failed to find issuer's certificate: rc=%d\n", rc);
535       rc = gpg_error (GPG_ERR_MISSING_CERT);
536       goto leave;
537     }
538
539   rc = keydb_get_cert (kh, r_next);
540   if (rc)
541     {
542       log_error ("keydb_get_cert() failed: rc=%d\n", rc);
543       rc = gpg_error (GPG_ERR_GENERAL);
544     }
545
546  leave:
547   xfree (issuer);
548   xfree (subject);
549   keydb_release (kh); 
550   return rc;
551 }
552
553
554 /* Check whether the CERT is a root certificate.  Returns True if this
555    is the case. */
556 int
557 gpgsm_is_root_cert (ksba_cert_t cert)
558 {
559   char *issuer;
560   char *subject;
561   int yes;
562
563   issuer = ksba_cert_get_issuer (cert, 0);
564   subject = ksba_cert_get_subject (cert, 0);
565   yes = (issuer && subject && !strcmp (issuer, subject));
566   xfree (issuer);
567   xfree (subject);
568   return yes;
569 }
570
571
572 /* This is a helper for gpgsm_validate_chain. */
573 static gpg_error_t 
574 is_cert_still_valid (ctrl_t ctrl, int lm, FILE *fp,
575                      ksba_cert_t subject_cert, ksba_cert_t issuer_cert,
576                      int *any_revoked, int *any_no_crl, int *any_crl_too_old)
577 {
578   if (!opt.no_crl_check || ctrl->use_ocsp)
579     {
580       gpg_error_t err;
581
582       err = gpgsm_dirmngr_isvalid (ctrl,
583                                    subject_cert, issuer_cert, ctrl->use_ocsp);
584       if (err)
585         {
586           /* Fixme: We should change the wording because we may
587              have used OCSP. */
588           switch (gpg_err_code (err))
589             {
590             case GPG_ERR_CERT_REVOKED:
591               do_list (1, lm, fp, _("certificate has been revoked"));
592               *any_revoked = 1;
593               /* Store that in the keybox so that key listings are
594                  able to return the revoked flag.  We don't care
595                  about error, though. */
596               keydb_set_cert_flags (subject_cert, KEYBOX_FLAG_VALIDITY, 0,
597                                     VALIDITY_REVOKED);
598               break;
599             case GPG_ERR_NO_CRL_KNOWN:
600               do_list (1, lm, fp, _("no CRL found for certificate"));
601               *any_no_crl = 1;
602               break;
603             case GPG_ERR_CRL_TOO_OLD:
604               do_list (1, lm, fp, _("the available CRL is too old"));
605               if (!lm)
606                 log_info (_("please make sure that the "
607                             "\"dirmngr\" is properly installed\n"));
608               *any_crl_too_old = 1;
609               break;
610             default:
611               do_list (1, lm, fp, _("checking the CRL failed: %s"),
612                        gpg_strerror (err));
613               return err;
614             }
615         }
616     }
617   return 0;
618 }
619
620
621 \f
622 /* Validate a chain and optionally return the nearest expiration time
623    in R_EXPTIME. With LISTMODE set to 1 a special listmode is
624    activated where only information about the certificate is printed
625    to FP and no output is send to the usual log stream. 
626
627    Defined flag bits: 0 - do not do any dirmngr isvalid checks.
628 */
629 int
630 gpgsm_validate_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t r_exptime,
631                       int listmode, FILE *fp, unsigned int flags)
632 {
633   int rc = 0, depth = 0, maxdepth;
634   char *issuer = NULL;
635   char *subject = NULL;
636   KEYDB_HANDLE kh = NULL;
637   ksba_cert_t subject_cert = NULL, issuer_cert = NULL;
638   ksba_isotime_t current_time;
639   ksba_isotime_t exptime;
640   int any_expired = 0;
641   int any_revoked = 0;
642   int any_no_crl = 0;
643   int any_crl_too_old = 0;
644   int any_no_policy_match = 0;
645   int lm = listmode;
646
647   gnupg_get_isotime (current_time);
648   if (r_exptime)
649     *r_exptime = 0;
650   *exptime = 0;
651
652   if (opt.no_chain_validation && !listmode)
653     {
654       log_info ("WARNING: bypassing certificate chain validation\n");
655       return 0;
656     }
657
658   kh = keydb_new (0);
659   if (!kh)
660     {
661       log_error (_("failed to allocated keyDB handle\n"));
662       rc = gpg_error (GPG_ERR_GENERAL);
663       goto leave;
664     }
665
666   if (DBG_X509 && !listmode)
667     gpgsm_dump_cert ("target", cert);
668
669   subject_cert = cert;
670   maxdepth = 50;
671
672   for (;;)
673     {
674       xfree (issuer);
675       xfree (subject);
676       issuer = ksba_cert_get_issuer (subject_cert, 0);
677       subject = ksba_cert_get_subject (subject_cert, 0);
678
679       if (!issuer)
680         {
681           do_list (1, lm, fp,  _("no issuer found in certificate"));
682           rc = gpg_error (GPG_ERR_BAD_CERT);
683           goto leave;
684         }
685
686       {
687         ksba_isotime_t not_before, not_after;
688
689         rc = ksba_cert_get_validity (subject_cert, 0, not_before);
690         if (!rc)
691           rc = ksba_cert_get_validity (subject_cert, 1, not_after);
692         if (rc)
693           {
694             do_list (1, lm, fp, _("certificate with invalid validity: %s"),
695                      gpg_strerror (rc));
696             rc = gpg_error (GPG_ERR_BAD_CERT);
697             goto leave;
698           }
699
700         if (*not_after)
701           {
702             if (!*exptime)
703               gnupg_copy_time (exptime, not_after);
704             else if (strcmp (not_after, exptime) < 0 )
705               gnupg_copy_time (exptime, not_after);
706           }
707
708         if (*not_before && strcmp (current_time, not_before) < 0 )
709           {
710             do_list (1, lm, fp, _("certificate not yet valid"));
711             if (!lm)
712               {
713                 log_info ("(valid from ");
714                 gpgsm_dump_time (not_before);
715                 log_printf (")\n");
716               }
717             rc = gpg_error (GPG_ERR_CERT_TOO_YOUNG);
718             goto leave;
719           }            
720         if (*not_after && strcmp (current_time, not_after) > 0 )
721           {
722             do_list (opt.ignore_expiration?0:1, lm, fp,
723                      _("certificate has expired"));
724             if (!lm)
725               {
726                 log_info ("(expired at ");
727                 gpgsm_dump_time (not_after);
728                 log_printf (")\n");
729               }
730             if (opt.ignore_expiration)
731                 log_info ("WARNING: ignoring expiration\n");
732             else
733               any_expired = 1;
734           }            
735       }
736
737       rc = unknown_criticals (subject_cert, listmode, fp);
738       if (rc)
739         goto leave;
740
741       if (!opt.no_policy_check)
742         {
743           rc = check_cert_policy (subject_cert, listmode, fp);
744           if (gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH)
745             {
746               any_no_policy_match = 1;
747               rc = 1;
748             }
749           else if (rc)
750             goto leave;
751         }
752
753
754       /* Is this a self-signed certificate? */
755       if (subject && !strcmp (issuer, subject))
756         {  /* Yes. */
757           if (gpgsm_check_cert_sig (subject_cert, subject_cert) )
758             {
759               do_list (1, lm, fp,
760                        _("selfsigned certificate has a BAD signature"));
761               if (DBG_X509)
762                 {
763                   gpgsm_dump_cert ("self-signing cert", subject_cert);
764                 }
765               rc = gpg_error (depth? GPG_ERR_BAD_CERT_CHAIN
766                                    : GPG_ERR_BAD_CERT);
767               goto leave;
768             }
769           rc = allowed_ca (subject_cert, NULL, listmode, fp);
770           if (rc)
771             goto leave;
772
773           rc = gpgsm_agent_istrusted (ctrl, subject_cert);
774           if (!rc)
775             ;
776           else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
777             {
778               do_list (0, lm, fp, _("root certificate is not marked trusted"));
779               /* If we already figured out that the certificate is
780                  expired it does not make much sense to ask the user
781                  whether we wants to trust the root certificate.  He
782                  should do this only if the certificate under question
783                  will then be usable. */
784               if (!lm && !any_expired)
785                 {
786                   int rc2;
787                   char *fpr = gpgsm_get_fingerprint_string (subject_cert,
788                                                             GCRY_MD_SHA1);
789                   log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
790                   xfree (fpr);
791                   rc2 = gpgsm_agent_marktrusted (ctrl, subject_cert);
792                   if (!rc2)
793                     {
794                       log_info (_("root certificate has now"
795                                   " been marked as trusted\n"));
796                       rc = 0;
797                     }
798                   else 
799                     {
800                       gpgsm_dump_cert ("issuer", subject_cert);
801                       log_info ("after checking the fingerprint, you may want "
802                                 "to add it manually to the list of trusted "
803                                 "certificates.\n");
804                     }
805                 }
806             }
807           else 
808             {
809               log_error (_("checking the trust list failed: %s\n"),
810                          gpg_strerror (rc));
811             }
812           
813           if (rc)
814             goto leave;
815
816           /* Check for revocations etc. */
817           if ((flags & 1))
818             rc = 0;
819           else if (any_expired)
820             ; /* Don't bother to run the expensive CRL check then. */
821           else
822             rc = is_cert_still_valid (ctrl, lm, fp,
823                                       subject_cert, subject_cert,
824                                       &any_revoked, &any_no_crl,
825                                       &any_crl_too_old);
826           if (rc)
827             goto leave;
828
829           break;  /* Okay: a self-signed certicate is an end-point. */
830         }
831       
832       depth++;
833       if (depth > maxdepth)
834         {
835           do_list (1, lm, fp, _("certificate chain too long\n"));
836           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
837           goto leave;
838         }
839
840       /* find the next cert up the tree */
841       keydb_search_reset (kh);
842       rc = find_up (kh, subject_cert, issuer, 0);
843       if (rc)
844         {
845           if (rc == -1)
846             {
847               do_list (0, lm, fp, _("issuer certificate not found"));
848               if (!lm)
849                 {
850                   log_info ("issuer certificate: #/");
851                   gpgsm_dump_string (issuer);
852                   log_printf ("\n");
853                 }
854             }
855           else
856             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
857           rc = gpg_error (GPG_ERR_MISSING_CERT);
858           goto leave;
859         }
860
861       ksba_cert_release (issuer_cert); issuer_cert = NULL;
862       rc = keydb_get_cert (kh, &issuer_cert);
863       if (rc)
864         {
865           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
866           rc = gpg_error (GPG_ERR_GENERAL);
867           goto leave;
868         }
869
870     try_another_cert:
871       if (DBG_X509)
872         {
873           log_debug ("got issuer's certificate:\n");
874           gpgsm_dump_cert ("issuer", issuer_cert);
875         }
876
877       rc = gpgsm_check_cert_sig (issuer_cert, subject_cert);
878       if (rc)
879         {
880           do_list (0, lm, fp, _("certificate has a BAD signature"));
881           if (DBG_X509)
882             {
883               gpgsm_dump_cert ("signing issuer", issuer_cert);
884               gpgsm_dump_cert ("signed subject", subject_cert);
885             }
886           if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
887             {
888               /* We now try to find other issuer certificates which
889                  might have been used.  This is required because some
890                  CAs are reusing the issuer and subject DN for new
891                  root certificates. */
892               /* FIXME: Do this only if we don't have an
893                  AKI.keyIdentifier */
894               rc = find_up (kh, subject_cert, issuer, 1);
895               if (!rc)
896                 {
897                   ksba_cert_t tmp_cert;
898
899                   rc = keydb_get_cert (kh, &tmp_cert);
900                   if (rc || !compare_certs (issuer_cert, tmp_cert))
901                     {
902                       /* The find next did not work or returned an
903                          identical certificate.  We better stop here
904                          to avoid infinite checks. */
905                       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
906                       ksba_cert_release (tmp_cert);
907                     }
908                   else
909                     {
910                       do_list (0, lm, fp, _("found another possible matching "
911                                             "CA certificate - trying again"));
912                       ksba_cert_release (issuer_cert); 
913                       issuer_cert = tmp_cert;
914                       goto try_another_cert;
915                     }
916                 }
917             }
918
919           /* We give a more descriptive error code than the one
920              returned from the signature checking. */
921           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
922           goto leave;
923         }
924
925       {
926         int chainlen;
927         rc = allowed_ca (issuer_cert, &chainlen, listmode, fp);
928         if (rc)
929           goto leave;
930         if (chainlen >= 0 && (depth - 1) > chainlen)
931           {
932             do_list (1, lm, fp,
933                      _("certificate chain longer than allowed by CA (%d)"),
934                      chainlen);
935             rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
936             goto leave;
937           }
938       }
939
940       if (!listmode)
941         {
942           rc = gpgsm_cert_use_cert_p (issuer_cert);
943           if (rc)
944             {
945               char numbuf[50];
946               sprintf (numbuf, "%d", rc);
947               gpgsm_status2 (ctrl, STATUS_ERROR, "certcert.issuer.keyusage",
948                              numbuf, NULL);
949               goto leave;
950             }
951         }
952
953       /* Check for revocations etc. */
954       if ((flags & 1))
955         rc = 0;
956       else if (any_expired)
957         ; /* Don't bother to run the expensive CRL check then. */
958       else
959         rc = is_cert_still_valid (ctrl, lm, fp,
960                                   subject_cert, issuer_cert,
961                                   &any_revoked, &any_no_crl, &any_crl_too_old);
962       if (rc)
963         goto leave;
964
965
966       if (opt.verbose && !listmode)
967         log_info ("certificate is good\n");
968       
969       keydb_search_reset (kh);
970       subject_cert = issuer_cert;
971       issuer_cert = NULL;
972     }
973
974   if (!listmode)
975     {
976       if (opt.no_policy_check)
977         log_info ("policies not checked due to %s option\n",
978                   "--disable-policy-checks");
979       if (opt.no_crl_check && !ctrl->use_ocsp)
980         log_info ("CRLs not checked due to %s option\n",
981                   "--disable-crl-checks");
982     }
983
984   if (!rc)
985     { /* If we encountered an error somewhere during the checks, set
986          the error code to the most critical one */
987       if (any_revoked)
988         rc = gpg_error (GPG_ERR_CERT_REVOKED);
989       else if (any_expired)
990         rc = gpg_error (GPG_ERR_CERT_EXPIRED);
991       else if (any_no_crl)
992         rc = gpg_error (GPG_ERR_NO_CRL_KNOWN);
993       else if (any_crl_too_old)
994         rc = gpg_error (GPG_ERR_CRL_TOO_OLD);
995       else if (any_no_policy_match)
996         rc = gpg_error (GPG_ERR_NO_POLICY_MATCH);
997     }
998   
999  leave:
1000   if (r_exptime)
1001     gnupg_copy_time (r_exptime, exptime);
1002   xfree (issuer);
1003   keydb_release (kh); 
1004   ksba_cert_release (issuer_cert);
1005   if (subject_cert != cert)
1006     ksba_cert_release (subject_cert);
1007   return rc;
1008 }
1009
1010
1011 /* Check that the given certificate is valid but DO NOT check any
1012    constraints.  We assume that the issuers certificate is already in
1013    the DB and that this one is valid; which it should be because it
1014    has been checked using this function. */
1015 int
1016 gpgsm_basic_cert_check (ksba_cert_t cert)
1017 {
1018   int rc = 0;
1019   char *issuer = NULL;
1020   char *subject = NULL;
1021   KEYDB_HANDLE kh = keydb_new (0);
1022   ksba_cert_t issuer_cert = NULL;
1023   
1024   if (opt.no_chain_validation)
1025     {
1026       log_info ("WARNING: bypassing basic certificate checks\n");
1027       return 0;
1028     }
1029
1030   if (!kh)
1031     {
1032       log_error (_("failed to allocated keyDB handle\n"));
1033       rc = gpg_error (GPG_ERR_GENERAL);
1034       goto leave;
1035     }
1036
1037   issuer = ksba_cert_get_issuer (cert, 0);
1038   subject = ksba_cert_get_subject (cert, 0);
1039   if (!issuer)
1040     {
1041       log_error ("no issuer found in certificate\n");
1042       rc = gpg_error (GPG_ERR_BAD_CERT);
1043       goto leave;
1044     }
1045
1046   if (subject && !strcmp (issuer, subject))
1047     {
1048       rc = gpgsm_check_cert_sig (cert, cert);
1049       if (rc)
1050         {
1051           log_error ("selfsigned certificate has a BAD signature: %s\n",
1052                      gpg_strerror (rc));
1053           if (DBG_X509)
1054             {
1055               gpgsm_dump_cert ("self-signing cert", cert);
1056             }
1057           rc = gpg_error (GPG_ERR_BAD_CERT);
1058           goto leave;
1059         }
1060     }
1061   else
1062     {
1063       /* Find the next cert up the tree. */
1064       keydb_search_reset (kh);
1065       rc = find_up (kh, cert, issuer, 0);
1066       if (rc)
1067         {
1068           if (rc == -1)
1069             {
1070               log_info ("issuer certificate (#/");
1071               gpgsm_dump_string (issuer);
1072               log_printf (") not found\n");
1073             }
1074           else
1075             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
1076           rc = gpg_error (GPG_ERR_MISSING_CERT);
1077           goto leave;
1078         }
1079       
1080       ksba_cert_release (issuer_cert); issuer_cert = NULL;
1081       rc = keydb_get_cert (kh, &issuer_cert);
1082       if (rc)
1083         {
1084           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
1085           rc = gpg_error (GPG_ERR_GENERAL);
1086           goto leave;
1087         }
1088
1089       rc = gpgsm_check_cert_sig (issuer_cert, cert);
1090       if (rc)
1091         {
1092           log_error ("certificate has a BAD signature: %s\n",
1093                      gpg_strerror (rc));
1094           if (DBG_X509)
1095             {
1096               gpgsm_dump_cert ("signing issuer", issuer_cert);
1097               gpgsm_dump_cert ("signed subject", cert);
1098             }
1099           rc = gpg_error (GPG_ERR_BAD_CERT);
1100           goto leave;
1101         }
1102       if (opt.verbose)
1103         log_info ("certificate is good\n");
1104     }
1105
1106  leave:
1107   xfree (issuer);
1108   keydb_release (kh); 
1109   ksba_cert_release (issuer_cert);
1110   return rc;
1111 }
1112