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