* configure.ac: Do not build gpg by default.
[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-issued 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                        _("self-signed 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             ;
820           else if (opt.no_trusted_cert_crl_check)
821             ; 
822           else
823             rc = is_cert_still_valid (ctrl, lm, fp,
824                                       subject_cert, subject_cert,
825                                       &any_revoked, &any_no_crl,
826                                       &any_crl_too_old);
827           if (rc)
828             goto leave;
829
830           break;  /* Okay: a self-signed certicate is an end-point. */
831         }
832       
833       depth++;
834       if (depth > maxdepth)
835         {
836           do_list (1, lm, fp, _("certificate chain too long\n"));
837           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
838           goto leave;
839         }
840
841       /* find the next cert up the tree */
842       keydb_search_reset (kh);
843       rc = find_up (kh, subject_cert, issuer, 0);
844       if (rc)
845         {
846           if (rc == -1)
847             {
848               do_list (0, lm, fp, _("issuer certificate not found"));
849               if (!lm)
850                 {
851                   log_info ("issuer certificate: #/");
852                   gpgsm_dump_string (issuer);
853                   log_printf ("\n");
854                 }
855             }
856           else
857             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
858           rc = gpg_error (GPG_ERR_MISSING_CERT);
859           goto leave;
860         }
861
862       ksba_cert_release (issuer_cert); issuer_cert = NULL;
863       rc = keydb_get_cert (kh, &issuer_cert);
864       if (rc)
865         {
866           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
867           rc = gpg_error (GPG_ERR_GENERAL);
868           goto leave;
869         }
870
871     try_another_cert:
872       if (DBG_X509)
873         {
874           log_debug ("got issuer's certificate:\n");
875           gpgsm_dump_cert ("issuer", issuer_cert);
876         }
877
878       rc = gpgsm_check_cert_sig (issuer_cert, subject_cert);
879       if (rc)
880         {
881           do_list (0, lm, fp, _("certificate has a BAD signature"));
882           if (DBG_X509)
883             {
884               gpgsm_dump_cert ("signing issuer", issuer_cert);
885               gpgsm_dump_cert ("signed subject", subject_cert);
886             }
887           if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
888             {
889               /* We now try to find other issuer certificates which
890                  might have been used.  This is required because some
891                  CAs are reusing the issuer and subject DN for new
892                  root certificates. */
893               /* FIXME: Do this only if we don't have an
894                  AKI.keyIdentifier */
895               rc = find_up (kh, subject_cert, issuer, 1);
896               if (!rc)
897                 {
898                   ksba_cert_t tmp_cert;
899
900                   rc = keydb_get_cert (kh, &tmp_cert);
901                   if (rc || !compare_certs (issuer_cert, tmp_cert))
902                     {
903                       /* The find next did not work or returned an
904                          identical certificate.  We better stop here
905                          to avoid infinite checks. */
906                       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
907                       ksba_cert_release (tmp_cert);
908                     }
909                   else
910                     {
911                       do_list (0, lm, fp, _("found another possible matching "
912                                             "CA certificate - trying again"));
913                       ksba_cert_release (issuer_cert); 
914                       issuer_cert = tmp_cert;
915                       goto try_another_cert;
916                     }
917                 }
918             }
919
920           /* We give a more descriptive error code than the one
921              returned from the signature checking. */
922           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
923           goto leave;
924         }
925
926       {
927         int chainlen;
928         rc = allowed_ca (issuer_cert, &chainlen, listmode, fp);
929         if (rc)
930           goto leave;
931         if (chainlen >= 0 && (depth - 1) > chainlen)
932           {
933             do_list (1, lm, fp,
934                      _("certificate chain longer than allowed by CA (%d)"),
935                      chainlen);
936             rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
937             goto leave;
938           }
939       }
940
941       if (!listmode)
942         {
943           rc = gpgsm_cert_use_cert_p (issuer_cert);
944           if (rc)
945             {
946               char numbuf[50];
947               sprintf (numbuf, "%d", rc);
948               gpgsm_status2 (ctrl, STATUS_ERROR, "certcert.issuer.keyusage",
949                              numbuf, NULL);
950               goto leave;
951             }
952         }
953
954       /* Check for revocations etc. */
955       if ((flags & 1))
956         rc = 0;
957       else
958         rc = is_cert_still_valid (ctrl, lm, fp,
959                                   subject_cert, issuer_cert,
960                                   &any_revoked, &any_no_crl, &any_crl_too_old);
961       if (rc)
962         goto leave;
963
964
965       if (opt.verbose && !listmode)
966         log_info ("certificate is good\n");
967       
968       keydb_search_reset (kh);
969       subject_cert = issuer_cert;
970       issuer_cert = NULL;
971     }
972
973   if (!listmode)
974     {
975       if (opt.no_policy_check)
976         log_info ("policies not checked due to %s option\n",
977                   "--disable-policy-checks");
978       if (opt.no_crl_check && !ctrl->use_ocsp)
979         log_info ("CRLs not checked due to %s option\n",
980                   "--disable-crl-checks");
981     }
982
983   if (!rc)
984     { /* If we encountered an error somewhere during the checks, set
985          the error code to the most critical one */
986       if (any_revoked)
987         rc = gpg_error (GPG_ERR_CERT_REVOKED);
988       else if (any_expired)
989         rc = gpg_error (GPG_ERR_CERT_EXPIRED);
990       else if (any_no_crl)
991         rc = gpg_error (GPG_ERR_NO_CRL_KNOWN);
992       else if (any_crl_too_old)
993         rc = gpg_error (GPG_ERR_CRL_TOO_OLD);
994       else if (any_no_policy_match)
995         rc = gpg_error (GPG_ERR_NO_POLICY_MATCH);
996     }
997   
998  leave:
999   if (r_exptime)
1000     gnupg_copy_time (r_exptime, exptime);
1001   xfree (issuer);
1002   keydb_release (kh); 
1003   ksba_cert_release (issuer_cert);
1004   if (subject_cert != cert)
1005     ksba_cert_release (subject_cert);
1006   return rc;
1007 }
1008
1009
1010 /* Check that the given certificate is valid but DO NOT check any
1011    constraints.  We assume that the issuers certificate is already in
1012    the DB and that this one is valid; which it should be because it
1013    has been checked using this function. */
1014 int
1015 gpgsm_basic_cert_check (ksba_cert_t cert)
1016 {
1017   int rc = 0;
1018   char *issuer = NULL;
1019   char *subject = NULL;
1020   KEYDB_HANDLE kh = keydb_new (0);
1021   ksba_cert_t issuer_cert = NULL;
1022   
1023   if (opt.no_chain_validation)
1024     {
1025       log_info ("WARNING: bypassing basic certificate checks\n");
1026       return 0;
1027     }
1028
1029   if (!kh)
1030     {
1031       log_error (_("failed to allocated keyDB handle\n"));
1032       rc = gpg_error (GPG_ERR_GENERAL);
1033       goto leave;
1034     }
1035
1036   issuer = ksba_cert_get_issuer (cert, 0);
1037   subject = ksba_cert_get_subject (cert, 0);
1038   if (!issuer)
1039     {
1040       log_error ("no issuer found in certificate\n");
1041       rc = gpg_error (GPG_ERR_BAD_CERT);
1042       goto leave;
1043     }
1044
1045   if (subject && !strcmp (issuer, subject))
1046     {
1047       rc = gpgsm_check_cert_sig (cert, cert);
1048       if (rc)
1049         {
1050           log_error ("self-signed certificate has a BAD signature: %s\n",
1051                      gpg_strerror (rc));
1052           if (DBG_X509)
1053             {
1054               gpgsm_dump_cert ("self-signing cert", cert);
1055             }
1056           rc = gpg_error (GPG_ERR_BAD_CERT);
1057           goto leave;
1058         }
1059     }
1060   else
1061     {
1062       /* Find the next cert up the tree. */
1063       keydb_search_reset (kh);
1064       rc = find_up (kh, cert, issuer, 0);
1065       if (rc)
1066         {
1067           if (rc == -1)
1068             {
1069               log_info ("issuer certificate (#/");
1070               gpgsm_dump_string (issuer);
1071               log_printf (") not found\n");
1072             }
1073           else
1074             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
1075           rc = gpg_error (GPG_ERR_MISSING_CERT);
1076           goto leave;
1077         }
1078       
1079       ksba_cert_release (issuer_cert); issuer_cert = NULL;
1080       rc = keydb_get_cert (kh, &issuer_cert);
1081       if (rc)
1082         {
1083           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
1084           rc = gpg_error (GPG_ERR_GENERAL);
1085           goto leave;
1086         }
1087
1088       rc = gpgsm_check_cert_sig (issuer_cert, cert);
1089       if (rc)
1090         {
1091           log_error ("certificate has a BAD signature: %s\n",
1092                      gpg_strerror (rc));
1093           if (DBG_X509)
1094             {
1095               gpgsm_dump_cert ("signing issuer", issuer_cert);
1096               gpgsm_dump_cert ("signed subject", cert);
1097             }
1098           rc = gpg_error (GPG_ERR_BAD_CERT);
1099           goto leave;
1100         }
1101       if (opt.verbose)
1102         log_info ("certificate is good\n");
1103     }
1104
1105  leave:
1106   xfree (issuer);
1107   keydb_release (kh); 
1108   ksba_cert_release (issuer_cert);
1109   return rc;
1110 }
1111