gpgsm: Allow arbitrary extensions for cert creation.
[gnupg.git] / sm / certchain.c
1 /* certchain.c - certificate chain validation
2  * Copyright (C) 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h>
27 #include <time.h>
28 #include <stdarg.h>
29 #include <assert.h>
30
31 #define JNLIB_NEED_LOG_LOGV /* We need log_logv. */
32
33 #include "gpgsm.h"
34 #include <gcrypt.h>
35 #include <ksba.h>
36
37 #include "keydb.h"
38 #include "../kbx/keybox.h" /* for KEYBOX_FLAG_* */
39 #include "i18n.h"
40 #include "tlv.h"
41
42
43 /* Object to keep track of certain root certificates. */
44 struct marktrusted_info_s
45 {
46   struct marktrusted_info_s *next;
47   unsigned char fpr[20];
48 };
49 static struct marktrusted_info_s *marktrusted_info;
50
51
52 /* While running the validation function we want to keep track of the
53    certificates in the chain.  This type is used for that.  */
54 struct chain_item_s
55 {
56   struct chain_item_s *next;
57   ksba_cert_t cert;      /* The certificate.  */
58   int is_root;           /* The certificate is the root certificate.  */
59 };
60 typedef struct chain_item_s *chain_item_t;
61
62
63 static int is_root_cert (ksba_cert_t cert,
64                          const char *issuerdn, const char *subjectdn);
65 static int get_regtp_ca_info (ctrl_t ctrl, ksba_cert_t cert, int *chainlen);
66
67
68 /* This function returns true if we already asked during this session
69    whether the root certificate CERT shall be marked as trusted.  */
70 static int
71 already_asked_marktrusted (ksba_cert_t cert)
72 {
73   unsigned char fpr[20];
74   struct marktrusted_info_s *r;
75
76   gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, fpr, NULL);
77   /* No context switches in the loop! */
78   for (r=marktrusted_info; r; r= r->next)
79     if (!memcmp (r->fpr, fpr, 20))
80       return 1;
81   return 0;
82 }
83
84 /* Flag certificate CERT as already asked whether it shall be marked
85    as trusted.  */
86 static void
87 set_already_asked_marktrusted (ksba_cert_t cert)
88 {
89  unsigned char fpr[20];
90  struct marktrusted_info_s *r;
91
92  gpgsm_get_fingerprint (cert, GCRY_MD_SHA1, fpr, NULL);
93  for (r=marktrusted_info; r; r= r->next)
94    if (!memcmp (r->fpr, fpr, 20))
95      return; /* Already marked. */
96  r = xtrycalloc (1, sizeof *r);
97  if (!r)
98    return;
99  memcpy (r->fpr, fpr, 20);
100  r->next = marktrusted_info;
101  marktrusted_info = r;
102 }
103
104 /* If LISTMODE is true, print FORMAT using LISTMODE to FP.  If
105    LISTMODE is false, use the string to print an log_info or, if
106    IS_ERROR is true, and log_error. */
107 static void
108 do_list (int is_error, int listmode, estream_t fp, const char *format, ...)
109 {
110   va_list arg_ptr;
111
112   va_start (arg_ptr, format) ;
113   if (listmode)
114     {
115       if (fp)
116         {
117           es_fputs ("  [", fp);
118           es_vfprintf (fp, format, arg_ptr);
119           es_fputs ("]\n", fp);
120         }
121     }
122   else
123     {
124       log_logv (is_error? JNLIB_LOG_ERROR: JNLIB_LOG_INFO, format, arg_ptr);
125       log_printf ("\n");
126     }
127   va_end (arg_ptr);
128 }
129
130 /* Return 0 if A and B are equal. */
131 static int
132 compare_certs (ksba_cert_t a, ksba_cert_t b)
133 {
134   const unsigned char *img_a, *img_b;
135   size_t len_a, len_b;
136
137   img_a = ksba_cert_get_image (a, &len_a);
138   if (!img_a)
139     return 1;
140   img_b = ksba_cert_get_image (b, &len_b);
141   if (!img_b)
142     return 1;
143   return !(len_a == len_b && !memcmp (img_a, img_b, len_a));
144 }
145
146
147 /* Return true if CERT has the validityModel extensions and defines
148    the use of the chain model.  */
149 static int
150 has_validation_model_chain (ksba_cert_t cert, int listmode, estream_t listfp)
151 {
152   gpg_error_t err;
153   int idx, yes;
154   const char *oid;
155   size_t off, derlen, objlen, hdrlen;
156   const unsigned char *der;
157   int class, tag, constructed, ndef;
158   char *oidbuf;
159
160   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
161                                              &oid, NULL, &off, &derlen));idx++)
162     if (!strcmp (oid, "1.3.6.1.4.1.8301.3.5") )
163       break;
164   if (err)
165     return 0; /* Not found.  */
166   der = ksba_cert_get_image (cert, NULL);
167   if (!der)
168     {
169       err = gpg_error (GPG_ERR_INV_OBJ); /* Oops  */
170       goto leave;
171     }
172   der += off;
173
174   err = parse_ber_header (&der, &derlen, &class, &tag, &constructed,
175                           &ndef, &objlen, &hdrlen);
176   if (!err && (objlen > derlen || tag != TAG_SEQUENCE))
177     err = gpg_error (GPG_ERR_INV_OBJ);
178   if (err)
179     goto leave;
180   derlen = objlen;
181   err = parse_ber_header (&der, &derlen, &class, &tag, &constructed,
182                           &ndef, &objlen, &hdrlen);
183   if (!err && (objlen > derlen || tag != TAG_OBJECT_ID))
184     err = gpg_error (GPG_ERR_INV_OBJ);
185   if (err)
186     goto leave;
187   oidbuf = ksba_oid_to_str (der, objlen);
188   if (!oidbuf)
189     {
190       err = gpg_error_from_syserror ();
191       goto leave;
192     }
193
194   if (opt.verbose)
195     do_list (0, listmode, listfp,
196              _("validation model requested by certificate: %s"),
197               !strcmp (oidbuf, "1.3.6.1.4.1.8301.3.5.1")? _("chain") :
198               !strcmp (oidbuf, "1.3.6.1.4.1.8301.3.5.2")? _("shell") :
199               /* */                                       oidbuf);
200   yes = !strcmp (oidbuf, "1.3.6.1.4.1.8301.3.5.1");
201   ksba_free (oidbuf);
202   return yes;
203
204
205  leave:
206   log_error ("error parsing validityModel: %s\n", gpg_strerror (err));
207   return 0;
208 }
209
210
211
212 static int
213 unknown_criticals (ksba_cert_t cert, int listmode, estream_t fp)
214 {
215   static const char *known[] = {
216     "2.5.29.15", /* keyUsage */
217     "2.5.29.17", /* subjectAltName
218                     Japanese DoCoMo certs mark them as critical.  PKIX
219                     only requires them as critical if subjectName is
220                     empty.  I don't know whether our code gracefully
221                     handles such empry subjectNames but that is
222                     another story. */
223     "2.5.29.19", /* basic Constraints */
224     "2.5.29.32", /* certificatePolicies */
225     "2.5.29.37", /* extendedKeyUsage - handled by certlist.c */
226     "1.3.6.1.4.1.8301.3.5", /* validityModel - handled here. */
227     NULL
228   };
229   int rc = 0, i, idx, crit;
230   const char *oid;
231   gpg_error_t err;
232   int unsupported;
233   strlist_t sl;
234
235   for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
236                                              &oid, &crit, NULL, NULL));idx++)
237     {
238       if (!crit)
239         continue;
240       for (i=0; known[i] && strcmp (known[i],oid); i++)
241         ;
242       unsupported = !known[i];
243
244       /* If this critical extension is not supported.  Check the list
245          of to be ignored extensions to see whether we claim that it
246          is supported.  */
247       if (unsupported && opt.ignored_cert_extensions)
248         {
249           for (sl=opt.ignored_cert_extensions;
250                sl && strcmp (sl->d, oid); sl = sl->next)
251             ;
252           if (sl)
253             unsupported = 0;
254         }
255       if (unsupported)
256         {
257           do_list (1, listmode, fp,
258                    _("critical certificate extension %s is not supported"),
259                    oid);
260           rc = gpg_error (GPG_ERR_UNSUPPORTED_CERT);
261         }
262     }
263   /* We ignore the error codes EOF as well as no-value. The later will
264      occur for certificates with no extensions at all. */
265   if (err
266       && gpg_err_code (err) != GPG_ERR_EOF
267       && gpg_err_code (err) != GPG_ERR_NO_VALUE)
268     rc = err;
269
270   return rc;
271 }
272
273
274 /* Check whether CERT is an allowed certificate.  This requires that
275    CERT matches all requirements for such a CA, i.e. the
276    BasicConstraints extension.  The function returns 0 on success and
277    the allowed length of the chain at CHAINLEN. */
278 static int
279 allowed_ca (ctrl_t ctrl,
280             ksba_cert_t cert, int *chainlen, int listmode, estream_t fp)
281 {
282   gpg_error_t err;
283   int flag;
284
285   err = ksba_cert_is_ca (cert, &flag, chainlen);
286   if (err)
287     return err;
288   if (!flag)
289     {
290       if (get_regtp_ca_info (ctrl, cert, chainlen))
291         {
292           /* Note that dirmngr takes a different way to cope with such
293              certs. */
294           return 0; /* RegTP issued certificate. */
295         }
296
297       do_list (1, listmode, fp,_("issuer certificate is not marked as a CA"));
298       return gpg_error (GPG_ERR_BAD_CA_CERT);
299     }
300   return 0;
301 }
302
303
304 static int
305 check_cert_policy (ksba_cert_t cert, int listmode, estream_t fplist)
306 {
307   gpg_error_t err;
308   char *policies;
309   FILE *fp;
310   int any_critical;
311
312   err = ksba_cert_get_cert_policies (cert, &policies);
313   if (gpg_err_code (err) == GPG_ERR_NO_DATA)
314     return 0; /* No policy given. */
315   if (err)
316     return err;
317
318   /* STRING is a line delimited list of certificate policies as stored
319      in the certificate.  The line itself is colon delimited where the
320      first field is the OID of the policy and the second field either
321      N or C for normal or critical extension */
322
323   if (opt.verbose > 1 && !listmode)
324     log_info ("certificate's policy list: %s\n", policies);
325
326   /* The check is very minimal but won't give false positives */
327   any_critical = !!strstr (policies, ":C");
328
329   if (!opt.policy_file)
330     {
331       xfree (policies);
332       if (any_critical)
333         {
334           do_list (1, listmode, fplist,
335                    _("critical marked policy without configured policies"));
336           return gpg_error (GPG_ERR_NO_POLICY_MATCH);
337         }
338       return 0;
339     }
340
341   fp = fopen (opt.policy_file, "r");
342   if (!fp)
343     {
344       if (opt.verbose || errno != ENOENT)
345         log_info (_("failed to open `%s': %s\n"),
346                   opt.policy_file, strerror (errno));
347       xfree (policies);
348       /* With no critical policies this is only a warning */
349       if (!any_critical)
350         {
351           if (!opt.quiet)
352             do_list (0, listmode, fplist,
353                      _("note: non-critical certificate policy not allowed"));
354           return 0;
355         }
356       do_list (1, listmode, fplist,
357                _("certificate policy not allowed"));
358       return gpg_error (GPG_ERR_NO_POLICY_MATCH);
359     }
360
361   for (;;)
362     {
363       int c;
364       char *p, line[256];
365       char *haystack, *allowed;
366
367       /* read line */
368       do
369         {
370           if (!fgets (line, DIM(line)-1, fp) )
371             {
372               gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
373
374               xfree (policies);
375               if (feof (fp))
376                 {
377                   fclose (fp);
378                   /* With no critical policies this is only a warning */
379                   if (!any_critical)
380                     {
381                       do_list (0, listmode, fplist,
382                      _("note: non-critical certificate policy not allowed"));
383                       return 0;
384                     }
385                   do_list (1, listmode, fplist,
386                            _("certificate policy not allowed"));
387                   return gpg_error (GPG_ERR_NO_POLICY_MATCH);
388                 }
389               fclose (fp);
390               return tmperr;
391             }
392
393           if (!*line || line[strlen(line)-1] != '\n')
394             {
395               /* eat until end of line */
396               while ( (c=getc (fp)) != EOF && c != '\n')
397                 ;
398               fclose (fp);
399               xfree (policies);
400               return gpg_error (*line? GPG_ERR_LINE_TOO_LONG
401                                      : GPG_ERR_INCOMPLETE_LINE);
402             }
403
404           /* Allow for empty lines and spaces */
405           for (p=line; spacep (p); p++)
406             ;
407         }
408       while (!*p || *p == '\n' || *p == '#');
409
410       /* parse line */
411       for (allowed=line; spacep (allowed); allowed++)
412         ;
413       p = strpbrk (allowed, " :\n");
414       if (!*p || p == allowed)
415         {
416           fclose (fp);
417           xfree (policies);
418           return gpg_error (GPG_ERR_CONFIGURATION);
419         }
420       *p = 0; /* strip the rest of the line */
421       /* See whether we find ALLOWED (which is an OID) in POLICIES */
422       for (haystack=policies; (p=strstr (haystack, allowed)); haystack = p+1)
423         {
424           if ( !(p == policies || p[-1] == '\n') )
425             continue; /* Does not match the begin of a line. */
426           if (p[strlen (allowed)] != ':')
427             continue; /* The length does not match. */
428           /* Yep - it does match so return okay. */
429           fclose (fp);
430           xfree (policies);
431           return 0;
432         }
433     }
434 }
435
436
437 /* Helper function for find_up.  This resets the key handle and search
438    for an issuer ISSUER with a subjectKeyIdentifier of KEYID.  Returns
439    0 on success or -1 when not found. */
440 static int
441 find_up_search_by_keyid (KEYDB_HANDLE kh,
442                          const char *issuer, ksba_sexp_t keyid)
443 {
444   int rc;
445   ksba_cert_t cert = NULL;
446   ksba_sexp_t subj = NULL;
447
448   keydb_search_reset (kh);
449   while (!(rc = keydb_search_subject (kh, issuer)))
450     {
451       ksba_cert_release (cert); cert = NULL;
452       rc = keydb_get_cert (kh, &cert);
453       if (rc)
454         {
455           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
456           rc = -1;
457           break;
458         }
459       xfree (subj);
460       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj))
461         {
462           if (!cmp_simple_canon_sexp (keyid, subj))
463             break; /* Found matching cert. */
464         }
465     }
466
467   ksba_cert_release (cert);
468   xfree (subj);
469   return rc? -1:0;
470 }
471
472
473 static void
474 find_up_store_certs_cb (void *cb_value, ksba_cert_t cert)
475 {
476   if (keydb_store_cert (cert, 1, NULL))
477     log_error ("error storing issuer certificate as ephemeral\n");
478   ++*(int*)cb_value;
479 }
480
481
482 /* Helper for find_up().  Locate the certificate for ISSUER using an
483    external lookup.  KH is the keydb context we are currently using.
484    On success 0 is returned and the certificate may be retrieved from
485    the keydb using keydb_get_cert().  KEYID is the keyIdentifier from
486    the AKI or NULL.  */
487 static int
488 find_up_external (ctrl_t ctrl, KEYDB_HANDLE kh,
489                   const char *issuer, ksba_sexp_t keyid)
490 {
491   int rc;
492   strlist_t names = NULL;
493   int count = 0;
494   char *pattern;
495   const char *s;
496
497   if (opt.verbose)
498     log_info (_("looking up issuer at external location\n"));
499   /* The Dirmngr process is confused about unknown attributes.  As a
500      quick and ugly hack we locate the CN and use the issuer string
501      starting at this attribite.  Fixme: we should have far better
502      parsing for external lookups in the Dirmngr. */
503   s = strstr (issuer, "CN=");
504   if (!s || s == issuer || s[-1] != ',')
505     s = issuer;
506   pattern = xtrymalloc (strlen (s)+2);
507   if (!pattern)
508     return gpg_error_from_syserror ();
509   strcpy (stpcpy (pattern, "/"), s);
510   add_to_strlist (&names, pattern);
511   xfree (pattern);
512
513   rc = gpgsm_dirmngr_lookup (ctrl, names, 0, find_up_store_certs_cb, &count);
514   free_strlist (names);
515
516   if (opt.verbose)
517     log_info (_("number of issuers matching: %d\n"), count);
518   if (rc)
519     {
520       log_error ("external key lookup failed: %s\n", gpg_strerror (rc));
521       rc = -1;
522     }
523   else if (!count)
524     rc = -1;
525   else
526     {
527       int old;
528       /* The issuers are currently stored in the ephemeral key DB, so
529          we temporary switch to ephemeral mode. */
530       old = keydb_set_ephemeral (kh, 1);
531       if (keyid)
532         rc = find_up_search_by_keyid (kh, issuer, keyid);
533       else
534         {
535           keydb_search_reset (kh);
536           rc = keydb_search_subject (kh, issuer);
537         }
538       keydb_set_ephemeral (kh, old);
539     }
540   return rc;
541 }
542
543
544 /* Helper for find_up().  Ask the dirmngr for the certificate for
545    ISSUER with optional SERIALNO.  KH is the keydb context we are
546    currently using.  With SUBJECT_MODE set, ISSUER is searched as the
547    subject.  On success 0 is returned and the certificate is available
548    in the ephemeral DB.  */
549 static int
550 find_up_dirmngr (ctrl_t ctrl, KEYDB_HANDLE kh,
551                  ksba_sexp_t serialno, const char *issuer, int subject_mode)
552 {
553   int rc;
554   strlist_t names = NULL;
555   int count = 0;
556   char *pattern;
557
558   (void)kh;
559
560   if (opt.verbose)
561     log_info (_("looking up issuer from the Dirmngr cache\n"));
562   if (subject_mode)
563     {
564       pattern = xtrymalloc (strlen (issuer)+2);
565       if (pattern)
566         strcpy (stpcpy (pattern, "/"), issuer);
567     }
568   else if (serialno)
569     pattern = gpgsm_format_sn_issuer (serialno, issuer);
570   else
571     {
572       pattern = xtrymalloc (strlen (issuer)+3);
573       if (pattern)
574         strcpy (stpcpy (pattern, "#/"), issuer);
575     }
576   if (!pattern)
577     return gpg_error_from_syserror ();
578   add_to_strlist (&names, pattern);
579   xfree (pattern);
580
581   rc = gpgsm_dirmngr_lookup (ctrl, names, 1, find_up_store_certs_cb, &count);
582   free_strlist (names);
583
584   if (opt.verbose)
585     log_info (_("number of matching certificates: %d\n"), count);
586   if (rc && !opt.quiet)
587     log_info (_("dirmngr cache-only key lookup failed: %s\n"),
588               gpg_strerror (rc));
589   return (!rc && count)? 0 : -1;
590 }
591
592
593
594 /* Locate issuing certificate for CERT. ISSUER is the name of the
595    issuer used as a fallback if the other methods don't work.  If
596    FIND_NEXT is true, the function shall return the next possible
597    issuer.  The certificate itself is not directly returned but a
598    keydb_get_cert on the keyDb context KH will return it.  Returns 0
599    on success, -1 if not found or an error code.  */
600 static int
601 find_up (ctrl_t ctrl, KEYDB_HANDLE kh,
602          ksba_cert_t cert, const char *issuer, int find_next)
603 {
604   ksba_name_t authid;
605   ksba_sexp_t authidno;
606   ksba_sexp_t keyid;
607   int rc = -1;
608
609   if (!ksba_cert_get_auth_key_id (cert, &keyid, &authid, &authidno))
610     {
611       const char *s = ksba_name_enum (authid, 0);
612       if (s && *authidno)
613         {
614           rc = keydb_search_issuer_sn (kh, s, authidno);
615           if (rc)
616             keydb_search_reset (kh);
617
618           /* In case of an error, try to get the certificate from the
619              dirmngr.  That is done by trying to put that certifcate
620              into the ephemeral DB and let the code below do the
621              actual retrieve.  Thus there is no error checking.
622              Skipped in find_next mode as usual. */
623           if (rc == -1 && !find_next)
624             find_up_dirmngr (ctrl, kh, authidno, s, 0);
625
626           /* In case of an error try the ephemeral DB.  We can't do
627              that in find_next mode because we can't keep the search
628              state then. */
629           if (rc == -1 && !find_next)
630             {
631               int old = keydb_set_ephemeral (kh, 1);
632               if (!old)
633                 {
634                   rc = keydb_search_issuer_sn (kh, s, authidno);
635                   if (rc)
636                     keydb_search_reset (kh);
637                 }
638               keydb_set_ephemeral (kh, old);
639             }
640           if (rc)
641             rc = -1; /* Need to make sure to have this error code. */
642         }
643
644       if (rc == -1 && keyid && !find_next)
645         {
646           /* Not found by AIK.issuer_sn.  Lets try the AIK.ki
647              instead. Loop over all certificates with that issuer as
648              subject and stop for the one with a matching
649              subjectKeyIdentifier. */
650           /* Fixme: Should we also search in the dirmngr?  */
651           rc = find_up_search_by_keyid (kh, issuer, keyid);
652           if (rc)
653             {
654               int old = keydb_set_ephemeral (kh, 1);
655               if (!old)
656                 rc = find_up_search_by_keyid (kh, issuer, keyid);
657               keydb_set_ephemeral (kh, old);
658             }
659           if (rc)
660             rc = -1; /* Need to make sure to have this error code. */
661         }
662
663       /* If we still didn't found it, try to find it via the subject
664          from the dirmngr-cache.  */
665       if (rc == -1 && !find_next)
666         {
667           if (!find_up_dirmngr (ctrl, kh, NULL, issuer, 1))
668             {
669               int old = keydb_set_ephemeral (kh, 1);
670               if (keyid)
671                 rc = find_up_search_by_keyid (kh, issuer, keyid);
672               else
673                 {
674                   keydb_search_reset (kh);
675                   rc = keydb_search_subject (kh, issuer);
676                 }
677               keydb_set_ephemeral (kh, old);
678             }
679           if (rc)
680             rc = -1; /* Need to make sure to have this error code. */
681         }
682
683       /* If we still didn't found it, try an external lookup.  */
684       if (rc == -1 && opt.auto_issuer_key_retrieve && !find_next)
685         rc = find_up_external (ctrl, kh, issuer, keyid);
686
687       /* Print a note so that the user does not feel too helpless when
688          an issuer certificate was found and gpgsm prints BAD
689          signature because it is not the correct one. */
690       if (rc == -1 && opt.quiet)
691         ;
692       else if (rc == -1)
693         {
694           log_info ("%sissuer certificate ", find_next?"next ":"");
695           if (keyid)
696             {
697               log_printf ("{");
698               gpgsm_dump_serial (keyid);
699               log_printf ("} ");
700             }
701           if (authidno)
702             {
703               log_printf ("(#");
704               gpgsm_dump_serial (authidno);
705               log_printf ("/");
706               gpgsm_dump_string (s);
707               log_printf (") ");
708             }
709           log_printf ("not found using authorityKeyIdentifier\n");
710         }
711       else if (rc)
712         log_error ("failed to find authorityKeyIdentifier: rc=%d\n", rc);
713       xfree (keyid);
714       ksba_name_release (authid);
715       xfree (authidno);
716     }
717
718   if (rc) /* Not found via authorithyKeyIdentifier, try regular issuer name. */
719     rc = keydb_search_subject (kh, issuer);
720   if (rc == -1 && !find_next)
721     {
722       int old;
723
724       /* Also try to get it from the Dirmngr cache.  The function
725          merely puts it into the ephemeral database.  */
726       find_up_dirmngr (ctrl, kh, NULL, issuer, 0);
727
728       /* Not found, let us see whether we have one in the ephemeral key DB. */
729       old = keydb_set_ephemeral (kh, 1);
730       if (!old)
731         {
732           keydb_search_reset (kh);
733           rc = keydb_search_subject (kh, issuer);
734         }
735       keydb_set_ephemeral (kh, old);
736     }
737
738   /* Still not found.  If enabled, try an external lookup.  */
739   if (rc == -1 && opt.auto_issuer_key_retrieve && !find_next)
740     rc = find_up_external (ctrl, kh, issuer, NULL);
741
742   return rc;
743 }
744
745
746 /* Return the next certificate up in the chain starting at START.
747    Returns -1 when there are no more certificates. */
748 int
749 gpgsm_walk_cert_chain (ctrl_t ctrl, ksba_cert_t start, ksba_cert_t *r_next)
750 {
751   int rc = 0;
752   char *issuer = NULL;
753   char *subject = NULL;
754   KEYDB_HANDLE kh = keydb_new (0);
755
756   *r_next = NULL;
757   if (!kh)
758     {
759       log_error (_("failed to allocated keyDB handle\n"));
760       rc = gpg_error (GPG_ERR_GENERAL);
761       goto leave;
762     }
763
764   issuer = ksba_cert_get_issuer (start, 0);
765   subject = ksba_cert_get_subject (start, 0);
766   if (!issuer)
767     {
768       log_error ("no issuer found in certificate\n");
769       rc = gpg_error (GPG_ERR_BAD_CERT);
770       goto leave;
771     }
772   if (!subject)
773     {
774       log_error ("no subject found in certificate\n");
775       rc = gpg_error (GPG_ERR_BAD_CERT);
776       goto leave;
777     }
778
779   if (is_root_cert (start, issuer, subject))
780     {
781       rc = -1; /* we are at the root */
782       goto leave;
783     }
784
785   rc = find_up (ctrl, kh, start, issuer, 0);
786   if (rc)
787     {
788       /* It is quite common not to have a certificate, so better don't
789          print an error here.  */
790       if (rc != -1 && opt.verbose > 1)
791         log_error ("failed to find issuer's certificate: rc=%d\n", rc);
792       rc = gpg_error (GPG_ERR_MISSING_ISSUER_CERT);
793       goto leave;
794     }
795
796   rc = keydb_get_cert (kh, r_next);
797   if (rc)
798     {
799       log_error ("keydb_get_cert() failed: rc=%d\n", rc);
800       rc = gpg_error (GPG_ERR_GENERAL);
801     }
802
803  leave:
804   xfree (issuer);
805   xfree (subject);
806   keydb_release (kh);
807   return rc;
808 }
809
810
811 /* Helper for gpgsm_is_root_cert.  This one is used if the subject and
812    issuer DNs are already known.  */
813 static int
814 is_root_cert (ksba_cert_t cert, const char *issuerdn, const char *subjectdn)
815 {
816   gpg_error_t err;
817   int result = 0;
818   ksba_sexp_t serialno;
819   ksba_sexp_t ak_keyid;
820   ksba_name_t ak_name;
821   ksba_sexp_t ak_sn;
822   const char *ak_name_str;
823   ksba_sexp_t subj_keyid = NULL;
824
825   if (!issuerdn || !subjectdn)
826     return 0;  /* No.  */
827
828   if (strcmp (issuerdn, subjectdn))
829     return 0;  /* No.  */
830
831   err = ksba_cert_get_auth_key_id (cert, &ak_keyid, &ak_name, &ak_sn);
832   if (err)
833     {
834       if (gpg_err_code (err) == GPG_ERR_NO_DATA)
835         return 1; /* Yes. Without a authorityKeyIdentifier this needs
836                      to be the Root certifcate (our trust anchor).  */
837       log_error ("error getting authorityKeyIdentifier: %s\n",
838                  gpg_strerror (err));
839       return 0; /* Well, it is broken anyway.  Return No. */
840     }
841
842   serialno = ksba_cert_get_serial (cert);
843   if (!serialno)
844     {
845       log_error ("error getting serialno: %s\n", gpg_strerror (err));
846       goto leave;
847     }
848
849   /* Check whether the auth name's matches the issuer name+sn.  If
850      that is the case this is a root certificate.  */
851   ak_name_str = ksba_name_enum (ak_name, 0);
852   if (ak_name_str
853       && !strcmp (ak_name_str, issuerdn)
854       && !cmp_simple_canon_sexp (ak_sn, serialno))
855     {
856       result = 1;  /* Right, CERT is self-signed.  */
857       goto leave;
858     }
859
860   /* Similar for the ak_keyid. */
861   if (ak_keyid && !ksba_cert_get_subj_key_id (cert, NULL, &subj_keyid)
862       && !cmp_simple_canon_sexp (ak_keyid, subj_keyid))
863     {
864       result = 1;  /* Right, CERT is self-signed.  */
865       goto leave;
866     }
867
868
869  leave:
870   ksba_free (subj_keyid);
871   ksba_free (ak_keyid);
872   ksba_name_release (ak_name);
873   ksba_free (ak_sn);
874   ksba_free (serialno);
875   return result;
876 }
877
878
879
880 /* Check whether the CERT is a root certificate.  Returns True if this
881    is the case. */
882 int
883 gpgsm_is_root_cert (ksba_cert_t cert)
884 {
885   char *issuer;
886   char *subject;
887   int yes;
888
889   issuer = ksba_cert_get_issuer (cert, 0);
890   subject = ksba_cert_get_subject (cert, 0);
891   yes = is_root_cert (cert, issuer, subject);
892   xfree (issuer);
893   xfree (subject);
894   return yes;
895 }
896
897
898 /* This is a helper for gpgsm_validate_chain. */
899 static gpg_error_t
900 is_cert_still_valid (ctrl_t ctrl, int force_ocsp, int lm, estream_t fp,
901                      ksba_cert_t subject_cert, ksba_cert_t issuer_cert,
902                      int *any_revoked, int *any_no_crl, int *any_crl_too_old)
903 {
904   gpg_error_t err;
905
906   if (opt.no_crl_check && !ctrl->use_ocsp)
907     {
908       audit_log_ok (ctrl->audit, AUDIT_CRL_CHECK,
909                     gpg_error (GPG_ERR_NOT_ENABLED));
910       return 0;
911     }
912
913   err = gpgsm_dirmngr_isvalid (ctrl,
914                                subject_cert, issuer_cert,
915                                force_ocsp? 2 : !!ctrl->use_ocsp);
916   audit_log_ok (ctrl->audit, AUDIT_CRL_CHECK, err);
917
918   if (err)
919     {
920       if (!lm)
921         gpgsm_cert_log_name (NULL, subject_cert);
922       switch (gpg_err_code (err))
923         {
924         case GPG_ERR_CERT_REVOKED:
925           do_list (1, lm, fp, _("certificate has been revoked"));
926           *any_revoked = 1;
927           /* Store that in the keybox so that key listings are able to
928              return the revoked flag.  We don't care about error,
929              though. */
930           keydb_set_cert_flags (subject_cert, 1, KEYBOX_FLAG_VALIDITY, 0,
931                                 ~0, VALIDITY_REVOKED);
932           break;
933
934         case GPG_ERR_NO_CRL_KNOWN:
935           do_list (1, lm, fp, _("no CRL found for certificate"));
936           *any_no_crl = 1;
937           break;
938
939         case GPG_ERR_NO_DATA:
940           do_list (1, lm, fp, _("the status of the certificate is unknown"));
941           *any_no_crl = 1;
942           break;
943
944         case GPG_ERR_CRL_TOO_OLD:
945           do_list (1, lm, fp, _("the available CRL is too old"));
946           if (!lm)
947             log_info (_("please make sure that the "
948                         "\"dirmngr\" is properly installed\n"));
949           *any_crl_too_old = 1;
950           break;
951
952         default:
953           do_list (1, lm, fp, _("checking the CRL failed: %s"),
954                    gpg_strerror (err));
955           return err;
956         }
957     }
958   return 0;
959 }
960
961
962 /* Helper for gpgsm_validate_chain to check the validity period of
963    SUBJECT_CERT.  The caller needs to pass EXPTIME which will be
964    updated to the nearest expiration time seen.  A DEPTH of 0 indicates
965    the target certifciate, -1 the final root certificate and other
966    values intermediate certificates. */
967 static gpg_error_t
968 check_validity_period (ksba_isotime_t current_time,
969                        ksba_cert_t subject_cert,
970                        ksba_isotime_t exptime,
971                        int listmode, estream_t listfp, int depth)
972 {
973   gpg_error_t err;
974   ksba_isotime_t not_before, not_after;
975
976   err = ksba_cert_get_validity (subject_cert, 0, not_before);
977   if (!err)
978     err = ksba_cert_get_validity (subject_cert, 1, not_after);
979   if (err)
980     {
981       do_list (1, listmode, listfp,
982                _("certificate with invalid validity: %s"), gpg_strerror (err));
983       return gpg_error (GPG_ERR_BAD_CERT);
984     }
985
986   if (*not_after)
987     {
988       if (!*exptime)
989         gnupg_copy_time (exptime, not_after);
990       else if (strcmp (not_after, exptime) < 0 )
991         gnupg_copy_time (exptime, not_after);
992     }
993
994   if (*not_before && strcmp (current_time, not_before) < 0 )
995     {
996       do_list (1, listmode, listfp,
997                depth ==  0 ? _("certificate not yet valid") :
998                depth == -1 ? _("root certificate not yet valid") :
999                /* other */   _("intermediate certificate not yet valid"));
1000       if (!listmode)
1001         {
1002           log_info ("  (valid from ");
1003           dump_isotime (not_before);
1004           log_printf (")\n");
1005         }
1006       return gpg_error (GPG_ERR_CERT_TOO_YOUNG);
1007     }
1008
1009   if (*not_after && strcmp (current_time, not_after) > 0 )
1010     {
1011       do_list (opt.ignore_expiration?0:1, listmode, listfp,
1012                depth == 0  ? _("certificate has expired") :
1013                depth == -1 ? _("root certificate has expired") :
1014                /* other  */  _("intermediate certificate has expired"));
1015       if (!listmode)
1016         {
1017           log_info ("  (expired at ");
1018           dump_isotime (not_after);
1019           log_printf (")\n");
1020         }
1021       if (opt.ignore_expiration)
1022         log_info ("WARNING: ignoring expiration\n");
1023       else
1024         return gpg_error (GPG_ERR_CERT_EXPIRED);
1025     }
1026
1027   return 0;
1028 }
1029
1030 /* This is a variant of check_validity_period used with the chain
1031    model.  The dextra contraint here is that notBefore and notAfter
1032    must exists and if the additional argument CHECK_TIME is given this
1033    time is used to check the validity period of SUBJECT_CERT.  */
1034 static gpg_error_t
1035 check_validity_period_cm (ksba_isotime_t current_time,
1036                           ksba_isotime_t check_time,
1037                           ksba_cert_t subject_cert,
1038                           ksba_isotime_t exptime,
1039                           int listmode, estream_t listfp, int depth)
1040 {
1041   gpg_error_t err;
1042   ksba_isotime_t not_before, not_after;
1043
1044   err = ksba_cert_get_validity (subject_cert, 0, not_before);
1045   if (!err)
1046     err = ksba_cert_get_validity (subject_cert, 1, not_after);
1047   if (err)
1048     {
1049       do_list (1, listmode, listfp,
1050                _("certificate with invalid validity: %s"), gpg_strerror (err));
1051       return gpg_error (GPG_ERR_BAD_CERT);
1052     }
1053   if (!*not_before || !*not_after)
1054     {
1055       do_list (1, listmode, listfp,
1056                _("required certificate attributes missing: %s%s%s"),
1057                !*not_before? "notBefore":"",
1058                (!*not_before && !*not_after)? ", ":"",
1059                !*not_before? "notAfter":"");
1060       return gpg_error (GPG_ERR_BAD_CERT);
1061     }
1062   if (strcmp (not_before, not_after) > 0 )
1063     {
1064       do_list (1, listmode, listfp,
1065                _("certificate with invalid validity"));
1066       log_info ("  (valid from ");
1067       dump_isotime (not_before);
1068       log_printf (" expired at ");
1069       dump_isotime (not_after);
1070       log_printf (")\n");
1071       return gpg_error (GPG_ERR_BAD_CERT);
1072     }
1073
1074   if (!*exptime)
1075     gnupg_copy_time (exptime, not_after);
1076   else if (strcmp (not_after, exptime) < 0 )
1077     gnupg_copy_time (exptime, not_after);
1078
1079   if (strcmp (current_time, not_before) < 0 )
1080     {
1081       do_list (1, listmode, listfp,
1082                depth ==  0 ? _("certificate not yet valid") :
1083                depth == -1 ? _("root certificate not yet valid") :
1084                /* other */   _("intermediate certificate not yet valid"));
1085       if (!listmode)
1086         {
1087           log_info ("  (valid from ");
1088           dump_isotime (not_before);
1089           log_printf (")\n");
1090         }
1091       return gpg_error (GPG_ERR_CERT_TOO_YOUNG);
1092     }
1093
1094   if (*check_time
1095       && (strcmp (check_time, not_before) < 0
1096           || strcmp (check_time, not_after) > 0))
1097     {
1098       /* Note that we don't need a case for the root certificate
1099          because its own consitency has already been checked.  */
1100       do_list(opt.ignore_expiration?0:1, listmode, listfp,
1101               depth == 0 ?
1102               _("signature not created during lifetime of certificate") :
1103               depth == 1 ?
1104               _("certificate not created during lifetime of issuer") :
1105               _("intermediate certificate not created during lifetime "
1106                 "of issuer"));
1107       if (!listmode)
1108         {
1109           log_info (depth== 0? _("  (  signature created at ") :
1110                     /* */      _("  (certificate created at ") );
1111           dump_isotime (check_time);
1112           log_printf (")\n");
1113           log_info (depth==0? _("  (certificate valid from ") :
1114                     /* */     _("  (     issuer valid from ") );
1115           dump_isotime (not_before);
1116           log_info (" to ");
1117           dump_isotime (not_after);
1118           log_printf (")\n");
1119         }
1120       if (opt.ignore_expiration)
1121         log_info ("WARNING: ignoring expiration\n");
1122       else
1123         return gpg_error (GPG_ERR_CERT_EXPIRED);
1124     }
1125
1126   return 0;
1127 }
1128
1129
1130
1131 /* Ask the user whether he wants to mark the certificate CERT trusted.
1132    Returns true if the CERT is the trusted.  We also check whether the
1133    agent is at all enabled to allow marktrusted and don't call it in
1134    this session again if it is not.  */
1135 static int
1136 ask_marktrusted (ctrl_t ctrl, ksba_cert_t cert, int listmode)
1137 {
1138   static int no_more_questions;
1139   int rc;
1140   char *fpr;
1141   int success = 0;
1142
1143   fpr = gpgsm_get_fingerprint_string (cert, GCRY_MD_SHA1);
1144   log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
1145   xfree (fpr);
1146
1147   if (no_more_questions)
1148     rc = gpg_error (GPG_ERR_NOT_SUPPORTED);
1149   else
1150     rc = gpgsm_agent_marktrusted (ctrl, cert);
1151   if (!rc)
1152     {
1153       log_info (_("root certificate has now been marked as trusted\n"));
1154       success = 1;
1155     }
1156   else if (!listmode)
1157     {
1158       gpgsm_dump_cert ("issuer", cert);
1159       log_info ("after checking the fingerprint, you may want "
1160                 "to add it manually to the list of trusted certificates.\n");
1161     }
1162
1163   if (gpg_err_code (rc) == GPG_ERR_NOT_SUPPORTED)
1164     {
1165       if (!no_more_questions)
1166         log_info (_("interactive marking as trusted "
1167                     "not enabled in gpg-agent\n"));
1168       no_more_questions = 1;
1169     }
1170   else if (gpg_err_code (rc) == GPG_ERR_CANCELED)
1171     {
1172       log_info (_("interactive marking as trusted "
1173                   "disabled for this session\n"));
1174       no_more_questions = 1;
1175     }
1176   else
1177     set_already_asked_marktrusted (cert);
1178
1179   return success;
1180 }
1181
1182
1183
1184 \f
1185 /* Validate a chain and optionally return the nearest expiration time
1186    in R_EXPTIME. With LISTMODE set to 1 a special listmode is
1187    activated where only information about the certificate is printed
1188    to LISTFP and no output is send to the usual log stream.  If
1189    CHECKTIME_ARG is set, it is used only in the chain model instead of the
1190    current time.
1191
1192    Defined flag bits
1193
1194    VALIDATE_FLAG_NO_DIRMNGR  - Do not do any dirmngr isvalid checks.
1195    VALIDATE_FLAG_CHAIN_MODEL - Check according to chain model.
1196 */
1197 static int
1198 do_validate_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t checktime_arg,
1199                    ksba_isotime_t r_exptime,
1200                    int listmode, estream_t listfp, unsigned int flags,
1201                    struct rootca_flags_s *rootca_flags)
1202 {
1203   int rc = 0, depth, maxdepth;
1204   char *issuer = NULL;
1205   char *subject = NULL;
1206   KEYDB_HANDLE kh = NULL;
1207   ksba_cert_t subject_cert = NULL, issuer_cert = NULL;
1208   ksba_isotime_t current_time;
1209   ksba_isotime_t check_time;
1210   ksba_isotime_t exptime;
1211   int any_expired = 0;
1212   int any_revoked = 0;
1213   int any_no_crl = 0;
1214   int any_crl_too_old = 0;
1215   int any_no_policy_match = 0;
1216   int is_qualified = -1; /* Indicates whether the certificate stems
1217                             from a qualified root certificate.
1218                             -1 = unknown, 0 = no, 1 = yes. */
1219   chain_item_t chain = NULL; /* A list of all certificates in the chain.  */
1220
1221
1222   gnupg_get_isotime (current_time);
1223
1224   if ( (flags & VALIDATE_FLAG_CHAIN_MODEL) )
1225     {
1226       if (!strcmp (checktime_arg, "19700101T000000"))
1227         {
1228           do_list (1, listmode, listfp,
1229                    _("WARNING: creation time of signature not known - "
1230                      "assuming current time"));
1231           gnupg_copy_time (check_time, current_time);
1232         }
1233       else
1234         gnupg_copy_time (check_time, checktime_arg);
1235     }
1236   else
1237     *check_time = 0;
1238
1239   if (r_exptime)
1240     *r_exptime = 0;
1241   *exptime = 0;
1242
1243   if (opt.no_chain_validation && !listmode)
1244     {
1245       log_info ("WARNING: bypassing certificate chain validation\n");
1246       return 0;
1247     }
1248
1249   kh = keydb_new (0);
1250   if (!kh)
1251     {
1252       log_error (_("failed to allocated keyDB handle\n"));
1253       rc = gpg_error (GPG_ERR_GENERAL);
1254       goto leave;
1255     }
1256
1257   if (DBG_X509 && !listmode)
1258     gpgsm_dump_cert ("target", cert);
1259
1260   subject_cert = cert;
1261   ksba_cert_ref (subject_cert);
1262   maxdepth = 50;
1263   depth = 0;
1264
1265   for (;;)
1266     {
1267       int is_root;
1268       gpg_error_t istrusted_rc = -1;
1269
1270       /* Put the certificate on our list.  */
1271       {
1272         chain_item_t ci;
1273
1274         ci = xtrycalloc (1, sizeof *ci);
1275         if (!ci)
1276           {
1277             rc = gpg_error_from_syserror ();
1278             goto leave;
1279           }
1280         ksba_cert_ref (subject_cert);
1281         ci->cert = subject_cert;
1282         ci->next = chain;
1283         chain = ci;
1284       }
1285
1286       xfree (issuer);
1287       xfree (subject);
1288       issuer = ksba_cert_get_issuer (subject_cert, 0);
1289       subject = ksba_cert_get_subject (subject_cert, 0);
1290
1291       if (!issuer)
1292         {
1293           do_list (1, listmode, listfp,  _("no issuer found in certificate"));
1294           rc = gpg_error (GPG_ERR_BAD_CERT);
1295           goto leave;
1296         }
1297
1298
1299       /* Is this a self-issued certificate (i.e. the root certificate)?  */
1300       is_root = is_root_cert (subject_cert, issuer, subject);
1301       if (is_root)
1302         {
1303           chain->is_root = 1;
1304           /* Check early whether the certificate is listed as trusted.
1305              We used to do this only later but changed it to call the
1306              check right here so that we can access special flags
1307              associated with that specific root certificate.  */
1308           istrusted_rc = gpgsm_agent_istrusted (ctrl, subject_cert, NULL,
1309                                                 rootca_flags);
1310           audit_log_cert (ctrl->audit, AUDIT_ROOT_TRUSTED,
1311                           subject_cert, istrusted_rc);
1312           /* If the chain model extended attribute is used, make sure
1313              that our chain model flag is set. */
1314           if (has_validation_model_chain (subject_cert, listmode, listfp))
1315             rootca_flags->chain_model = 1;
1316         }
1317
1318
1319       /* Check the validity period. */
1320       if ( (flags & VALIDATE_FLAG_CHAIN_MODEL) )
1321         rc = check_validity_period_cm (current_time, check_time, subject_cert,
1322                                        exptime, listmode, listfp,
1323                                        (depth && is_root)? -1: depth);
1324       else
1325         rc = check_validity_period (current_time, subject_cert,
1326                                     exptime, listmode, listfp,
1327                                     (depth && is_root)? -1: depth);
1328       if (gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED)
1329         {
1330           any_expired = 1;
1331           rc = 0;
1332         }
1333       else if (rc)
1334         goto leave;
1335
1336
1337       /* Assert that we understand all critical extensions. */
1338       rc = unknown_criticals (subject_cert, listmode, listfp);
1339       if (rc)
1340         goto leave;
1341
1342       /* Do a policy check. */
1343       if (!opt.no_policy_check)
1344         {
1345           rc = check_cert_policy (subject_cert, listmode, listfp);
1346           if (gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH)
1347             {
1348               any_no_policy_match = 1;
1349               rc = 1;
1350             }
1351           else if (rc)
1352             goto leave;
1353         }
1354
1355
1356       /* If this is the root certificate we are at the end of the chain.  */
1357       if (is_root)
1358         {
1359           if (!istrusted_rc)
1360             ; /* No need to check the certificate for a trusted one. */
1361           else if (gpgsm_check_cert_sig (subject_cert, subject_cert) )
1362             {
1363               /* We only check the signature if the certificate is not
1364                  trusted for better diagnostics. */
1365               do_list (1, listmode, listfp,
1366                        _("self-signed certificate has a BAD signature"));
1367               if (DBG_X509)
1368                 {
1369                   gpgsm_dump_cert ("self-signing cert", subject_cert);
1370                 }
1371               rc = gpg_error (depth? GPG_ERR_BAD_CERT_CHAIN
1372                                    : GPG_ERR_BAD_CERT);
1373               goto leave;
1374             }
1375           if (!rootca_flags->relax)
1376             {
1377               rc = allowed_ca (ctrl, subject_cert, NULL, listmode, listfp);
1378               if (rc)
1379                 goto leave;
1380             }
1381
1382
1383           /* Set the flag for qualified signatures.  This flag is
1384              deduced from a list of root certificates allowed for
1385              qualified signatures. */
1386           if (is_qualified == -1)
1387             {
1388               gpg_error_t err;
1389               size_t buflen;
1390               char buf[1];
1391
1392               if (!ksba_cert_get_user_data (cert, "is_qualified",
1393                                             &buf, sizeof (buf),
1394                                             &buflen) && buflen)
1395                 {
1396                   /* We already checked this for this certificate,
1397                      thus we simply take it from the user data. */
1398                   is_qualified = !!*buf;
1399                 }
1400               else
1401                 {
1402                   /* Need to consult the list of root certificates for
1403                      qualified signatures. */
1404                   err = gpgsm_is_in_qualified_list (ctrl, subject_cert, NULL);
1405                   if (!err)
1406                     is_qualified = 1;
1407                   else if ( gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1408                     is_qualified = 0;
1409                   else
1410                     log_error ("checking the list of qualified "
1411                                "root certificates failed: %s\n",
1412                                gpg_strerror (err));
1413                   if ( is_qualified != -1 )
1414                     {
1415                       /* Cache the result but don't care too much
1416                          about an error. */
1417                       buf[0] = !!is_qualified;
1418                       err = ksba_cert_set_user_data (subject_cert,
1419                                                      "is_qualified", buf, 1);
1420                       if (err)
1421                         log_error ("set_user_data(is_qualified) failed: %s\n",
1422                                    gpg_strerror (err));
1423                     }
1424                 }
1425             }
1426
1427
1428           /* Act on the check for a trusted root certificates. */
1429           rc = istrusted_rc;
1430           if (!rc)
1431             ;
1432           else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
1433             {
1434               do_list (0, listmode, listfp,
1435                        _("root certificate is not marked trusted"));
1436               /* If we already figured out that the certificate is
1437                  expired it does not make much sense to ask the user
1438                  whether we wants to trust the root certificate.  We
1439                  should do this only if the certificate under question
1440                  will then be usable.  */
1441               if ( !any_expired
1442                    && (!listmode || !already_asked_marktrusted (subject_cert))
1443                    && ask_marktrusted (ctrl, subject_cert, listmode) )
1444                 rc = 0;
1445             }
1446           else
1447             {
1448               log_error (_("checking the trust list failed: %s\n"),
1449                          gpg_strerror (rc));
1450             }
1451
1452           if (rc)
1453             goto leave;
1454
1455           /* Check for revocations etc. */
1456           if ((flags & VALIDATE_FLAG_NO_DIRMNGR))
1457             ;
1458           else if (opt.no_trusted_cert_crl_check || rootca_flags->relax)
1459             ;
1460           else
1461             rc = is_cert_still_valid (ctrl,
1462                                       (flags & VALIDATE_FLAG_CHAIN_MODEL),
1463                                       listmode, listfp,
1464                                       subject_cert, subject_cert,
1465                                       &any_revoked, &any_no_crl,
1466                                       &any_crl_too_old);
1467           if (rc)
1468             goto leave;
1469
1470           break;  /* Okay: a self-signed certicate is an end-point. */
1471         } /* End is_root.  */
1472
1473
1474       /* Take care that the chain does not get too long. */
1475       if ((depth+1) > maxdepth)
1476         {
1477           do_list (1, listmode, listfp, _("certificate chain too long\n"));
1478           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
1479           goto leave;
1480         }
1481
1482       /* Find the next cert up the tree. */
1483       keydb_search_reset (kh);
1484       rc = find_up (ctrl, kh, subject_cert, issuer, 0);
1485       if (rc)
1486         {
1487           if (rc == -1)
1488             {
1489               do_list (0, listmode, listfp, _("issuer certificate not found"));
1490               if (!listmode)
1491                 {
1492                   log_info ("issuer certificate: #/");
1493                   gpgsm_dump_string (issuer);
1494                   log_printf ("\n");
1495                 }
1496             }
1497           else
1498             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
1499           rc = gpg_error (GPG_ERR_MISSING_ISSUER_CERT);
1500           goto leave;
1501         }
1502
1503       ksba_cert_release (issuer_cert); issuer_cert = NULL;
1504       rc = keydb_get_cert (kh, &issuer_cert);
1505       if (rc)
1506         {
1507           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
1508           rc = gpg_error (GPG_ERR_GENERAL);
1509           goto leave;
1510         }
1511
1512     try_another_cert:
1513       if (DBG_X509)
1514         {
1515           log_debug ("got issuer's certificate:\n");
1516           gpgsm_dump_cert ("issuer", issuer_cert);
1517         }
1518
1519       rc = gpgsm_check_cert_sig (issuer_cert, subject_cert);
1520       if (rc)
1521         {
1522           do_list (0, listmode, listfp, _("certificate has a BAD signature"));
1523           if (DBG_X509)
1524             {
1525               gpgsm_dump_cert ("signing issuer", issuer_cert);
1526               gpgsm_dump_cert ("signed subject", subject_cert);
1527             }
1528           if (gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE)
1529             {
1530               /* We now try to find other issuer certificates which
1531                  might have been used.  This is required because some
1532                  CAs are reusing the issuer and subject DN for new
1533                  root certificates. */
1534               /* FIXME: Do this only if we don't have an
1535                  AKI.keyIdentifier */
1536               rc = find_up (ctrl, kh, subject_cert, issuer, 1);
1537               if (!rc)
1538                 {
1539                   ksba_cert_t tmp_cert;
1540
1541                   rc = keydb_get_cert (kh, &tmp_cert);
1542                   if (rc || !compare_certs (issuer_cert, tmp_cert))
1543                     {
1544                       /* The find next did not work or returned an
1545                          identical certificate.  We better stop here
1546                          to avoid infinite checks. */
1547                       rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
1548                       ksba_cert_release (tmp_cert);
1549                     }
1550                   else
1551                     {
1552                       do_list (0, listmode, listfp,
1553                                _("found another possible matching "
1554                                  "CA certificate - trying again"));
1555                       ksba_cert_release (issuer_cert);
1556                       issuer_cert = tmp_cert;
1557                       goto try_another_cert;
1558                     }
1559                 }
1560             }
1561
1562           /* We give a more descriptive error code than the one
1563              returned from the signature checking. */
1564           rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
1565           goto leave;
1566         }
1567
1568       is_root = gpgsm_is_root_cert (issuer_cert);
1569       istrusted_rc = -1;
1570
1571
1572       /* Check that a CA is allowed to issue certificates. */
1573       {
1574         int chainlen;
1575
1576         rc = allowed_ca (ctrl, issuer_cert, &chainlen, listmode, listfp);
1577         if (rc)
1578           {
1579             /* Not allowed.  Check whether this is a trusted root
1580                certificate and whether we allow special exceptions.
1581                We could carry the result of the test over to the
1582                regular root check at the top of the loop but for
1583                clarity we won't do that.  Given that the majority of
1584                certificates carry proper BasicContraints our way of
1585                overriding an error in the way is justified for
1586                performance reasons. */
1587             if (is_root)
1588               {
1589                 istrusted_rc = gpgsm_agent_istrusted (ctrl, issuer_cert, NULL,
1590                                                       rootca_flags);
1591                 if (!istrusted_rc && rootca_flags->relax)
1592                   {
1593                     /* Ignore the error due to the relax flag.  */
1594                     rc = 0;
1595                     chainlen = -1;
1596                   }
1597               }
1598           }
1599         if (rc)
1600           goto leave;
1601         if (chainlen >= 0 && depth > chainlen)
1602           {
1603             do_list (1, listmode, listfp,
1604                      _("certificate chain longer than allowed by CA (%d)"),
1605                      chainlen);
1606             rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
1607             goto leave;
1608           }
1609       }
1610
1611       /* Is the certificate allowed to sign other certificates. */
1612       if (!listmode)
1613         {
1614           rc = gpgsm_cert_use_cert_p (issuer_cert);
1615           if (rc)
1616             {
1617               char numbuf[50];
1618               sprintf (numbuf, "%d", rc);
1619               gpgsm_status2 (ctrl, STATUS_ERROR, "certcert.issuer.keyusage",
1620                              numbuf, NULL);
1621               goto leave;
1622             }
1623         }
1624
1625       /* Check for revocations etc.  Note that for a root certificate
1626          this test is done a second time later. This should eventually
1627          be fixed. */
1628       if ((flags & VALIDATE_FLAG_NO_DIRMNGR))
1629         rc = 0;
1630       else if (is_root && (opt.no_trusted_cert_crl_check
1631                            || (!istrusted_rc && rootca_flags->relax)))
1632         rc = 0;
1633       else
1634         rc = is_cert_still_valid (ctrl,
1635                                   (flags & VALIDATE_FLAG_CHAIN_MODEL),
1636                                   listmode, listfp,
1637                                   subject_cert, issuer_cert,
1638                                   &any_revoked, &any_no_crl, &any_crl_too_old);
1639       if (rc)
1640         goto leave;
1641
1642
1643       if (opt.verbose && !listmode)
1644         log_info (depth == 0 ? _("certificate is good\n") :
1645                   !is_root   ? _("intermediate certificate is good\n") :
1646                   /* other */  _("root certificate is good\n"));
1647
1648       /* Under the chain model the next check time is the creation
1649          time of the subject certificate.  */
1650       if ( (flags & VALIDATE_FLAG_CHAIN_MODEL) )
1651         {
1652           rc = ksba_cert_get_validity (subject_cert, 0, check_time);
1653           if (rc)
1654             {
1655               /* That will never happen as we have already checked
1656                  this above.  */
1657               BUG ();
1658             }
1659         }
1660
1661       /* For the next round the current issuer becomes the new subject.  */
1662       keydb_search_reset (kh);
1663       ksba_cert_release (subject_cert);
1664       subject_cert = issuer_cert;
1665       issuer_cert = NULL;
1666       depth++;
1667     } /* End chain traversal. */
1668
1669   if (!listmode && !opt.quiet)
1670     {
1671       if (opt.no_policy_check)
1672         log_info ("policies not checked due to %s option\n",
1673                   "--disable-policy-checks");
1674       if (opt.no_crl_check && !ctrl->use_ocsp)
1675         log_info ("CRLs not checked due to %s option\n",
1676                   "--disable-crl-checks");
1677     }
1678
1679   if (!rc)
1680     { /* If we encountered an error somewhere during the checks, set
1681          the error code to the most critical one */
1682       if (any_revoked)
1683         rc = gpg_error (GPG_ERR_CERT_REVOKED);
1684       else if (any_expired)
1685         rc = gpg_error (GPG_ERR_CERT_EXPIRED);
1686       else if (any_no_crl)
1687         rc = gpg_error (GPG_ERR_NO_CRL_KNOWN);
1688       else if (any_crl_too_old)
1689         rc = gpg_error (GPG_ERR_CRL_TOO_OLD);
1690       else if (any_no_policy_match)
1691         rc = gpg_error (GPG_ERR_NO_POLICY_MATCH);
1692     }
1693
1694  leave:
1695   /* If we have traversed a complete chain up to the root we will
1696      reset the ephemeral flag for all these certificates.  This is done
1697      regardless of any error because those errors may only be
1698      transient. */
1699   if (chain && chain->is_root)
1700     {
1701       gpg_error_t err;
1702       chain_item_t ci;
1703
1704       for (ci = chain; ci; ci = ci->next)
1705         {
1706           /* Note that it is possible for the last certificate in the
1707              chain (i.e. our target certificate) that it has not yet
1708              been stored in the keybox and thus the flag can't be set.
1709              We ignore this error becuase it will later be stored
1710              anyway.  */
1711           err = keydb_set_cert_flags (ci->cert, 1, KEYBOX_FLAG_BLOB, 0,
1712                                       KEYBOX_FLAG_BLOB_EPHEMERAL, 0);
1713           if (!ci->next && gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1714             ;
1715           else if (err)
1716             log_error ("clearing ephemeral flag failed: %s\n",
1717                        gpg_strerror (err));
1718         }
1719     }
1720
1721   /* If we have figured something about the qualified signature
1722      capability of the certificate under question, store the result as
1723      user data in all certificates of the chain.  We do this even if the
1724      validation itself failed.  */
1725   if (is_qualified != -1)
1726     {
1727       gpg_error_t err;
1728       chain_item_t ci;
1729       char buf[1];
1730
1731       buf[0] = !!is_qualified;
1732
1733       for (ci = chain; ci; ci = ci->next)
1734         {
1735           err = ksba_cert_set_user_data (ci->cert, "is_qualified", buf, 1);
1736           if (err)
1737             {
1738               log_error ("set_user_data(is_qualified) failed: %s\n",
1739                          gpg_strerror (err));
1740               if (!rc)
1741                 rc = err;
1742             }
1743         }
1744     }
1745
1746   /* If auditing has been enabled, record what is in the chain.  */
1747   if (ctrl->audit)
1748     {
1749       chain_item_t ci;
1750
1751       audit_log (ctrl->audit, AUDIT_CHAIN_BEGIN);
1752       for (ci = chain; ci; ci = ci->next)
1753         {
1754           audit_log_cert (ctrl->audit,
1755                           ci->is_root? AUDIT_CHAIN_ROOTCERT : AUDIT_CHAIN_CERT,
1756                           ci->cert, 0);
1757         }
1758       audit_log (ctrl->audit, AUDIT_CHAIN_END);
1759     }
1760
1761   if (r_exptime)
1762     gnupg_copy_time (r_exptime, exptime);
1763   xfree (issuer);
1764   xfree (subject);
1765   keydb_release (kh);
1766   while (chain)
1767     {
1768       chain_item_t ci_next = chain->next;
1769       ksba_cert_release (chain->cert);
1770       xfree (chain);
1771       chain = ci_next;
1772     }
1773   ksba_cert_release (issuer_cert);
1774   ksba_cert_release (subject_cert);
1775   return rc;
1776 }
1777
1778
1779 /* Validate a certificate chain.  For a description see
1780    do_validate_chain.  This function is a wrapper to handle a root
1781    certificate with the chain_model flag set.  If RETFLAGS is not
1782    NULL, flags indicating now the verification was done are stored
1783    there.  The only defined flag for RETFLAGS is
1784    VALIDATE_FLAG_CHAIN_MODEL.
1785
1786    If you are verifying a signature you should set CHECKTIME to the
1787    creation time of the signature.  If your are verifying a
1788    certificate, set it nil (i.e. the empty string).  If the creation
1789    date of the signature is not known use the special date
1790    "19700101T000000" which is treated in a special way here. */
1791 int
1792 gpgsm_validate_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t checktime,
1793                       ksba_isotime_t r_exptime,
1794                       int listmode, estream_t listfp, unsigned int flags,
1795                       unsigned int *retflags)
1796 {
1797   int rc;
1798   struct rootca_flags_s rootca_flags;
1799   unsigned int dummy_retflags;
1800
1801   if (!retflags)
1802     retflags = &dummy_retflags;
1803
1804   if (ctrl->validation_model == 1)
1805     flags |= VALIDATE_FLAG_CHAIN_MODEL;
1806
1807   *retflags = (flags & VALIDATE_FLAG_CHAIN_MODEL);
1808   memset (&rootca_flags, 0, sizeof rootca_flags);
1809
1810   rc = do_validate_chain (ctrl, cert, checktime,
1811                           r_exptime, listmode, listfp, flags,
1812                           &rootca_flags);
1813   if (gpg_err_code (rc) == GPG_ERR_CERT_EXPIRED
1814       && !(flags & VALIDATE_FLAG_CHAIN_MODEL)
1815       && (rootca_flags.valid && rootca_flags.chain_model))
1816     {
1817       do_list (0, listmode, listfp, _("switching to chain model"));
1818       rc = do_validate_chain (ctrl, cert, checktime,
1819                               r_exptime, listmode, listfp,
1820                               (flags |= VALIDATE_FLAG_CHAIN_MODEL),
1821                               &rootca_flags);
1822       *retflags |= VALIDATE_FLAG_CHAIN_MODEL;
1823     }
1824
1825   if (opt.verbose)
1826     do_list (0, listmode, listfp, _("validation model used: %s"),
1827              (*retflags & VALIDATE_FLAG_CHAIN_MODEL)?
1828              _("chain"):_("shell"));
1829
1830   return rc;
1831 }
1832
1833
1834 /* Check that the given certificate is valid but DO NOT check any
1835    constraints.  We assume that the issuers certificate is already in
1836    the DB and that this one is valid; which it should be because it
1837    has been checked using this function. */
1838 int
1839 gpgsm_basic_cert_check (ctrl_t ctrl, ksba_cert_t cert)
1840 {
1841   int rc = 0;
1842   char *issuer = NULL;
1843   char *subject = NULL;
1844   KEYDB_HANDLE kh;
1845   ksba_cert_t issuer_cert = NULL;
1846
1847   if (opt.no_chain_validation)
1848     {
1849       log_info ("WARNING: bypassing basic certificate checks\n");
1850       return 0;
1851     }
1852
1853   kh = keydb_new (0);
1854   if (!kh)
1855     {
1856       log_error (_("failed to allocated keyDB handle\n"));
1857       rc = gpg_error (GPG_ERR_GENERAL);
1858       goto leave;
1859     }
1860
1861   issuer = ksba_cert_get_issuer (cert, 0);
1862   subject = ksba_cert_get_subject (cert, 0);
1863   if (!issuer)
1864     {
1865       log_error ("no issuer found in certificate\n");
1866       rc = gpg_error (GPG_ERR_BAD_CERT);
1867       goto leave;
1868     }
1869
1870   if (is_root_cert (cert, issuer, subject))
1871     {
1872       rc = gpgsm_check_cert_sig (cert, cert);
1873       if (rc)
1874         {
1875           log_error ("self-signed certificate has a BAD signature: %s\n",
1876                      gpg_strerror (rc));
1877           if (DBG_X509)
1878             {
1879               gpgsm_dump_cert ("self-signing cert", cert);
1880             }
1881           rc = gpg_error (GPG_ERR_BAD_CERT);
1882           goto leave;
1883         }
1884     }
1885   else
1886     {
1887       /* Find the next cert up the tree. */
1888       keydb_search_reset (kh);
1889       rc = find_up (ctrl, kh, cert, issuer, 0);
1890       if (rc)
1891         {
1892           if (rc == -1)
1893             {
1894               log_info ("issuer certificate (#/");
1895               gpgsm_dump_string (issuer);
1896               log_printf (") not found\n");
1897             }
1898           else
1899             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
1900           rc = gpg_error (GPG_ERR_MISSING_ISSUER_CERT);
1901           goto leave;
1902         }
1903
1904       ksba_cert_release (issuer_cert); issuer_cert = NULL;
1905       rc = keydb_get_cert (kh, &issuer_cert);
1906       if (rc)
1907         {
1908           log_error ("keydb_get_cert() failed: rc=%d\n", rc);
1909           rc = gpg_error (GPG_ERR_GENERAL);
1910           goto leave;
1911         }
1912
1913       rc = gpgsm_check_cert_sig (issuer_cert, cert);
1914       if (rc)
1915         {
1916           log_error ("certificate has a BAD signature: %s\n",
1917                      gpg_strerror (rc));
1918           if (DBG_X509)
1919             {
1920               gpgsm_dump_cert ("signing issuer", issuer_cert);
1921               gpgsm_dump_cert ("signed subject", cert);
1922             }
1923           rc = gpg_error (GPG_ERR_BAD_CERT);
1924           goto leave;
1925         }
1926       if (opt.verbose)
1927         log_info (_("certificate is good\n"));
1928     }
1929
1930  leave:
1931   xfree (issuer);
1932   xfree (subject);
1933   keydb_release (kh);
1934   ksba_cert_release (issuer_cert);
1935   return rc;
1936 }
1937
1938
1939
1940 /* Check whether the certificate CERT has been issued by the German
1941    authority for qualified signature.  They do not set the
1942    basicConstraints and thus we need this workaround.  It works by
1943    looking up the root certificate and checking whether that one is
1944    listed as a qualified certificate for Germany.
1945
1946    We also try to cache this data but as long as don't keep a
1947    reference to the certificate this won't be used.
1948
1949    Returns: True if CERT is a RegTP issued CA cert (i.e. the root
1950    certificate itself or one of the CAs).  In that case CHAINLEN will
1951    receive the length of the chain which is either 0 or 1.
1952 */
1953 static int
1954 get_regtp_ca_info (ctrl_t ctrl, ksba_cert_t cert, int *chainlen)
1955 {
1956   gpg_error_t err;
1957   ksba_cert_t next;
1958   int rc = 0;
1959   int i, depth;
1960   char country[3];
1961   ksba_cert_t array[4];
1962   char buf[2];
1963   size_t buflen;
1964   int dummy_chainlen;
1965
1966   if (!chainlen)
1967     chainlen = &dummy_chainlen;
1968
1969   *chainlen = 0;
1970   err = ksba_cert_get_user_data (cert, "regtp_ca_chainlen",
1971                                  &buf, sizeof (buf), &buflen);
1972   if (!err)
1973     {
1974       /* Got info. */
1975       if (buflen < 2 || !*buf)
1976         return 0; /* Nothing found. */
1977       *chainlen = buf[1];
1978       return 1; /* This is a regtp CA. */
1979     }
1980   else if (gpg_err_code (err) != GPG_ERR_NOT_FOUND)
1981     {
1982       log_error ("ksba_cert_get_user_data(%s) failed: %s\n",
1983                  "regtp_ca_chainlen", gpg_strerror (err));
1984       return 0; /* Nothing found.  */
1985     }
1986
1987   /* Need to gather the info.  This requires to walk up the chain
1988      until we have found the root.  Because we are only interested in
1989      German Bundesnetzagentur (former RegTP) derived certificates 3
1990      levels are enough.  (The German signature law demands a 3 tier
1991      hierachy; thus there is only one CA between the EE and the Root
1992      CA.)  */
1993   memset (&array, 0, sizeof array);
1994
1995   depth = 0;
1996   ksba_cert_ref (cert);
1997   array[depth++] = cert;
1998   ksba_cert_ref (cert);
1999   while (depth < DIM(array) && !(rc=gpgsm_walk_cert_chain (ctrl, cert, &next)))
2000     {
2001       ksba_cert_release (cert);
2002       ksba_cert_ref (next);
2003       array[depth++] = next;
2004       cert = next;
2005     }
2006   ksba_cert_release (cert);
2007   if (rc != -1 || !depth || depth == DIM(array) )
2008     {
2009       /* We did not reached the root. */
2010       goto leave;
2011     }
2012
2013   /* If this is a German signature law issued certificate, we store
2014      additional additional information. */
2015   if (!gpgsm_is_in_qualified_list (NULL, array[depth-1], country)
2016       && !strcmp (country, "de"))
2017     {
2018       /* Setting the pathlen for the root CA and the CA flag for the
2019          next one is all what we need to do. */
2020       err = ksba_cert_set_user_data (array[depth-1], "regtp_ca_chainlen",
2021                                      "\x01\x01", 2);
2022       if (!err && depth > 1)
2023         err = ksba_cert_set_user_data (array[depth-2], "regtp_ca_chainlen",
2024                                        "\x01\x00", 2);
2025       if (err)
2026         log_error ("ksba_set_user_data(%s) failed: %s\n",
2027                    "regtp_ca_chainlen", gpg_strerror (err));
2028       for (i=0; i < depth; i++)
2029         ksba_cert_release (array[i]);
2030       *chainlen = (depth>1? 0:1);
2031       return 1;
2032     }
2033
2034  leave:
2035   /* Nothing special with this certificate. Mark the target
2036      certificate anyway to avoid duplicate lookups. */
2037   err = ksba_cert_set_user_data (cert, "regtp_ca_chainlen", "", 1);
2038   if (err)
2039     log_error ("ksba_set_user_data(%s) failed: %s\n",
2040                "regtp_ca_chainlen", gpg_strerror (err));
2041   for (i=0; i < depth; i++)
2042     ksba_cert_release (array[i]);
2043   return 0;
2044 }