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