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