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