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