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