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