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