dirmngr: Load all system provided certificates.
[gnupg.git] / dirmngr / certcache.c
1 /* certcache.c - Certificate caching
2  * Copyright (C) 2004, 2005, 2007, 2008, 2017 g10 Code GmbH
3  *
4  * This file is part of DirMngr.
5  *
6  * DirMngr is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * DirMngr is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <https://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <errno.h>
25 #include <assert.h>
26 #include <sys/types.h>
27 #include <dirent.h>
28 #include <npth.h>
29
30 #include "dirmngr.h"
31 #include "misc.h"
32 #include "../common/ksba-io-support.h"
33 #include "crlfetch.h"
34 #include "certcache.h"
35
36 #define MAX_EXTRA_CACHED_CERTS 1000
37
38 /* Constants used to classify search patterns.  */
39 enum pattern_class
40   {
41     PATTERN_UNKNOWN = 0,
42     PATTERN_EMAIL,
43     PATTERN_EMAIL_SUBSTR,
44     PATTERN_FINGERPRINT16,
45     PATTERN_FINGERPRINT20,
46     PATTERN_SHORT_KEYID,
47     PATTERN_LONG_KEYID,
48     PATTERN_SUBJECT,
49     PATTERN_SERIALNO,
50     PATTERN_SERIALNO_ISSUER,
51     PATTERN_ISSUER,
52     PATTERN_SUBSTR
53   };
54
55
56 /* A certificate cache item.  This consists of a the KSBA cert object
57    and some meta data for easier lookup.  We use a hash table to keep
58    track of all items and use the (randomly distributed) first byte of
59    the fingerprint directly as the hash which makes it pretty easy. */
60 struct cert_item_s
61 {
62   struct cert_item_s *next; /* Next item with the same hash value. */
63   ksba_cert_t cert;         /* The KSBA cert object or NULL is this is
64                                not a valid item.  */
65   unsigned char fpr[20];    /* The fingerprint of this object. */
66   char *issuer_dn;          /* The malloced issuer DN.  */
67   ksba_sexp_t sn;           /* The malloced serial number  */
68   char *subject_dn;         /* The malloced subject DN - maybe NULL.  */
69   struct
70   {
71     unsigned int config:1;  /* This has been loaded from the configuration.  */
72     unsigned int trusted:1; /* This is a trusted root certificate.  */
73     unsigned int systrust:1;/* The certifciate is trusted because it
74                              * is in the system's store of trusted
75                              * certificates (i.e. not configured using
76                              * GnuPG mechanisms.  */
77   } flags;
78 };
79 typedef struct cert_item_s *cert_item_t;
80
81 /* The actual cert cache consisting of 256 slots for items indexed by
82    the first byte of the fingerprint.  */
83 static cert_item_t cert_cache[256];
84
85 /* This is the global cache_lock variable. In general locking is not
86    needed but it would take extra efforts to make sure that no
87    indirect use of npth functions is done, so we simply lock it
88    always.  Note: We can't use static initialization, as that is not
89    available through w32-pth.  */
90 static npth_rwlock_t cert_cache_lock;
91
92 /* Flag to track whether the cache has been initialized.  */
93 static int initialization_done;
94
95 /* Total number of certificates loaded during initialization
96  * (ie. configured), extra certificates cached during operation,
97  * number of trusted and system trusted certificates.  */
98 static unsigned int total_config_certificates;
99 static unsigned int total_extra_certificates;
100 static unsigned int total_trusted_certificates;
101 static unsigned int total_system_trusted_certificates;
102
103 \f
104 /* Helper to do the cache locking.  */
105 static void
106 init_cache_lock (void)
107 {
108   int err;
109
110   err = npth_rwlock_init (&cert_cache_lock, NULL);
111   if (err)
112     log_fatal (_("can't initialize certificate cache lock: %s\n"),
113                strerror (err));
114 }
115
116 static void
117 acquire_cache_read_lock (void)
118 {
119   int err;
120
121   err = npth_rwlock_rdlock (&cert_cache_lock);
122   if (err)
123     log_fatal (_("can't acquire read lock on the certificate cache: %s\n"),
124                strerror (err));
125 }
126
127 static void
128 acquire_cache_write_lock (void)
129 {
130   int err;
131
132   err = npth_rwlock_wrlock (&cert_cache_lock);
133   if (err)
134     log_fatal (_("can't acquire write lock on the certificate cache: %s\n"),
135                strerror (err));
136 }
137
138 static void
139 release_cache_lock (void)
140 {
141   int err;
142
143   err = npth_rwlock_unlock (&cert_cache_lock);
144   if (err)
145     log_fatal (_("can't release lock on the certificate cache: %s\n"),
146                strerror (err));
147 }
148
149
150 /* Return false if both serial numbers match.  Can't be used for
151    sorting. */
152 static int
153 compare_serialno (ksba_sexp_t serial1, ksba_sexp_t serial2 )
154 {
155   unsigned char *a = serial1;
156   unsigned char *b = serial2;
157   return cmp_simple_canon_sexp (a, b);
158 }
159
160
161
162 /* Return a malloced canonical S-Expression with the serial number
163  * converted from the hex string HEXSN.  Return NULL on memory
164  * error.  */
165 ksba_sexp_t
166 hexsn_to_sexp (const char *hexsn)
167 {
168   char *buffer, *p;
169   size_t len;
170   char numbuf[40];
171
172   len = unhexify (NULL, hexsn);
173   snprintf (numbuf, sizeof numbuf, "(%u:", (unsigned int)len);
174   buffer = xtrymalloc (strlen (numbuf) + len + 2 );
175   if (!buffer)
176     return NULL;
177   p = stpcpy (buffer, numbuf);
178   len = unhexify (p, hexsn);
179   p[len] = ')';
180   p[len+1] = 0;
181
182   return buffer;
183 }
184
185
186 /* Compute the fingerprint of the certificate CERT and put it into
187    the 20 bytes large buffer DIGEST.  Return address of this buffer.  */
188 unsigned char *
189 cert_compute_fpr (ksba_cert_t cert, unsigned char *digest)
190 {
191   gpg_error_t err;
192   gcry_md_hd_t md;
193
194   err = gcry_md_open (&md, GCRY_MD_SHA1, 0);
195   if (err)
196     log_fatal ("gcry_md_open failed: %s\n", gpg_strerror (err));
197
198   err = ksba_cert_hash (cert, 0, HASH_FNC, md);
199   if (err)
200     {
201       log_error ("oops: ksba_cert_hash failed: %s\n", gpg_strerror (err));
202       memset (digest, 0xff, 20); /* Use a dummy value. */
203     }
204   else
205     {
206       gcry_md_final (md);
207       memcpy (digest, gcry_md_read (md, GCRY_MD_SHA1), 20);
208     }
209   gcry_md_close (md);
210   return digest;
211 }
212
213
214 /* Cleanup one slot.  This releases all resourses but keeps the actual
215    slot in the cache marked for reuse. */
216 static void
217 clean_cache_slot (cert_item_t ci)
218 {
219   ksba_cert_t cert;
220
221   if (!ci->cert)
222     return; /* Already cleaned.  */
223
224   ksba_free (ci->sn);
225   ci->sn = NULL;
226   ksba_free (ci->issuer_dn);
227   ci->issuer_dn = NULL;
228   ksba_free (ci->subject_dn);
229   ci->subject_dn = NULL;
230   cert = ci->cert;
231   ci->cert = NULL;
232
233   ksba_cert_release (cert);
234 }
235
236
237 /* Put the certificate CERT into the cache.  It is assumed that the
238  * cache is locked while this function is called.
239  *
240  * FROM_CONFIG indicates that CERT is a permanent certificate and
241  * should stay in the cache.  IS_TRUSTED requests that the trusted
242  * flag is set for the certificate; a value of 1 indicates the the
243  * cert is trusted due to GnuPG mechanisms, a value of 2 indicates
244  * that it is trusted because it has been taken from the system's
245  * store of trusted certificates.  If FPR_BUFFER is not NULL the
246  * fingerprint of the certificate will be stored there.  FPR_BUFFER
247  * needs to point to a buffer of at least 20 bytes.  The fingerprint
248  * will be stored on success or when the function returns
249  * GPG_ERR_DUP_VALUE.  */
250 static gpg_error_t
251 put_cert (ksba_cert_t cert, int from_config, int is_trusted, void *fpr_buffer)
252 {
253   unsigned char help_fpr_buffer[20], *fpr;
254   cert_item_t ci;
255
256   fpr = fpr_buffer? fpr_buffer : &help_fpr_buffer;
257
258   /* If we already reached the caching limit, drop a couple of certs
259    * from the cache.  Our dropping strategy is simple: We keep a
260    * static index counter and use this to start looking for
261    * certificates, then we drop 5 percent of the oldest certificates
262    * starting at that index.  For a large cache this is a fair way of
263    * removing items.  An LRU strategy would be better of course.
264    * Because we append new entries to the head of the list and we want
265    * to remove old ones first, we need to do this from the tail.  The
266    * implementation is not very efficient but compared to the long
267    * time it takes to retrieve a certificate from an external resource
268    * it seems to be reasonable.  */
269   if (!from_config && total_extra_certificates >= MAX_EXTRA_CACHED_CERTS)
270     {
271       static int idx;
272       cert_item_t ci_mark;
273       int i;
274       unsigned int drop_count;
275
276       drop_count = MAX_EXTRA_CACHED_CERTS / 20;
277       if (drop_count < 2)
278         drop_count = 2;
279
280       log_info (_("dropping %u certificates from the cache\n"), drop_count);
281       assert (idx < 256);
282       for (i=idx; drop_count; i = ((i+1)%256))
283         {
284           ci_mark = NULL;
285           for (ci = cert_cache[i]; ci; ci = ci->next)
286             if (ci->cert && !ci->flags.config)
287               ci_mark = ci;
288           if (ci_mark)
289             {
290               clean_cache_slot (ci_mark);
291               drop_count--;
292               total_extra_certificates--;
293               if (ci->flags.trusted)
294                 total_trusted_certificates--;
295               if (ci->flags.systrust)
296                 total_system_trusted_certificates--;
297             }
298         }
299       if (i==idx)
300         idx++;
301       else
302         idx = i;
303       idx %= 256;
304     }
305
306   cert_compute_fpr (cert, fpr);
307   for (ci=cert_cache[*fpr]; ci; ci = ci->next)
308     if (ci->cert && !memcmp (ci->fpr, fpr, 20))
309       return gpg_error (GPG_ERR_DUP_VALUE);
310   /* Try to reuse an existing entry.  */
311   for (ci=cert_cache[*fpr]; ci; ci = ci->next)
312     if (!ci->cert)
313       break;
314   if (!ci)
315     { /* No: Create a new entry.  */
316       ci = xtrycalloc (1, sizeof *ci);
317       if (!ci)
318         return gpg_error_from_errno (errno);
319       ci->next = cert_cache[*fpr];
320       cert_cache[*fpr] = ci;
321     }
322   else
323     memset (&ci->flags, 0, sizeof ci->flags);
324
325   ksba_cert_ref (cert);
326   ci->cert = cert;
327   memcpy (ci->fpr, fpr, 20);
328   ci->sn = ksba_cert_get_serial (cert);
329   ci->issuer_dn = ksba_cert_get_issuer (cert, 0);
330   if (!ci->issuer_dn || !ci->sn)
331     {
332       clean_cache_slot (ci);
333       return gpg_error (GPG_ERR_INV_CERT_OBJ);
334     }
335   ci->subject_dn = ksba_cert_get_subject (cert, 0);
336   ci->flags.config  = !!from_config;
337   ci->flags.trusted = !!is_trusted;
338   ci->flags.systrust = (is_trusted && is_trusted == 2);
339
340   if (ci->flags.trusted)
341     total_trusted_certificates++;
342   if (ci->flags.systrust)
343     total_system_trusted_certificates++;
344
345   if (from_config)
346     total_config_certificates++;
347   else
348     total_extra_certificates++;
349
350   return 0;
351 }
352
353
354 /* Load certificates from the directory DIRNAME.  All certificates
355    matching the pattern "*.crt" or "*.der"  are loaded.  We assume that
356    certificates are DER encoded and not PEM encapsulated. The cache
357    should be in a locked state when calling this function.  */
358 static gpg_error_t
359 load_certs_from_dir (const char *dirname, int are_trusted)
360 {
361   gpg_error_t err;
362   DIR *dir;
363   struct dirent *ep;
364   char *p;
365   size_t n;
366   estream_t fp;
367   ksba_reader_t reader;
368   ksba_cert_t cert;
369   char *fname = NULL;
370
371   dir = opendir (dirname);
372   if (!dir)
373     {
374       return 0; /* We do not consider this a severe error.  */
375     }
376
377   while ( (ep=readdir (dir)) )
378     {
379       p = ep->d_name;
380       if (*p == '.' || !*p)
381         continue; /* Skip any hidden files and invalid entries.  */
382       n = strlen (p);
383       if ( n < 5 || (strcmp (p+n-4,".crt") && strcmp (p+n-4,".der")))
384         continue; /* Not the desired "*.crt" or "*.der" pattern.  */
385
386       xfree (fname);
387       fname = make_filename (dirname, p, NULL);
388       fp = es_fopen (fname, "rb");
389       if (!fp)
390         {
391           log_error (_("can't open '%s': %s\n"),
392                      fname, strerror (errno));
393           continue;
394         }
395
396       err = create_estream_ksba_reader (&reader, fp);
397       if (err)
398         {
399           es_fclose (fp);
400           continue;
401         }
402
403       err = ksba_cert_new (&cert);
404       if (!err)
405         err = ksba_cert_read_der (cert, reader);
406       ksba_reader_release (reader);
407       es_fclose (fp);
408       if (err)
409         {
410           log_error (_("can't parse certificate '%s': %s\n"),
411                      fname, gpg_strerror (err));
412           ksba_cert_release (cert);
413           continue;
414         }
415
416       err = put_cert (cert, 1, !!are_trusted, NULL);
417       if (gpg_err_code (err) == GPG_ERR_DUP_VALUE)
418         log_info (_("certificate '%s' already cached\n"), fname);
419       else if (!err)
420         {
421           if (are_trusted)
422             log_info (_("trusted certificate '%s' loaded\n"), fname);
423           else
424             log_info (_("certificate '%s' loaded\n"), fname);
425           if (opt.verbose)
426             {
427               p = get_fingerprint_hexstring_colon (cert);
428               log_info (_("  SHA1 fingerprint = %s\n"), p);
429               xfree (p);
430
431               cert_log_name (_("   issuer ="), cert);
432               cert_log_subject (_("  subject ="), cert);
433             }
434         }
435       else
436         log_error (_("error loading certificate '%s': %s\n"),
437                      fname, gpg_strerror (err));
438       ksba_cert_release (cert);
439     }
440
441   xfree (fname);
442   closedir (dir);
443   return 0;
444 }
445
446
447 /* Load certificates from FILE.  The certifciates are expected to be
448  * PEM encoded so that it is possible to load several certificates.
449  * All certates rea considered to be system provided trusted
450  * certificates.  The cache should be in a locked state when calling
451  * this function.  */
452 static gpg_error_t
453 load_certs_from_file (const char *fname)
454 {
455   gpg_error_t err;
456   estream_t fp = NULL;
457   gnupg_ksba_io_t ioctx = NULL;
458   ksba_reader_t reader;
459   ksba_cert_t cert = NULL;
460
461   fp = es_fopen (fname, "rb");
462   if (!fp)
463     {
464       err = gpg_error_from_syserror ();
465       log_error (_("can't open '%s': %s\n"), fname, gpg_strerror (err));
466       goto leave;
467     }
468
469   err = gnupg_ksba_create_reader (&ioctx,
470                                   (GNUPG_KSBA_IO_PEM | GNUPG_KSBA_IO_MULTIPEM),
471                                   fp, &reader);
472   if (err)
473     {
474       log_error ("can't create reader: %s\n", gpg_strerror (err));
475       goto leave;
476     }
477
478   /* Loop to read all certificates from the file.  */
479   do
480     {
481       ksba_cert_release (cert);
482       cert = NULL;
483       err = ksba_cert_new (&cert);
484       if (!err)
485         err = ksba_cert_read_der (cert, reader);
486       if (err)
487         {
488           if (gpg_err_code (err) == GPG_ERR_EOF)
489             err = 0;
490           else
491             log_error (_("can't parse certificate '%s': %s\n"),
492                        fname, gpg_strerror (err));
493           goto leave;
494         }
495
496       err = put_cert (cert, 1, 2, NULL);
497       if (gpg_err_code (err) == GPG_ERR_DUP_VALUE)
498         log_info (_("certificate '%s' already cached\n"), fname);
499       else if (err)
500         log_error (_("error loading certificate '%s': %s\n"),
501                    fname, gpg_strerror (err));
502       else if (opt.verbose > 1)
503         {
504           char *p;
505
506           log_info (_("trusted certificate '%s' loaded\n"), fname);
507           p = get_fingerprint_hexstring_colon (cert);
508           log_info (_("  SHA1 fingerprint = %s\n"), p);
509           xfree (p);
510
511           cert_log_name    (_("   issuer ="), cert);
512           cert_log_subject (_("  subject ="), cert);
513         }
514
515       ksba_reader_clear (reader, NULL, NULL);
516     }
517   while (!gnupg_ksba_reader_eof_seen (ioctx));
518
519  leave:
520   ksba_cert_release (cert);
521   gnupg_ksba_destroy_reader (ioctx);
522   es_fclose (fp);
523
524   return err;
525 }
526
527
528 /* Load the trusted certificates provided by the system.  */
529 static gpg_error_t
530 load_certs_from_system (void)
531 {
532   /* A list of certificate bundles to try.  */
533   static struct {
534     const char *name;
535   } table[] = {
536 #ifdef DEFAULT_TRUST_STORE_FILE
537     { DEFAULT_TRUST_STORE_FILE }
538 #else
539     { "/etc/ssl/ca-bundle.pem" },
540     { "/etc/ssl/certs/ca-certificates.crt" },
541     { "/etc/pki/tls/cert.pem" },
542     { "/usr/local/share/certs/ca-root-nss.crt" },
543     { "/etc/ssl/cert.pem" }
544 #endif /*!DEFAULT_TRUST_STORE_FILE*/
545   };
546   int idx;
547   gpg_error_t err = 0;
548
549   for (idx=0; idx < DIM (table); idx++)
550     if (!access (table[idx].name, F_OK))
551       {
552         /* Take the first available bundle.  */
553         err = load_certs_from_file (table[idx].name);
554         break;
555       }
556
557
558   return err;
559 }
560
561
562 /* Initialize the certificate cache if not yet done.  */
563 void
564 cert_cache_init (void)
565 {
566   char *dname;
567
568   if (initialization_done)
569     return;
570   init_cache_lock ();
571   acquire_cache_write_lock ();
572
573   load_certs_from_system ();
574
575   dname = make_filename (gnupg_sysconfdir (), "trusted-certs", NULL);
576   load_certs_from_dir (dname, 1);
577   xfree (dname);
578
579   dname = make_filename (gnupg_sysconfdir (), "extra-certs", NULL);
580   load_certs_from_dir (dname, 0);
581   xfree (dname);
582
583   initialization_done = 1;
584   release_cache_lock ();
585
586   cert_cache_print_stats ();
587 }
588
589 /* Deinitialize the certificate cache.  With FULL set to true even the
590    unused certificate slots are released. */
591 void
592 cert_cache_deinit (int full)
593 {
594   cert_item_t ci, ci2;
595   int i;
596
597   if (!initialization_done)
598     return;
599
600   acquire_cache_write_lock ();
601
602   for (i=0; i < 256; i++)
603     for (ci=cert_cache[i]; ci; ci = ci->next)
604       clean_cache_slot (ci);
605
606   if (full)
607     {
608       for (i=0; i < 256; i++)
609         {
610           for (ci=cert_cache[i]; ci; ci = ci2)
611             {
612               ci2 = ci->next;
613               xfree (ci);
614             }
615           cert_cache[i] = NULL;
616         }
617     }
618
619   total_config_certificates = 0;
620   total_extra_certificates = 0;
621   total_trusted_certificates = 0;
622   total_system_trusted_certificates = 0;
623   initialization_done = 0;
624   release_cache_lock ();
625 }
626
627 /* Print some statistics to the log file.  */
628 void
629 cert_cache_print_stats (void)
630 {
631   log_info (_("permanently loaded certificates: %u\n"),
632             total_config_certificates);
633   log_info (_("    runtime cached certificates: %u\n"),
634             total_extra_certificates);
635   log_info (_("           trusted certificates: %u (%u)\n"),
636             total_trusted_certificates, total_system_trusted_certificates);
637 }
638
639
640 /* Put CERT into the certificate cache.  */
641 gpg_error_t
642 cache_cert (ksba_cert_t cert)
643 {
644   gpg_error_t err;
645
646   acquire_cache_write_lock ();
647   err = put_cert (cert, 0, 0, NULL);
648   release_cache_lock ();
649   if (gpg_err_code (err) == GPG_ERR_DUP_VALUE)
650     log_info (_("certificate already cached\n"));
651   else if (!err)
652     log_info (_("certificate cached\n"));
653   else
654     log_error (_("error caching certificate: %s\n"), gpg_strerror (err));
655   return err;
656 }
657
658
659 /* Put CERT into the certificate cache and store the fingerprint of
660    the certificate into FPR_BUFFER.  If the certificate is already in
661    the cache do not print a warning; just store the
662    fingerprint. FPR_BUFFER needs to be at least 20 bytes. */
663 gpg_error_t
664 cache_cert_silent (ksba_cert_t cert, void *fpr_buffer)
665 {
666   gpg_error_t err;
667
668   acquire_cache_write_lock ();
669   err = put_cert (cert, 0, 0, fpr_buffer);
670   release_cache_lock ();
671   if (gpg_err_code (err) == GPG_ERR_DUP_VALUE)
672     err = 0;
673   if (err)
674     log_error (_("error caching certificate: %s\n"), gpg_strerror (err));
675   return err;
676 }
677
678
679 \f
680 /* Return a certificate object for the given fingerprint.  FPR is
681    expected to be a 20 byte binary SHA-1 fingerprint.  If no matching
682    certificate is available in the cache NULL is returned.  The caller
683    must release a returned certificate.  Note that although we are
684    using reference counting the caller should not just compare the
685    pointers to check for identical certificates. */
686 ksba_cert_t
687 get_cert_byfpr (const unsigned char *fpr)
688 {
689   cert_item_t ci;
690
691   acquire_cache_read_lock ();
692   for (ci=cert_cache[*fpr]; ci; ci = ci->next)
693     if (ci->cert && !memcmp (ci->fpr, fpr, 20))
694       {
695         ksba_cert_ref (ci->cert);
696         release_cache_lock ();
697         return ci->cert;
698       }
699
700   release_cache_lock ();
701   return NULL;
702 }
703
704 /* Return a certificate object for the given fingerprint.  STRING is
705    expected to be a SHA-1 fingerprint in standard hex notation with or
706    without colons.  If no matching certificate is available in the
707    cache NULL is returned.  The caller must release a returned
708    certificate.  Note that although we are using reference counting
709    the caller should not just compare the pointers to check for
710    identical certificates. */
711 ksba_cert_t
712 get_cert_byhexfpr (const char *string)
713 {
714   unsigned char fpr[20];
715   const char *s;
716   int i;
717
718   if (strchr (string, ':'))
719     {
720       for (s=string,i=0; i < 20 && hexdigitp (s) && hexdigitp(s+1);)
721         {
722           if (s[2] && s[2] != ':')
723             break; /* Invalid string. */
724           fpr[i++] = xtoi_2 (s);
725           s += 2;
726           if (i!= 20 && *s == ':')
727             s++;
728         }
729     }
730   else
731     {
732       for (s=string,i=0; i < 20 && hexdigitp (s) && hexdigitp(s+1); s+=2 )
733         fpr[i++] = xtoi_2 (s);
734     }
735   if (i!=20 || *s)
736     {
737       log_error (_("invalid SHA1 fingerprint string '%s'\n"), string);
738       return NULL;
739     }
740
741   return get_cert_byfpr (fpr);
742 }
743
744
745
746 /* Return the certificate matching ISSUER_DN and SERIALNO.  */
747 ksba_cert_t
748 get_cert_bysn (const char *issuer_dn, ksba_sexp_t serialno)
749 {
750   /* Simple and inefficient implementation.   fixme! */
751   cert_item_t ci;
752   int i;
753
754   acquire_cache_read_lock ();
755   for (i=0; i < 256; i++)
756     {
757       for (ci=cert_cache[i]; ci; ci = ci->next)
758         if (ci->cert && !strcmp (ci->issuer_dn, issuer_dn)
759             && !compare_serialno (ci->sn, serialno))
760           {
761             ksba_cert_ref (ci->cert);
762             release_cache_lock ();
763             return ci->cert;
764           }
765     }
766
767   release_cache_lock ();
768   return NULL;
769 }
770
771
772 /* Return the certificate matching ISSUER_DN.  SEQ should initially be
773    set to 0 and bumped up to get the next issuer with that DN. */
774 ksba_cert_t
775 get_cert_byissuer (const char *issuer_dn, unsigned int seq)
776 {
777   /* Simple and very inefficient implementation and API.  fixme! */
778   cert_item_t ci;
779   int i;
780
781   acquire_cache_read_lock ();
782   for (i=0; i < 256; i++)
783     {
784       for (ci=cert_cache[i]; ci; ci = ci->next)
785         if (ci->cert && !strcmp (ci->issuer_dn, issuer_dn))
786           if (!seq--)
787             {
788               ksba_cert_ref (ci->cert);
789               release_cache_lock ();
790               return ci->cert;
791             }
792     }
793
794   release_cache_lock ();
795   return NULL;
796 }
797
798
799 /* Return the certificate matching SUBJECT_DN.  SEQ should initially be
800    set to 0 and bumped up to get the next subject with that DN. */
801 ksba_cert_t
802 get_cert_bysubject (const char *subject_dn, unsigned int seq)
803 {
804   /* Simple and very inefficient implementation and API.  fixme! */
805   cert_item_t ci;
806   int i;
807
808   if (!subject_dn)
809     return NULL;
810
811   acquire_cache_read_lock ();
812   for (i=0; i < 256; i++)
813     {
814       for (ci=cert_cache[i]; ci; ci = ci->next)
815         if (ci->cert && ci->subject_dn
816             && !strcmp (ci->subject_dn, subject_dn))
817           if (!seq--)
818             {
819               ksba_cert_ref (ci->cert);
820               release_cache_lock ();
821               return ci->cert;
822             }
823     }
824
825   release_cache_lock ();
826   return NULL;
827 }
828
829
830
831 /* Return a value describing the the class of PATTERN.  The offset of
832    the actual string to be used for the comparison is stored at
833    R_OFFSET.  The offset of the serialnumer is stored at R_SN_OFFSET. */
834 static enum pattern_class
835 classify_pattern (const char *pattern, size_t *r_offset, size_t *r_sn_offset)
836 {
837   enum pattern_class result;
838   const char *s;
839   int hexprefix = 0;
840   int hexlength;
841
842   *r_offset = *r_sn_offset = 0;
843
844   /* Skip leading spaces. */
845   for(s = pattern; *s && spacep (s); s++ )
846     ;
847
848   switch (*s)
849     {
850     case 0:  /* Empty string is an error. */
851       result = PATTERN_UNKNOWN;
852       break;
853
854     case '.': /* An email address, compare from end.  */
855       result = PATTERN_UNKNOWN;  /* Not implemented.  */
856       break;
857
858     case '<': /* An email address.  */
859       result = PATTERN_EMAIL;
860       s++;
861       break;
862
863     case '@': /* Part of an email address.  */
864       result = PATTERN_EMAIL_SUBSTR;
865       s++;
866       break;
867
868     case '=':  /* Exact compare. */
869       result = PATTERN_UNKNOWN; /* Does not make sense for X.509.  */
870       break;
871
872     case '*':  /* Case insensitive substring search.  */
873       result = PATTERN_SUBSTR;
874       s++;
875       break;
876
877     case '+':  /* Compare individual words. */
878       result = PATTERN_UNKNOWN;  /* Not implemented.  */
879       break;
880
881     case '/': /* Subject's DN. */
882       s++;
883       if (!*s || spacep (s))
884         result = PATTERN_UNKNOWN; /* No DN or prefixed with a space. */
885       else
886         result = PATTERN_SUBJECT;
887       break;
888
889     case '#': /* Serial number or issuer DN. */
890       {
891         const char *si;
892
893         s++;
894         if ( *s == '/')
895           {
896             /* An issuer's DN is indicated by "#/" */
897             s++;
898             if (!*s || spacep (s))
899               result = PATTERN_UNKNOWN; /* No DN or prefixed with a space. */
900             else
901               result = PATTERN_ISSUER;
902           }
903         else
904           { /* Serialnumber + optional issuer ID. */
905             for (si=s; *si && *si != '/'; si++)
906               if (!strchr("01234567890abcdefABCDEF", *si))
907                 break;
908             if (*si && *si != '/')
909               result = PATTERN_UNKNOWN; /* Invalid digit in serial number. */
910             else
911               {
912                 *r_sn_offset = s - pattern;
913                 if (!*si)
914                   result = PATTERN_SERIALNO;
915                 else
916                   {
917                     s = si+1;
918                     if (!*s || spacep (s))
919                       result = PATTERN_UNKNOWN; /* No DN or prefixed
920                                                    with a space. */
921                     else
922                       result = PATTERN_SERIALNO_ISSUER;
923                   }
924               }
925           }
926       }
927       break;
928
929     case ':': /* Unified fingerprint. */
930       {
931         const char *se, *si;
932         int i;
933
934         se = strchr (++s, ':');
935         if (!se)
936           result = PATTERN_UNKNOWN;
937         else
938           {
939             for (i=0, si=s; si < se; si++, i++ )
940               if (!strchr("01234567890abcdefABCDEF", *si))
941                 break;
942             if ( si < se )
943               result = PATTERN_UNKNOWN; /* Invalid digit. */
944             else if (i == 32)
945               result = PATTERN_FINGERPRINT16;
946             else if (i == 40)
947               result = PATTERN_FINGERPRINT20;
948             else
949               result = PATTERN_UNKNOWN; /* Invalid length for a fingerprint. */
950           }
951       }
952       break;
953
954     case '&': /* Keygrip. */
955       result = PATTERN_UNKNOWN;  /* Not implemented.  */
956       break;
957
958     default:
959       if (s[0] == '0' && s[1] == 'x')
960         {
961           hexprefix = 1;
962           s += 2;
963         }
964
965       hexlength = strspn(s, "0123456789abcdefABCDEF");
966
967       /* Check if a hexadecimal number is terminated by EOS or blank. */
968       if (hexlength && s[hexlength] && !spacep (s+hexlength))
969         {
970           /* If the "0x" prefix is used a correct termination is required. */
971           if (hexprefix)
972             {
973               result = PATTERN_UNKNOWN;
974               break; /* switch */
975             }
976           hexlength = 0;  /* Not a hex number.  */
977         }
978
979       if (hexlength == 8 || (!hexprefix && hexlength == 9 && *s == '0'))
980         {
981           if (hexlength == 9)
982             s++;
983           result = PATTERN_SHORT_KEYID;
984         }
985       else if (hexlength == 16 || (!hexprefix && hexlength == 17 && *s == '0'))
986         {
987           if (hexlength == 17)
988             s++;
989           result = PATTERN_LONG_KEYID;
990         }
991       else if (hexlength == 32 || (!hexprefix && hexlength == 33 && *s == '0'))
992         {
993           if (hexlength == 33)
994             s++;
995           result = PATTERN_FINGERPRINT16;
996         }
997       else if (hexlength == 40 || (!hexprefix && hexlength == 41 && *s == '0'))
998         {
999           if (hexlength == 41)
1000             s++;
1001           result = PATTERN_FINGERPRINT20;
1002         }
1003       else if (!hexprefix)
1004         {
1005           /* The fingerprints used with X.509 are often delimited by
1006              colons, so we try to single this case out. */
1007           result = PATTERN_UNKNOWN;
1008           hexlength = strspn (s, ":0123456789abcdefABCDEF");
1009           if (hexlength == 59 && (!s[hexlength] || spacep (s+hexlength)))
1010             {
1011               int i, c;
1012
1013               for (i=0; i < 20; i++, s += 3)
1014                 {
1015                   c = hextobyte(s);
1016                   if (c == -1 || (i < 19 && s[2] != ':'))
1017                     break;
1018                 }
1019               if (i == 20)
1020                 result = PATTERN_FINGERPRINT20;
1021             }
1022           if (result == PATTERN_UNKNOWN) /* Default to substring match. */
1023             {
1024               result = PATTERN_SUBSTR;
1025             }
1026         }
1027       else /* A hex number with a prefix but with a wrong length.  */
1028         result = PATTERN_UNKNOWN;
1029     }
1030
1031   if (result != PATTERN_UNKNOWN)
1032     *r_offset = s - pattern;
1033   return result;
1034 }
1035
1036
1037
1038 /* Given PATTERN, which is a string as used by GnuPG to specify a
1039    certificate, return all matching certificates by calling the
1040    supplied function RETFNC.  */
1041 gpg_error_t
1042 get_certs_bypattern (const char *pattern,
1043                      gpg_error_t (*retfnc)(void*,ksba_cert_t),
1044                      void *retfnc_data)
1045 {
1046   gpg_error_t err = GPG_ERR_BUG;
1047   enum pattern_class class;
1048   size_t offset, sn_offset;
1049   const char *hexserialno;
1050   ksba_sexp_t serialno = NULL;
1051   ksba_cert_t cert = NULL;
1052   unsigned int seq;
1053
1054   if (!pattern || !retfnc)
1055     return gpg_error (GPG_ERR_INV_ARG);
1056
1057   class = classify_pattern (pattern, &offset, &sn_offset);
1058   hexserialno = pattern + sn_offset;
1059   pattern += offset;
1060   switch (class)
1061     {
1062     case PATTERN_UNKNOWN:
1063       err = gpg_error (GPG_ERR_INV_NAME);
1064       break;
1065
1066     case PATTERN_FINGERPRINT20:
1067       cert = get_cert_byhexfpr (pattern);
1068       err = cert? 0 : gpg_error (GPG_ERR_NOT_FOUND);
1069       break;
1070
1071     case PATTERN_SERIALNO_ISSUER:
1072       serialno = hexsn_to_sexp (hexserialno);
1073       if (!serialno)
1074         err = gpg_error_from_syserror ();
1075       else
1076         {
1077           cert = get_cert_bysn (pattern, serialno);
1078           err = cert? 0 : gpg_error (GPG_ERR_NOT_FOUND);
1079         }
1080       break;
1081
1082     case PATTERN_ISSUER:
1083       for (seq=0,err=0; !err && (cert = get_cert_byissuer (pattern, seq)); seq++)
1084         {
1085           err = retfnc (retfnc_data, cert);
1086           ksba_cert_release (cert);
1087           cert = NULL;
1088         }
1089       if (!err && !seq)
1090         err = gpg_error (GPG_ERR_NOT_FOUND);
1091       break;
1092
1093     case PATTERN_SUBJECT:
1094       for (seq=0,err=0; !err && (cert = get_cert_bysubject (pattern, seq));seq++)
1095         {
1096           err = retfnc (retfnc_data, cert);
1097           ksba_cert_release (cert);
1098           cert = NULL;
1099         }
1100       if (!err && !seq)
1101         err = gpg_error (GPG_ERR_NOT_FOUND);
1102       break;
1103
1104     case PATTERN_EMAIL:
1105     case PATTERN_EMAIL_SUBSTR:
1106     case PATTERN_FINGERPRINT16:
1107     case PATTERN_SHORT_KEYID:
1108     case PATTERN_LONG_KEYID:
1109     case PATTERN_SUBSTR:
1110     case PATTERN_SERIALNO:
1111       /* Not supported.  */
1112       err = gpg_error (GPG_ERR_INV_NAME);
1113     }
1114
1115
1116   if (!err && cert)
1117     err = retfnc (retfnc_data, cert);
1118   ksba_cert_release (cert);
1119   xfree (serialno);
1120   return err;
1121 }
1122
1123
1124
1125
1126 \f
1127 /* Return the certificate matching ISSUER_DN and SERIALNO; if it is
1128  * not already in the cache, try to find it from other resources.  */
1129 ksba_cert_t
1130 find_cert_bysn (ctrl_t ctrl, const char *issuer_dn, ksba_sexp_t serialno)
1131 {
1132   gpg_error_t err;
1133   ksba_cert_t cert;
1134   cert_fetch_context_t context = NULL;
1135   char *hexsn, *buf;
1136
1137   /* First check whether it has already been cached.  */
1138   cert = get_cert_bysn (issuer_dn, serialno);
1139   if (cert)
1140     return cert;
1141
1142   /* Ask back to the service requester to return the certificate.
1143    * This is because we can assume that he already used the
1144    * certificate while checking for the CRL.  */
1145   hexsn = serial_hex (serialno);
1146   if (!hexsn)
1147     {
1148       log_error ("serial_hex() failed\n");
1149       return NULL;
1150     }
1151   buf = strconcat ("#", hexsn, "/", issuer_dn, NULL);
1152   if (!buf)
1153     {
1154       log_error ("can't allocate enough memory: %s\n", strerror (errno));
1155       xfree (hexsn);
1156       return NULL;
1157     }
1158   xfree (hexsn);
1159
1160   cert = get_cert_local (ctrl, buf);
1161   xfree (buf);
1162   if (cert)
1163     {
1164       cache_cert (cert);
1165       return cert; /* Done. */
1166     }
1167
1168   if (DBG_LOOKUP)
1169     log_debug ("find_cert_bysn: certificate not returned by caller"
1170                " - doing lookup\n");
1171
1172   /* Retrieve the certificate from external resources. */
1173   while (!cert)
1174     {
1175       ksba_sexp_t sn;
1176       char *issdn;
1177
1178       if (!context)
1179         {
1180           err = ca_cert_fetch (ctrl, &context, issuer_dn);
1181           if (err)
1182             {
1183               log_error (_("error fetching certificate by S/N: %s\n"),
1184                          gpg_strerror (err));
1185               break;
1186             }
1187         }
1188
1189       err = fetch_next_ksba_cert (context, &cert);
1190       if (err)
1191         {
1192           log_error (_("error fetching certificate by S/N: %s\n"),
1193                      gpg_strerror (err) );
1194           break;
1195         }
1196
1197       issdn = ksba_cert_get_issuer (cert, 0);
1198       if (strcmp (issuer_dn, issdn))
1199         {
1200           log_debug ("find_cert_bysn: Ooops: issuer DN does not match\n");
1201           ksba_cert_release (cert);
1202           cert = NULL;
1203           ksba_free (issdn);
1204           break;
1205         }
1206
1207       sn = ksba_cert_get_serial (cert);
1208
1209       if (DBG_LOOKUP)
1210         {
1211           log_debug ("   considering certificate (#");
1212           dump_serial (sn);
1213           log_printf ("/");
1214           dump_string (issdn);
1215           log_printf (")\n");
1216         }
1217
1218       if (!compare_serialno (serialno, sn))
1219         {
1220           ksba_free (sn);
1221           ksba_free (issdn);
1222           cache_cert (cert);
1223           if (DBG_LOOKUP)
1224             log_debug ("   found\n");
1225           break; /* Ready.  */
1226         }
1227
1228       ksba_free (sn);
1229       ksba_free (issdn);
1230       ksba_cert_release (cert);
1231       cert = NULL;
1232     }
1233
1234   end_cert_fetch (context);
1235   return cert;
1236 }
1237
1238
1239 /* Return the certificate matching SUBJECT_DN and (if not NULL)
1240  * KEYID. If it is not already in the cache, try to find it from other
1241  * resources.  Note, that the external search does not work for user
1242  * certificates because the LDAP lookup is on the caCertificate
1243  * attribute. For our purposes this is just fine.  */
1244 ksba_cert_t
1245 find_cert_bysubject (ctrl_t ctrl, const char *subject_dn, ksba_sexp_t keyid)
1246 {
1247   gpg_error_t err;
1248   int seq;
1249   ksba_cert_t cert = NULL;
1250   cert_fetch_context_t context = NULL;
1251   ksba_sexp_t subj;
1252
1253   /* If we have certificates from an OCSP request we first try to use
1254    * them.  This is because these certificates will really be the
1255    * required ones and thus even in the case that they can't be
1256    * uniquely located by the following code we can use them.  This is
1257    * for example required by Telesec certificates where a keyId is
1258    * used but the issuer certificate comes without a subject keyId! */
1259   if (ctrl->ocsp_certs && subject_dn)
1260     {
1261       cert_item_t ci;
1262       cert_ref_t cr;
1263       int i;
1264
1265       /* For efficiency reasons we won't use get_cert_bysubject here. */
1266       acquire_cache_read_lock ();
1267       for (i=0; i < 256; i++)
1268         for (ci=cert_cache[i]; ci; ci = ci->next)
1269           if (ci->cert && ci->subject_dn
1270               && !strcmp (ci->subject_dn, subject_dn))
1271             for (cr=ctrl->ocsp_certs; cr; cr = cr->next)
1272               if (!memcmp (ci->fpr, cr->fpr, 20))
1273                 {
1274                   ksba_cert_ref (ci->cert);
1275                   release_cache_lock ();
1276                   return ci->cert; /* We use this certificate. */
1277                 }
1278       release_cache_lock ();
1279       if (DBG_LOOKUP)
1280         log_debug ("find_cert_bysubject: certificate not in ocsp_certs\n");
1281     }
1282
1283   /* No check whether the certificate is cached.  */
1284   for (seq=0; (cert = get_cert_bysubject (subject_dn, seq)); seq++)
1285     {
1286       if (!keyid)
1287         break; /* No keyid requested, so return the first one found. */
1288       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj)
1289           && !cmp_simple_canon_sexp (keyid, subj))
1290         {
1291           xfree (subj);
1292           break; /* Found matching cert. */
1293         }
1294       xfree (subj);
1295       ksba_cert_release (cert);
1296     }
1297   if (cert)
1298     return cert; /* Done.  */
1299
1300   if (DBG_LOOKUP)
1301     log_debug ("find_cert_bysubject: certificate not in cache\n");
1302
1303   /* Ask back to the service requester to return the certificate.
1304    * This is because we can assume that he already used the
1305    * certificate while checking for the CRL. */
1306   if (keyid)
1307     cert = get_cert_local_ski (ctrl, subject_dn, keyid);
1308   else
1309     {
1310       /* In contrast to get_cert_local_ski, get_cert_local uses any
1311        * passed pattern, so we need to make sure that an exact subject
1312        * search is done.  */
1313       char *buf;
1314
1315       buf = strconcat ("/", subject_dn, NULL);
1316       if (!buf)
1317         {
1318           log_error ("can't allocate enough memory: %s\n", strerror (errno));
1319           return NULL;
1320         }
1321       cert = get_cert_local (ctrl, buf);
1322       xfree (buf);
1323     }
1324   if (cert)
1325     {
1326       cache_cert (cert);
1327       return cert; /* Done. */
1328     }
1329
1330   if (DBG_LOOKUP)
1331     log_debug ("find_cert_bysubject: certificate not returned by caller"
1332                " - doing lookup\n");
1333
1334   /* Locate the certificate using external resources. */
1335   while (!cert)
1336     {
1337       char *subjdn;
1338
1339       if (!context)
1340         {
1341           err = ca_cert_fetch (ctrl, &context, subject_dn);
1342           if (err)
1343             {
1344               log_error (_("error fetching certificate by subject: %s\n"),
1345                          gpg_strerror (err));
1346               break;
1347             }
1348         }
1349
1350       err = fetch_next_ksba_cert (context, &cert);
1351       if (err)
1352         {
1353           log_error (_("error fetching certificate by subject: %s\n"),
1354                      gpg_strerror (err) );
1355           break;
1356         }
1357
1358       subjdn = ksba_cert_get_subject (cert, 0);
1359       if (strcmp (subject_dn, subjdn))
1360         {
1361           log_info ("find_cert_bysubject: subject DN does not match\n");
1362           ksba_cert_release (cert);
1363           cert = NULL;
1364           ksba_free (subjdn);
1365           continue;
1366         }
1367
1368
1369       if (DBG_LOOKUP)
1370         {
1371           log_debug ("   considering certificate (/");
1372           dump_string (subjdn);
1373           log_printf (")\n");
1374         }
1375       ksba_free (subjdn);
1376
1377       /* If no key ID has been provided, we return the first match.  */
1378       if (!keyid)
1379         {
1380           cache_cert (cert);
1381           if (DBG_LOOKUP)
1382             log_debug ("   found\n");
1383           break; /* Ready.  */
1384         }
1385
1386       /* With the key ID given we need to compare it.  */
1387       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj))
1388         {
1389           if (!cmp_simple_canon_sexp (keyid, subj))
1390             {
1391               ksba_free (subj);
1392               cache_cert (cert);
1393               if (DBG_LOOKUP)
1394                 log_debug ("   found\n");
1395               break; /* Ready.  */
1396             }
1397         }
1398
1399       ksba_free (subj);
1400       ksba_cert_release (cert);
1401       cert = NULL;
1402     }
1403
1404   end_cert_fetch (context);
1405   return cert;
1406 }
1407
1408
1409 /* Return 0 if the certificate is a trusted certificate.  Returns
1410  * GPG_ERR_NOT_TRUSTED if it is not trusted or other error codes in
1411  * case of systems errors.  If WITH_SYSTRUST is set also system
1412  * provided certificates are considered trusted.  */
1413 gpg_error_t
1414 is_trusted_cert (ksba_cert_t cert, int with_systrust)
1415 {
1416   unsigned char fpr[20];
1417   cert_item_t ci;
1418
1419   cert_compute_fpr (cert, fpr);
1420
1421   acquire_cache_read_lock ();
1422   for (ci=cert_cache[*fpr]; ci; ci = ci->next)
1423     if (ci->cert && !memcmp (ci->fpr, fpr, 20))
1424       {
1425         if (ci->flags.trusted && (with_systrust || !ci->flags.systrust))
1426           {
1427             release_cache_lock ();
1428             return 0; /* Yes, it is trusted. */
1429           }
1430         break;
1431       }
1432
1433   release_cache_lock ();
1434   return gpg_error (GPG_ERR_NOT_TRUSTED);
1435 }
1436
1437
1438 \f
1439 /* Given the certificate CERT locate the issuer for this certificate
1440  * and return it at R_CERT.  Returns 0 on success or
1441  * GPG_ERR_NOT_FOUND.  */
1442 gpg_error_t
1443 find_issuing_cert (ctrl_t ctrl, ksba_cert_t cert, ksba_cert_t *r_cert)
1444 {
1445   gpg_error_t err;
1446   char *issuer_dn;
1447   ksba_cert_t issuer_cert = NULL;
1448   ksba_name_t authid;
1449   ksba_sexp_t authidno;
1450   ksba_sexp_t keyid;
1451
1452   *r_cert = NULL;
1453
1454   issuer_dn = ksba_cert_get_issuer (cert, 0);
1455   if (!issuer_dn)
1456     {
1457       log_error (_("no issuer found in certificate\n"));
1458       err = gpg_error (GPG_ERR_BAD_CERT);
1459       goto leave;
1460     }
1461
1462   /* First we need to check whether we can return that certificate
1463      using the authorithyKeyIdentifier.  */
1464   err = ksba_cert_get_auth_key_id (cert, &keyid, &authid, &authidno);
1465   if (err)
1466     {
1467       log_info (_("error getting authorityKeyIdentifier: %s\n"),
1468                 gpg_strerror (err));
1469     }
1470   else
1471     {
1472       const char *s = ksba_name_enum (authid, 0);
1473       if (s && *authidno)
1474         {
1475           issuer_cert = find_cert_bysn (ctrl, s, authidno);
1476         }
1477
1478       if (!issuer_cert && keyid)
1479         {
1480           /* Not found by issuer+s/n.  Now that we have an AKI
1481            * keyIdentifier look for a certificate with a matching
1482            * SKI. */
1483           issuer_cert = find_cert_bysubject (ctrl, issuer_dn, keyid);
1484         }
1485
1486       /* Print a note so that the user does not feel too helpless when
1487        * an issuer certificate was found and gpgsm prints BAD
1488        * signature because it is not the correct one.  */
1489       if (!issuer_cert)
1490         {
1491           log_info ("issuer certificate ");
1492           if (keyid)
1493             {
1494               log_printf ("{");
1495               dump_serial (keyid);
1496               log_printf ("} ");
1497             }
1498           if (authidno)
1499             {
1500               log_printf ("(#");
1501               dump_serial (authidno);
1502               log_printf ("/");
1503               dump_string (s);
1504               log_printf (") ");
1505             }
1506           log_printf ("not found using authorityKeyIdentifier\n");
1507         }
1508       ksba_name_release (authid);
1509       xfree (authidno);
1510       xfree (keyid);
1511     }
1512
1513   /* If this did not work, try just with the issuer's name and assume
1514    * that there is only one such certificate.  We only look into our
1515    * cache then.  */
1516   if (err || !issuer_cert)
1517     {
1518       issuer_cert = get_cert_bysubject (issuer_dn, 0);
1519       if (issuer_cert)
1520         err = 0;
1521     }
1522
1523  leave:
1524   if (!err && !issuer_cert)
1525     err = gpg_error (GPG_ERR_NOT_FOUND);
1526
1527   xfree (issuer_dn);
1528
1529   if (err)
1530     ksba_cert_release (issuer_cert);
1531   else
1532     *r_cert = issuer_cert;
1533
1534   return err;
1535 }