Moved 1.9 branch to trunk
[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           if (!lm)
601             gpgsm_cert_log_name (NULL, subject_cert);
602           switch (gpg_err_code (err))
603             {
604             case GPG_ERR_CERT_REVOKED:
605               do_list (1, lm, fp, _("certificate has been revoked"));
606               *any_revoked = 1;
607               /* Store that in the keybox so that key listings are
608                  able to return the revoked flag.  We don't care
609                  about error, though. */
610               keydb_set_cert_flags (subject_cert, KEYBOX_FLAG_VALIDITY, 0,
611                                     VALIDITY_REVOKED);
612               break;
613             case GPG_ERR_NO_CRL_KNOWN:
614               do_list (1, lm, fp, _("no CRL found for certificate"));
615               *any_no_crl = 1;
616               break;
617             case GPG_ERR_CRL_TOO_OLD:
618               do_list (1, lm, fp, _("the available CRL is too old"));
619               if (!lm)
620                 log_info (_("please make sure that the "
621                             "\"dirmngr\" is properly installed\n"));
622               *any_crl_too_old = 1;
623               break;
624             default:
625               do_list (1, lm, fp, _("checking the CRL failed: %s"),
626                        gpg_strerror (err));
627               return err;
628             }
629         }
630     }
631   return 0;
632 }
633
634
635 \f
636 /* Validate a chain and optionally return the nearest expiration time
637    in R_EXPTIME. With LISTMODE set to 1 a special listmode is
638    activated where only information about the certificate is printed
639    to FP and no output is send to the usual log stream. 
640
641    Defined flag bits: 0 - do not do any dirmngr isvalid checks.
642 */
643 int
644 gpgsm_validate_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t r_exptime,
645                       int listmode, FILE *fp, unsigned int flags)
646 {
647   int rc = 0, depth = 0, maxdepth;
648   char *issuer = NULL;
649   char *subject = NULL;
650   KEYDB_HANDLE kh = NULL;
651   ksba_cert_t subject_cert = NULL, issuer_cert = NULL;
652   ksba_isotime_t current_time;
653   ksba_isotime_t exptime;
654   int any_expired = 0;
655   int any_revoked = 0;
656   int any_no_crl = 0;
657   int any_crl_too_old = 0;
658   int any_no_policy_match = 0;
659   int is_qualified = -1; /* Indicates whether the certificate stems
660                             from a qualified root certificate.
661                             -1 = unknown, 0 = no, 1 = yes. */
662   int lm = listmode;
663
664   gnupg_get_isotime (current_time);
665   if (r_exptime)
666     *r_exptime = 0;
667   *exptime = 0;
668
669   if (opt.no_chain_validation && !listmode)
670     {
671       log_info ("WARNING: bypassing certificate chain validation\n");
672       return 0;
673     }
674
675   kh = keydb_new (0);
676   if (!kh)
677     {
678       log_error (_("failed to allocated keyDB handle\n"));
679       rc = gpg_error (GPG_ERR_GENERAL);
680       goto leave;
681     }
682
683   if (DBG_X509 && !listmode)
684     gpgsm_dump_cert ("target", cert);
685
686   subject_cert = cert;
687   maxdepth = 50;
688
689   for (;;)
690     {
691       xfree (issuer);
692       xfree (subject);
693       issuer = ksba_cert_get_issuer (subject_cert, 0);
694       subject = ksba_cert_get_subject (subject_cert, 0);
695
696       if (!issuer)
697         {
698           do_list (1, lm, fp,  _("no issuer found in certificate"));
699           rc = gpg_error (GPG_ERR_BAD_CERT);
700           goto leave;
701         }
702
703       {
704         ksba_isotime_t not_before, not_after;
705
706         rc = ksba_cert_get_validity (subject_cert, 0, not_before);
707         if (!rc)
708           rc = ksba_cert_get_validity (subject_cert, 1, not_after);
709         if (rc)
710           {
711             do_list (1, lm, fp, _("certificate with invalid validity: %s"),
712                      gpg_strerror (rc));
713             rc = gpg_error (GPG_ERR_BAD_CERT);
714             goto leave;
715           }
716
717         if (*not_after)
718           {
719             if (!*exptime)
720               gnupg_copy_time (exptime, not_after);
721             else if (strcmp (not_after, exptime) < 0 )
722               gnupg_copy_time (exptime, not_after);
723           }
724
725         if (*not_before && strcmp (current_time, not_before) < 0 )
726           {
727             do_list (1, lm, fp, _("certificate not yet valid"));
728             if (!lm)
729               {
730                 log_info ("(valid from ");
731                 gpgsm_dump_time (not_before);
732                 log_printf (")\n");
733               }
734             rc = gpg_error (GPG_ERR_CERT_TOO_YOUNG);
735             goto leave;
736           }            
737         if (*not_after && strcmp (current_time, not_after) > 0 )
738           {
739             do_list (opt.ignore_expiration?0:1, lm, fp,
740                      _("certificate has expired"));
741             if (!lm)
742               {
743                 log_info ("(expired at ");
744                 gpgsm_dump_time (not_after);
745                 log_printf (")\n");
746               }
747             if (opt.ignore_expiration)
748                 log_info ("WARNING: ignoring expiration\n");
749             else
750               any_expired = 1;
751           }            
752       }
753
754       rc = unknown_criticals (subject_cert, listmode, fp);
755       if (rc)
756         goto leave;
757
758       if (!opt.no_policy_check)
759         {
760           rc = check_cert_policy (subject_cert, listmode, fp);
761           if (gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH)
762             {
763               any_no_policy_match = 1;
764               rc = 1;
765             }
766           else if (rc)
767             goto leave;
768         }
769
770
771       /* Is this a self-issued certificate? */
772       if (subject && !strcmp (issuer, subject))
773         {  /* Yes. */
774           if (gpgsm_check_cert_sig (subject_cert, subject_cert) )
775             {
776               do_list (1, lm, fp,
777                        _("self-signed certificate has a BAD signature"));
778               if (DBG_X509)
779                 {
780                   gpgsm_dump_cert ("self-signing cert", subject_cert);
781                 }
782               rc = gpg_error (depth? GPG_ERR_BAD_CERT_CHAIN
783                                    : GPG_ERR_BAD_CERT);
784               goto leave;
785             }
786           rc = allowed_ca (subject_cert, NULL, listmode, fp);
787           if (rc)
788             goto leave;
789
790           
791           /* Set the flag for qualified signatures.  This flag is
792              deduced from a list of root certificates allowed for
793              qualified signatures. */
794           if (is_qualified == -1)
795             {
796               gpg_error_t err;
797               size_t buflen;
798               char buf[1];
799               
800               if (!ksba_cert_get_user_data (cert, "is_qualified", 
801                                             &buf, sizeof (buf),
802                                             &buflen) && buflen)
803                 {
804                   /* We already checked this for this certificate,
805                      thus we simply take it from the user data. */
806                   is_qualified = !!*buf;
807                 }    
808               else
809                 {
810                   /* Need to consult the list of root certificates for
811                      qualified signatures. */
812                   err = gpgsm_is_in_qualified_list (ctrl, subject_cert, NULL);
813                   if (!err)
814                     is_qualified = 1;
815                   else if ( gpg_err_code (err) == GPG_ERR_NOT_FOUND)
816                     is_qualified = 0;
817                   else
818                     log_error ("checking the list of qualified "
819                                "root certificates failed: %s\n",
820                                gpg_strerror (err));
821                   if ( is_qualified != -1 )
822                     {
823                       /* Cache the result but don't care too much
824                          about an error. */
825                       buf[0] = !!is_qualified;
826                       err = ksba_cert_set_user_data (subject_cert,
827                                                      "is_qualified", buf, 1);
828                       if (err)
829                         log_error ("set_user_data(is_qualified) failed: %s\n",
830                                    gpg_strerror (err)); 
831                     }
832                 }
833             }
834
835
836           /* Check whether we really trust this root certificate. */
837           rc = gpgsm_agent_istrusted (ctrl, subject_cert);
838           if (!rc)
839             ;
840           else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
841             {
842               do_list (0, lm, fp, _("root certificate is not marked trusted"));
843               /* If we already figured out that the certificate is
844                  expired it does not make much sense to ask the user
845                  whether we wants to trust the root certificate.  He
846                  should do this only if the certificate under question
847                  will then be usable. */
848               if (!lm && !any_expired)
849                 {
850                   int rc2;
851                   char *fpr = gpgsm_get_fingerprint_string (subject_cert,
852                                                             GCRY_MD_SHA1);
853                   log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
854                   xfree (fpr);
855                   rc2 = gpgsm_agent_marktrusted (ctrl, subject_cert);
856                   if (!rc2)
857                     {
858                       log_info (_("root certificate has now"
859                                   " been marked as trusted\n"));
860                       rc = 0;
861                     }
862                   else 
863                     {
864                       gpgsm_dump_cert ("issuer", subject_cert);
865                       log_info ("after checking the fingerprint, you may want "
866                                 "to add it manually to the list of trusted "
867                                 "certificates.\n");
868                     }
869                 }
870             }
871           else 
872             {
873               log_error (_("checking the trust list failed: %s\n"),
874                          gpg_strerror (rc));
875             }
876           
877           if (rc)
878             goto leave;
879
880           /* Check for revocations etc. */
881           if ((flags & 1))
882             ;
883           else if (opt.no_trusted_cert_crl_check)
884             ; 
885           else
886             rc = is_cert_still_valid (ctrl, lm, fp,
887                                       subject_cert, subject_cert,
888                                       &any_revoked, &any_no_crl,
889                                       &any_crl_too_old);
890           if (rc)
891             goto leave;
892
893           break;  /* Okay: a self-signed certicate is an end-point. */
894         }
895       
896       depth++;
897       if (depth > maxdepth)
898         {
899           do_list (1, lm, fp, _("certificate chain too long\n"));
900           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
901           goto leave;
902         }
903
904       /* find the next cert up the tree */
905       keydb_search_reset (kh);
906       rc = find_up (kh, subject_cert, issuer, 0);
907       if (rc)
908         {
909           if (rc == -1)
910             {
911               do_list (0, lm, fp, _("issuer certificate not found"));
912               if (!lm)
913                 {
914                   log_info ("issuer certificate: #/");
915                   gpgsm_dump_string (issuer);
916                   log_printf ("\n");
917                 }
918             }
919           else
920             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
921           rc = gpg_error (GPG_ERR_MISSING_CERT);
922           goto leave;
923         }
924
925       ksba_cert_release (issuer_cert); issuer_cert = NULL;
926       rc = keydb_get_cert (kh, &issuer_cert);
927       if (rc)
928         {
929           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
930           rc = gpg_error (GPG_ERR_GENERAL);
931           goto leave;
932         }
933
934     try_another_cert:
935       if (DBG_X509)
936         {
937           log_debug ("got issuer's certificate:\n");
938           gpgsm_dump_cert ("issuer", issuer_cert);
939         }
940
941       rc = gpgsm_check_cert_sig (issuer_cert, subject_cert);
942       if (rc)
943         {
944           do_list (0, lm, fp, _("certificate has a BAD signature"));
945           if (DBG_X509)
946             {
947               gpgsm_dump_cert ("signing issuer", issuer_cert);
948               gpgsm_dump_cert ("signed subject", subject_cert);
949             }
950           if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
951             {
952               /* We now try to find other issuer certificates which
953                  might have been used.  This is required because some
954                  CAs are reusing the issuer and subject DN for new
955                  root certificates. */
956               /* FIXME: Do this only if we don't have an
957                  AKI.keyIdentifier */
958               rc = find_up (kh, subject_cert, issuer, 1);
959               if (!rc)
960                 {
961                   ksba_cert_t tmp_cert;
962
963                   rc = keydb_get_cert (kh, &tmp_cert);
964                   if (rc || !compare_certs (issuer_cert, tmp_cert))
965                     {
966                       /* The find next did not work or returned an
967                          identical certificate.  We better stop here
968                          to avoid infinite checks. */
969                       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
970                       ksba_cert_release (tmp_cert);
971                     }
972                   else
973                     {
974                       do_list (0, lm, fp, _("found another possible matching "
975                                             "CA certificate - trying again"));
976                       ksba_cert_release (issuer_cert); 
977                       issuer_cert = tmp_cert;
978                       goto try_another_cert;
979                     }
980                 }
981             }
982
983           /* We give a more descriptive error code than the one
984              returned from the signature checking. */
985           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
986           goto leave;
987         }
988
989       {
990         int chainlen;
991         rc = allowed_ca (issuer_cert, &chainlen, listmode, fp);
992         if (rc)
993           goto leave;
994         if (chainlen >= 0 && (depth - 1) > chainlen)
995           {
996             do_list (1, lm, fp,
997                      _("certificate chain longer than allowed by CA (%d)"),
998                      chainlen);
999             rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
1000             goto leave;
1001           }
1002       }
1003
1004       if (!listmode)
1005         {
1006           rc = gpgsm_cert_use_cert_p (issuer_cert);
1007           if (rc)
1008             {
1009               char numbuf[50];
1010               sprintf (numbuf, "%d", rc);
1011               gpgsm_status2 (ctrl, STATUS_ERROR, "certcert.issuer.keyusage",
1012                              numbuf, NULL);
1013               goto leave;
1014             }
1015         }
1016
1017       /* Check for revocations etc. */
1018       if ((flags & 1))
1019         rc = 0;
1020       else
1021         rc = is_cert_still_valid (ctrl, lm, fp,
1022                                   subject_cert, issuer_cert,
1023                                   &any_revoked, &any_no_crl, &any_crl_too_old);
1024       if (rc)
1025         goto leave;
1026
1027
1028       if (opt.verbose && !listmode)
1029         log_info ("certificate is good\n");
1030       
1031       keydb_search_reset (kh);
1032       subject_cert = issuer_cert;
1033       issuer_cert = NULL;
1034     } /* End chain traversal. */
1035
1036   if (!listmode)
1037     {
1038       if (opt.no_policy_check)
1039         log_info ("policies not checked due to %s option\n",
1040                   "--disable-policy-checks");
1041       if (opt.no_crl_check && !ctrl->use_ocsp)
1042         log_info ("CRLs not checked due to %s option\n",
1043                   "--disable-crl-checks");
1044     }
1045
1046   if (!rc)
1047     { /* If we encountered an error somewhere during the checks, set
1048          the error code to the most critical one */
1049       if (any_revoked)
1050         rc = gpg_error (GPG_ERR_CERT_REVOKED);
1051       else if (any_expired)
1052         rc = gpg_error (GPG_ERR_CERT_EXPIRED);
1053       else if (any_no_crl)
1054         rc = gpg_error (GPG_ERR_NO_CRL_KNOWN);
1055       else if (any_crl_too_old)
1056         rc = gpg_error (GPG_ERR_CRL_TOO_OLD);
1057       else if (any_no_policy_match)
1058         rc = gpg_error (GPG_ERR_NO_POLICY_MATCH);
1059     }
1060   
1061  leave:
1062   if (is_qualified != -1)
1063     {
1064       /* We figured something about the qualified signature capability
1065          of the certificate under question.  Store the result as user
1066          data in the certificate object.  We do this even if the
1067          validation itself failed. */
1068       /* Fixme: We should set this flag for all certificates in the
1069          chain for optimizing reasons. */
1070       char buf[1];
1071       gpg_error_t err;
1072
1073       buf[0] = !!is_qualified;
1074       err = ksba_cert_set_user_data (cert, "is_qualified", buf, 1);
1075       if (err)
1076         {
1077           log_error ("set_user_data(is_qualified) failed: %s\n",
1078                      gpg_strerror (err)); 
1079           if (!rc)
1080             rc = err;
1081         }
1082     }
1083   if (r_exptime)
1084     gnupg_copy_time (r_exptime, exptime);
1085   xfree (issuer);
1086   keydb_release (kh); 
1087   ksba_cert_release (issuer_cert);
1088   if (subject_cert != cert)
1089     ksba_cert_release (subject_cert);
1090   return rc;
1091 }
1092
1093
1094 /* Check that the given certificate is valid but DO NOT check any
1095    constraints.  We assume that the issuers certificate is already in
1096    the DB and that this one is valid; which it should be because it
1097    has been checked using this function. */
1098 int
1099 gpgsm_basic_cert_check (ksba_cert_t cert)
1100 {
1101   int rc = 0;
1102   char *issuer = NULL;
1103   char *subject = NULL;
1104   KEYDB_HANDLE kh;
1105   ksba_cert_t issuer_cert = NULL;
1106   
1107   if (opt.no_chain_validation)
1108     {
1109       log_info ("WARNING: bypassing basic certificate checks\n");
1110       return 0;
1111     }
1112
1113   kh = keydb_new (0);
1114   if (!kh)
1115     {
1116       log_error (_("failed to allocated keyDB handle\n"));
1117       rc = gpg_error (GPG_ERR_GENERAL);
1118       goto leave;
1119     }
1120
1121   issuer = ksba_cert_get_issuer (cert, 0);
1122   subject = ksba_cert_get_subject (cert, 0);
1123   if (!issuer)
1124     {
1125       log_error ("no issuer found in certificate\n");
1126       rc = gpg_error (GPG_ERR_BAD_CERT);
1127       goto leave;
1128     }
1129
1130   if (subject && !strcmp (issuer, subject))
1131     {
1132       rc = gpgsm_check_cert_sig (cert, cert);
1133       if (rc)
1134         {
1135           log_error ("self-signed certificate has a BAD signature: %s\n",
1136                      gpg_strerror (rc));
1137           if (DBG_X509)
1138             {
1139               gpgsm_dump_cert ("self-signing cert", cert);
1140             }
1141           rc = gpg_error (GPG_ERR_BAD_CERT);
1142           goto leave;
1143         }
1144     }
1145   else
1146     {
1147       /* Find the next cert up the tree. */
1148       keydb_search_reset (kh);
1149       rc = find_up (kh, cert, issuer, 0);
1150       if (rc)
1151         {
1152           if (rc == -1)
1153             {
1154               log_info ("issuer certificate (#/");
1155               gpgsm_dump_string (issuer);
1156               log_printf (") not found\n");
1157             }
1158           else
1159             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
1160           rc = gpg_error (GPG_ERR_MISSING_CERT);
1161           goto leave;
1162         }
1163       
1164       ksba_cert_release (issuer_cert); issuer_cert = NULL;
1165       rc = keydb_get_cert (kh, &issuer_cert);
1166       if (rc)
1167         {
1168           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
1169           rc = gpg_error (GPG_ERR_GENERAL);
1170           goto leave;
1171         }
1172
1173       rc = gpgsm_check_cert_sig (issuer_cert, cert);
1174       if (rc)
1175         {
1176           log_error ("certificate has a BAD signature: %s\n",
1177                      gpg_strerror (rc));
1178           if (DBG_X509)
1179             {
1180               gpgsm_dump_cert ("signing issuer", issuer_cert);
1181               gpgsm_dump_cert ("signed subject", cert);
1182             }
1183           rc = gpg_error (GPG_ERR_BAD_CERT);
1184           goto leave;
1185         }
1186       if (opt.verbose)
1187         log_info ("certificate is good\n");
1188     }
1189
1190  leave:
1191   xfree (issuer);
1192   keydb_release (kh); 
1193   ksba_cert_release (issuer_cert);
1194   return rc;
1195 }
1196
1197
1198
1199 /* Check whether the certificate CERT has been issued by the German
1200    authority for qualified signature.  They do not set the
1201    basicConstraints and thus we need this workaround.  It works by
1202    looking up the root certificate and checking whether that one is
1203    listed as a qualified certificate for Germany. 
1204
1205    We also try to cache this data but as long as don't keep a
1206    reference to the certificate this won't be used.
1207
1208    Returns: True if CERT is a RegTP issued CA cert (i.e. the root
1209    certificate itself or one of the CAs).  In that case CHAINLEN will
1210    receive the length of the chain which is either 0 or 1.
1211 */
1212 static int
1213 get_regtp_ca_info (ksba_cert_t cert, int *chainlen)
1214 {
1215   gpg_error_t err;
1216   ksba_cert_t next;
1217   int rc = 0;
1218   int i, depth;
1219   char country[3];
1220   ksba_cert_t array[4];
1221   char buf[2];
1222   size_t buflen;
1223   int dummy_chainlen;
1224
1225   if (!chainlen)
1226     chainlen = &dummy_chainlen;
1227
1228   *chainlen = 0;
1229   err = ksba_cert_get_user_data (cert, "regtp_ca_chainlen", 
1230                                  &buf, sizeof (buf), &buflen);
1231   if (!err)
1232     {
1233       /* Got info. */
1234       if (buflen < 2 || !*buf)
1235         return 0; /* Nothing found. */
1236       *chainlen = buf[1];
1237       return 1; /* This is a regtp CA. */
1238     }
1239   else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1240     {
1241       log_error ("ksba_cert_get_user_data(%s) failed: %s\n",
1242                  "regtp_ca_chainlen", gpg_strerror (err));
1243       return 0; /* Nothing found.  */
1244     }
1245
1246   /* Need to gather the info.  This requires to walk up the chain
1247      until we have found the root.  Because we are only interested in
1248      German Bundesnetzagentur (former RegTP) derived certificates 3
1249      levels are enough.  (The German signature law demands a 3 tier
1250      hierachy; thus there is only one CA between the EE and the Root
1251      CA.)  */
1252   memset (&array, 0, sizeof array);
1253
1254   depth = 0;
1255   ksba_cert_ref (cert);
1256   array[depth++] = cert;
1257   ksba_cert_ref (cert);
1258   while (depth < DIM(array) && !(rc=gpgsm_walk_cert_chain (cert, &next)))
1259     {
1260       ksba_cert_release (cert);
1261       ksba_cert_ref (next);
1262       array[depth++] = next;
1263       cert = next;
1264     }
1265   ksba_cert_release (cert);
1266   if (rc != -1 || !depth || depth == DIM(array) )
1267     {
1268       /* We did not reached the root. */
1269       goto leave;
1270     }
1271
1272   /* If this is a German signature law issued certificate, we store
1273      additional additional information. */
1274   if (!gpgsm_is_in_qualified_list (NULL, array[depth-1], country)
1275       && !strcmp (country, "de"))
1276     {
1277       /* Setting the pathlen for the root CA and the CA flag for the
1278          next one is all what we need to do. */
1279       err = ksba_cert_set_user_data (array[depth-1], "regtp_ca_chainlen",
1280                                      "\x01\x01", 2);
1281       if (!err && depth > 1)
1282         err = ksba_cert_set_user_data (array[depth-2], "regtp_ca_chainlen",
1283                                        "\x01\x00", 2);
1284       if (err)
1285         log_error ("ksba_set_user_data(%s) failed: %s\n",
1286                    "regtp_ca_chainlen", gpg_strerror (err)); 
1287       for (i=0; i < depth; i++)
1288         ksba_cert_release (array[i]);
1289       *chainlen = (depth>1? 0:1);
1290       return 1;
1291     }
1292
1293  leave:
1294   /* Nothing special with this certificate. Mark the target
1295      certificate anyway to avoid duplicate lookups. */ 
1296   err = ksba_cert_set_user_data (cert, "regtp_ca_chainlen", "", 1);
1297   if (err)
1298     log_error ("ksba_set_user_data(%s) failed: %s\n",
1299                "regtp_ca_chainlen", gpg_strerror (err)); 
1300   for (i=0; i < depth; i++)
1301     ksba_cert_release (array[i]);
1302   return 0;
1303 }