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