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