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