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