Added qualified signature features.
[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 is_qualified = -1; /* Indicates whether the certificate stems
647                             from a qualified root certificate.
648                             -1 = unknown, 0 = no, 1 = yes. */
649   int lm = listmode;
650
651   gnupg_get_isotime (current_time);
652   if (r_exptime)
653     *r_exptime = 0;
654   *exptime = 0;
655
656   if (opt.no_chain_validation && !listmode)
657     {
658       log_info ("WARNING: bypassing certificate chain validation\n");
659       return 0;
660     }
661
662   kh = keydb_new (0);
663   if (!kh)
664     {
665       log_error (_("failed to allocated keyDB handle\n"));
666       rc = gpg_error (GPG_ERR_GENERAL);
667       goto leave;
668     }
669
670   if (DBG_X509 && !listmode)
671     gpgsm_dump_cert ("target", cert);
672
673   subject_cert = cert;
674   maxdepth = 50;
675
676   for (;;)
677     {
678       xfree (issuer);
679       xfree (subject);
680       issuer = ksba_cert_get_issuer (subject_cert, 0);
681       subject = ksba_cert_get_subject (subject_cert, 0);
682
683       if (!issuer)
684         {
685           do_list (1, lm, fp,  _("no issuer found in certificate"));
686           rc = gpg_error (GPG_ERR_BAD_CERT);
687           goto leave;
688         }
689
690       {
691         ksba_isotime_t not_before, not_after;
692
693         rc = ksba_cert_get_validity (subject_cert, 0, not_before);
694         if (!rc)
695           rc = ksba_cert_get_validity (subject_cert, 1, not_after);
696         if (rc)
697           {
698             do_list (1, lm, fp, _("certificate with invalid validity: %s"),
699                      gpg_strerror (rc));
700             rc = gpg_error (GPG_ERR_BAD_CERT);
701             goto leave;
702           }
703
704         if (*not_after)
705           {
706             if (!*exptime)
707               gnupg_copy_time (exptime, not_after);
708             else if (strcmp (not_after, exptime) < 0 )
709               gnupg_copy_time (exptime, not_after);
710           }
711
712         if (*not_before && strcmp (current_time, not_before) < 0 )
713           {
714             do_list (1, lm, fp, _("certificate not yet valid"));
715             if (!lm)
716               {
717                 log_info ("(valid from ");
718                 gpgsm_dump_time (not_before);
719                 log_printf (")\n");
720               }
721             rc = gpg_error (GPG_ERR_CERT_TOO_YOUNG);
722             goto leave;
723           }            
724         if (*not_after && strcmp (current_time, not_after) > 0 )
725           {
726             do_list (opt.ignore_expiration?0:1, lm, fp,
727                      _("certificate has expired"));
728             if (!lm)
729               {
730                 log_info ("(expired at ");
731                 gpgsm_dump_time (not_after);
732                 log_printf (")\n");
733               }
734             if (opt.ignore_expiration)
735                 log_info ("WARNING: ignoring expiration\n");
736             else
737               any_expired = 1;
738           }            
739       }
740
741       rc = unknown_criticals (subject_cert, listmode, fp);
742       if (rc)
743         goto leave;
744
745       if (!opt.no_policy_check)
746         {
747           rc = check_cert_policy (subject_cert, listmode, fp);
748           if (gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH)
749             {
750               any_no_policy_match = 1;
751               rc = 1;
752             }
753           else if (rc)
754             goto leave;
755         }
756
757
758       /* Is this a self-issued certificate? */
759       if (subject && !strcmp (issuer, subject))
760         {  /* Yes. */
761           if (gpgsm_check_cert_sig (subject_cert, subject_cert) )
762             {
763               do_list (1, lm, fp,
764                        _("self-signed certificate has a BAD signature"));
765               if (DBG_X509)
766                 {
767                   gpgsm_dump_cert ("self-signing cert", subject_cert);
768                 }
769               rc = gpg_error (depth? GPG_ERR_BAD_CERT_CHAIN
770                                    : GPG_ERR_BAD_CERT);
771               goto leave;
772             }
773           rc = allowed_ca (subject_cert, NULL, listmode, fp);
774           if (rc)
775             goto leave;
776
777           
778           /* Set the flag for qualified signatures.  This flag is
779              deduced from a list of root certificates allowed for
780              qualified signatures. */
781           if (is_qualified == -1)
782             {
783               gpg_error_t err;
784               size_t buflen;
785               char buf[1];
786               
787               if (!ksba_cert_get_user_data (cert, "is_qualified", 
788                                             &buf, sizeof (buf),
789                                             &buflen) && buflen)
790                 {
791                   /* We already checked this for this certificate,
792                      thus we simply take it from the user data. */
793                   is_qualified = !!*buf;
794                 }    
795               else
796                 {
797                   /* Need to consult the list of root certificates for
798                      qualified signatures. */
799                   err = gpgsm_is_in_qualified_list (ctrl, subject_cert);
800                   if (!err)
801                     is_qualified = 1;
802                   else if ( gpg_err_code (err) == GPG_ERR_NOT_FOUND)
803                     is_qualified = 0;
804                   else
805                     log_error ("checking the list of qualified "
806                                "root certificates failed: %s\n",
807                                gpg_strerror (err));
808                   if ( is_qualified != -1 )
809                     {
810                       /* Cache the result but don't care toomuch about
811                          an error. */
812                       buf[0] = !!is_qualified;
813                       err = ksba_cert_set_user_data (subject_cert,
814                                                      "is_qualified", buf, 1);
815                       if (err)
816                         log_error ("set_user_data(is_qualified) failed: %s\n",
817                                    gpg_strerror (err)); 
818                     }
819                 }
820             }
821
822
823           /* Check whether we really trust this root certificate. */
824           rc = gpgsm_agent_istrusted (ctrl, subject_cert);
825           if (!rc)
826             ;
827           else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
828             {
829               do_list (0, lm, fp, _("root certificate is not marked trusted"));
830               /* If we already figured out that the certificate is
831                  expired it does not make much sense to ask the user
832                  whether we wants to trust the root certificate.  He
833                  should do this only if the certificate under question
834                  will then be usable. */
835               if (!lm && !any_expired)
836                 {
837                   int rc2;
838                   char *fpr = gpgsm_get_fingerprint_string (subject_cert,
839                                                             GCRY_MD_SHA1);
840                   log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
841                   xfree (fpr);
842                   rc2 = gpgsm_agent_marktrusted (ctrl, subject_cert);
843                   if (!rc2)
844                     {
845                       log_info (_("root certificate has now"
846                                   " been marked as trusted\n"));
847                       rc = 0;
848                     }
849                   else 
850                     {
851                       gpgsm_dump_cert ("issuer", subject_cert);
852                       log_info ("after checking the fingerprint, you may want "
853                                 "to add it manually to the list of trusted "
854                                 "certificates.\n");
855                     }
856                 }
857             }
858           else 
859             {
860               log_error (_("checking the trust list failed: %s\n"),
861                          gpg_strerror (rc));
862             }
863           
864           if (rc)
865             goto leave;
866
867           /* Check for revocations etc. */
868           if ((flags & 1))
869             ;
870           else if (opt.no_trusted_cert_crl_check)
871             ; 
872           else
873             rc = is_cert_still_valid (ctrl, lm, fp,
874                                       subject_cert, subject_cert,
875                                       &any_revoked, &any_no_crl,
876                                       &any_crl_too_old);
877           if (rc)
878             goto leave;
879
880           break;  /* Okay: a self-signed certicate is an end-point. */
881         }
882       
883       depth++;
884       if (depth > maxdepth)
885         {
886           do_list (1, lm, fp, _("certificate chain too long\n"));
887           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
888           goto leave;
889         }
890
891       /* find the next cert up the tree */
892       keydb_search_reset (kh);
893       rc = find_up (kh, subject_cert, issuer, 0);
894       if (rc)
895         {
896           if (rc == -1)
897             {
898               do_list (0, lm, fp, _("issuer certificate not found"));
899               if (!lm)
900                 {
901                   log_info ("issuer certificate: #/");
902                   gpgsm_dump_string (issuer);
903                   log_printf ("\n");
904                 }
905             }
906           else
907             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
908           rc = gpg_error (GPG_ERR_MISSING_CERT);
909           goto leave;
910         }
911
912       ksba_cert_release (issuer_cert); issuer_cert = NULL;
913       rc = keydb_get_cert (kh, &issuer_cert);
914       if (rc)
915         {
916           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
917           rc = gpg_error (GPG_ERR_GENERAL);
918           goto leave;
919         }
920
921     try_another_cert:
922       if (DBG_X509)
923         {
924           log_debug ("got issuer's certificate:\n");
925           gpgsm_dump_cert ("issuer", issuer_cert);
926         }
927
928       rc = gpgsm_check_cert_sig (issuer_cert, subject_cert);
929       if (rc)
930         {
931           do_list (0, lm, fp, _("certificate has a BAD signature"));
932           if (DBG_X509)
933             {
934               gpgsm_dump_cert ("signing issuer", issuer_cert);
935               gpgsm_dump_cert ("signed subject", subject_cert);
936             }
937           if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
938             {
939               /* We now try to find other issuer certificates which
940                  might have been used.  This is required because some
941                  CAs are reusing the issuer and subject DN for new
942                  root certificates. */
943               /* FIXME: Do this only if we don't have an
944                  AKI.keyIdentifier */
945               rc = find_up (kh, subject_cert, issuer, 1);
946               if (!rc)
947                 {
948                   ksba_cert_t tmp_cert;
949
950                   rc = keydb_get_cert (kh, &tmp_cert);
951                   if (rc || !compare_certs (issuer_cert, tmp_cert))
952                     {
953                       /* The find next did not work or returned an
954                          identical certificate.  We better stop here
955                          to avoid infinite checks. */
956                       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
957                       ksba_cert_release (tmp_cert);
958                     }
959                   else
960                     {
961                       do_list (0, lm, fp, _("found another possible matching "
962                                             "CA certificate - trying again"));
963                       ksba_cert_release (issuer_cert); 
964                       issuer_cert = tmp_cert;
965                       goto try_another_cert;
966                     }
967                 }
968             }
969
970           /* We give a more descriptive error code than the one
971              returned from the signature checking. */
972           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
973           goto leave;
974         }
975
976       {
977         int chainlen;
978         rc = allowed_ca (issuer_cert, &chainlen, listmode, fp);
979         if (rc)
980           goto leave;
981         if (chainlen >= 0 && (depth - 1) > chainlen)
982           {
983             do_list (1, lm, fp,
984                      _("certificate chain longer than allowed by CA (%d)"),
985                      chainlen);
986             rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
987             goto leave;
988           }
989       }
990
991       if (!listmode)
992         {
993           rc = gpgsm_cert_use_cert_p (issuer_cert);
994           if (rc)
995             {
996               char numbuf[50];
997               sprintf (numbuf, "%d", rc);
998               gpgsm_status2 (ctrl, STATUS_ERROR, "certcert.issuer.keyusage",
999                              numbuf, NULL);
1000               goto leave;
1001             }
1002         }
1003
1004       /* Check for revocations etc. */
1005       if ((flags & 1))
1006         rc = 0;
1007       else
1008         rc = is_cert_still_valid (ctrl, lm, fp,
1009                                   subject_cert, issuer_cert,
1010                                   &any_revoked, &any_no_crl, &any_crl_too_old);
1011       if (rc)
1012         goto leave;
1013
1014
1015       if (opt.verbose && !listmode)
1016         log_info ("certificate is good\n");
1017       
1018       keydb_search_reset (kh);
1019       subject_cert = issuer_cert;
1020       issuer_cert = NULL;
1021     } /* End chain traversal. */
1022
1023   if (!listmode)
1024     {
1025       if (opt.no_policy_check)
1026         log_info ("policies not checked due to %s option\n",
1027                   "--disable-policy-checks");
1028       if (opt.no_crl_check && !ctrl->use_ocsp)
1029         log_info ("CRLs not checked due to %s option\n",
1030                   "--disable-crl-checks");
1031     }
1032
1033   if (!rc)
1034     { /* If we encountered an error somewhere during the checks, set
1035          the error code to the most critical one */
1036       if (any_revoked)
1037         rc = gpg_error (GPG_ERR_CERT_REVOKED);
1038       else if (any_expired)
1039         rc = gpg_error (GPG_ERR_CERT_EXPIRED);
1040       else if (any_no_crl)
1041         rc = gpg_error (GPG_ERR_NO_CRL_KNOWN);
1042       else if (any_crl_too_old)
1043         rc = gpg_error (GPG_ERR_CRL_TOO_OLD);
1044       else if (any_no_policy_match)
1045         rc = gpg_error (GPG_ERR_NO_POLICY_MATCH);
1046     }
1047   
1048  leave:
1049   if (is_qualified != -1)
1050     {
1051       /* We figured something about the qualified signature capability
1052          of the certificate under question.  Store the result as user
1053          data in the certificate object.  We do this even if the
1054          validation itself failed. */
1055       /* Fixme: We should set this flag for all certificates in the
1056          chain for optimizing reasons. */
1057       char buf[1];
1058       gpg_error_t err;
1059
1060       buf[0] = !!is_qualified;
1061       err = ksba_cert_set_user_data (cert, "is_qualified", buf, 1);
1062       if (err)
1063         {
1064           log_error ("set_user_data(is_qualified) failed: %s\n",
1065                      gpg_strerror (err)); 
1066           if (!rc)
1067             rc = err;
1068         }
1069     }
1070   if (r_exptime)
1071     gnupg_copy_time (r_exptime, exptime);
1072   xfree (issuer);
1073   keydb_release (kh); 
1074   ksba_cert_release (issuer_cert);
1075   if (subject_cert != cert)
1076     ksba_cert_release (subject_cert);
1077   return rc;
1078 }
1079
1080
1081 /* Check that the given certificate is valid but DO NOT check any
1082    constraints.  We assume that the issuers certificate is already in
1083    the DB and that this one is valid; which it should be because it
1084    has been checked using this function. */
1085 int
1086 gpgsm_basic_cert_check (ksba_cert_t cert)
1087 {
1088   int rc = 0;
1089   char *issuer = NULL;
1090   char *subject = NULL;
1091   KEYDB_HANDLE kh;
1092   ksba_cert_t issuer_cert = NULL;
1093   
1094   if (opt.no_chain_validation)
1095     {
1096       log_info ("WARNING: bypassing basic certificate checks\n");
1097       return 0;
1098     }
1099
1100   kh = keydb_new (0);
1101   if (!kh)
1102     {
1103       log_error (_("failed to allocated keyDB handle\n"));
1104       rc = gpg_error (GPG_ERR_GENERAL);
1105       goto leave;
1106     }
1107
1108   issuer = ksba_cert_get_issuer (cert, 0);
1109   subject = ksba_cert_get_subject (cert, 0);
1110   if (!issuer)
1111     {
1112       log_error ("no issuer found in certificate\n");
1113       rc = gpg_error (GPG_ERR_BAD_CERT);
1114       goto leave;
1115     }
1116
1117   if (subject && !strcmp (issuer, subject))
1118     {
1119       rc = gpgsm_check_cert_sig (cert, cert);
1120       if (rc)
1121         {
1122           log_error ("self-signed certificate has a BAD signature: %s\n",
1123                      gpg_strerror (rc));
1124           if (DBG_X509)
1125             {
1126               gpgsm_dump_cert ("self-signing cert", cert);
1127             }
1128           rc = gpg_error (GPG_ERR_BAD_CERT);
1129           goto leave;
1130         }
1131     }
1132   else
1133     {
1134       /* Find the next cert up the tree. */
1135       keydb_search_reset (kh);
1136       rc = find_up (kh, cert, issuer, 0);
1137       if (rc)
1138         {
1139           if (rc == -1)
1140             {
1141               log_info ("issuer certificate (#/");
1142               gpgsm_dump_string (issuer);
1143               log_printf (") not found\n");
1144             }
1145           else
1146             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
1147           rc = gpg_error (GPG_ERR_MISSING_CERT);
1148           goto leave;
1149         }
1150       
1151       ksba_cert_release (issuer_cert); issuer_cert = NULL;
1152       rc = keydb_get_cert (kh, &issuer_cert);
1153       if (rc)
1154         {
1155           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
1156           rc = gpg_error (GPG_ERR_GENERAL);
1157           goto leave;
1158         }
1159
1160       rc = gpgsm_check_cert_sig (issuer_cert, cert);
1161       if (rc)
1162         {
1163           log_error ("certificate has a BAD signature: %s\n",
1164                      gpg_strerror (rc));
1165           if (DBG_X509)
1166             {
1167               gpgsm_dump_cert ("signing issuer", issuer_cert);
1168               gpgsm_dump_cert ("signed subject", cert);
1169             }
1170           rc = gpg_error (GPG_ERR_BAD_CERT);
1171           goto leave;
1172         }
1173       if (opt.verbose)
1174         log_info ("certificate is good\n");
1175     }
1176
1177  leave:
1178   xfree (issuer);
1179   keydb_release (kh); 
1180   ksba_cert_release (issuer_cert);
1181   return rc;
1182 }
1183