gpg: Remove PGP6 compliance mode.
[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                   return ci->cert; /* We use this certificate. */
1475                 }
1476       release_cache_lock ();
1477       if (DBG_LOOKUP)
1478         log_debug ("find_cert_bysubject: certificate not in ocsp_certs\n");
1479     }
1480
1481   /* No check whether the certificate is cached.  */
1482   for (seq=0; (cert = get_cert_bysubject (subject_dn, seq)); seq++)
1483     {
1484       if (!keyid)
1485         break; /* No keyid requested, so return the first one found. */
1486       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj)
1487           && !cmp_simple_canon_sexp (keyid, subj))
1488         {
1489           xfree (subj);
1490           break; /* Found matching cert. */
1491         }
1492       xfree (subj);
1493       ksba_cert_release (cert);
1494     }
1495   if (cert)
1496     return cert; /* Done.  */
1497
1498   if (DBG_LOOKUP)
1499     log_debug ("find_cert_bysubject: certificate not in cache\n");
1500
1501   /* Ask back to the service requester to return the certificate.
1502    * This is because we can assume that he already used the
1503    * certificate while checking for the CRL. */
1504   if (keyid)
1505     cert = get_cert_local_ski (ctrl, subject_dn, keyid);
1506   else
1507     {
1508       /* In contrast to get_cert_local_ski, get_cert_local uses any
1509        * passed pattern, so we need to make sure that an exact subject
1510        * search is done.  */
1511       char *buf;
1512
1513       buf = strconcat ("/", subject_dn, NULL);
1514       if (!buf)
1515         {
1516           log_error ("can't allocate enough memory: %s\n", strerror (errno));
1517           return NULL;
1518         }
1519       cert = get_cert_local (ctrl, buf);
1520       xfree (buf);
1521     }
1522   if (cert)
1523     {
1524       cache_cert (cert);
1525       return cert; /* Done. */
1526     }
1527
1528   if (DBG_LOOKUP)
1529     log_debug ("find_cert_bysubject: certificate not returned by caller"
1530                " - doing lookup\n");
1531
1532   /* Locate the certificate using external resources. */
1533   while (!cert)
1534     {
1535       char *subjdn;
1536
1537       if (!context)
1538         {
1539           err = ca_cert_fetch (ctrl, &context, subject_dn);
1540           if (err)
1541             {
1542               log_error (_("error fetching certificate by subject: %s\n"),
1543                          gpg_strerror (err));
1544               break;
1545             }
1546         }
1547
1548       err = fetch_next_ksba_cert (context, &cert);
1549       if (err)
1550         {
1551           log_error (_("error fetching certificate by subject: %s\n"),
1552                      gpg_strerror (err) );
1553           break;
1554         }
1555
1556       subjdn = ksba_cert_get_subject (cert, 0);
1557       if (strcmp (subject_dn, subjdn))
1558         {
1559           log_info ("find_cert_bysubject: subject DN does not match\n");
1560           ksba_cert_release (cert);
1561           cert = NULL;
1562           ksba_free (subjdn);
1563           continue;
1564         }
1565
1566
1567       if (DBG_LOOKUP)
1568         {
1569           log_debug ("   considering certificate (/");
1570           dump_string (subjdn);
1571           log_printf (")\n");
1572         }
1573       ksba_free (subjdn);
1574
1575       /* If no key ID has been provided, we return the first match.  */
1576       if (!keyid)
1577         {
1578           cache_cert (cert);
1579           if (DBG_LOOKUP)
1580             log_debug ("   found\n");
1581           break; /* Ready.  */
1582         }
1583
1584       /* With the key ID given we need to compare it.  */
1585       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj))
1586         {
1587           if (!cmp_simple_canon_sexp (keyid, subj))
1588             {
1589               ksba_free (subj);
1590               cache_cert (cert);
1591               if (DBG_LOOKUP)
1592                 log_debug ("   found\n");
1593               break; /* Ready.  */
1594             }
1595         }
1596
1597       ksba_free (subj);
1598       ksba_cert_release (cert);
1599       cert = NULL;
1600     }
1601
1602   end_cert_fetch (context);
1603   return cert;
1604 }
1605
1606
1607 /* Return 0 if the certificate is a trusted certificate. Returns
1608  * GPG_ERR_NOT_TRUSTED if it is not trusted or other error codes in
1609  * case of systems errors.  TRUSTCLASSES are the bitwise ORed
1610  * CERTTRUST_CLASS values to use for the check.  */
1611 gpg_error_t
1612 is_trusted_cert (ksba_cert_t cert, unsigned int trustclasses)
1613 {
1614   unsigned char fpr[20];
1615   cert_item_t ci;
1616
1617   cert_compute_fpr (cert, fpr);
1618
1619   acquire_cache_read_lock ();
1620   for (ci=cert_cache[*fpr]; ci; ci = ci->next)
1621     if (ci->cert && !memcmp (ci->fpr, fpr, 20))
1622       {
1623         if ((ci->trustclasses & trustclasses))
1624           {
1625             /* The certificate is trusted in one of the given
1626              * TRUSTCLASSES.  */
1627             release_cache_lock ();
1628             return 0; /* Yes, it is trusted. */
1629           }
1630         break;
1631       }
1632
1633   release_cache_lock ();
1634   return gpg_error (GPG_ERR_NOT_TRUSTED);
1635 }
1636
1637
1638 \f
1639 /* Given the certificate CERT locate the issuer for this certificate
1640  * and return it at R_CERT.  Returns 0 on success or
1641  * GPG_ERR_NOT_FOUND.  */
1642 gpg_error_t
1643 find_issuing_cert (ctrl_t ctrl, ksba_cert_t cert, ksba_cert_t *r_cert)
1644 {
1645   gpg_error_t err;
1646   char *issuer_dn;
1647   ksba_cert_t issuer_cert = NULL;
1648   ksba_name_t authid;
1649   ksba_sexp_t authidno;
1650   ksba_sexp_t keyid;
1651
1652   *r_cert = NULL;
1653
1654   issuer_dn = ksba_cert_get_issuer (cert, 0);
1655   if (!issuer_dn)
1656     {
1657       log_error (_("no issuer found in certificate\n"));
1658       err = gpg_error (GPG_ERR_BAD_CERT);
1659       goto leave;
1660     }
1661
1662   /* First we need to check whether we can return that certificate
1663      using the authorithyKeyIdentifier.  */
1664   err = ksba_cert_get_auth_key_id (cert, &keyid, &authid, &authidno);
1665   if (err)
1666     {
1667       log_info (_("error getting authorityKeyIdentifier: %s\n"),
1668                 gpg_strerror (err));
1669     }
1670   else
1671     {
1672       const char *s = ksba_name_enum (authid, 0);
1673       if (s && *authidno)
1674         {
1675           issuer_cert = find_cert_bysn (ctrl, s, authidno);
1676         }
1677
1678       if (!issuer_cert && keyid)
1679         {
1680           /* Not found by issuer+s/n.  Now that we have an AKI
1681            * keyIdentifier look for a certificate with a matching
1682            * SKI. */
1683           issuer_cert = find_cert_bysubject (ctrl, issuer_dn, keyid);
1684         }
1685
1686       /* Print a note so that the user does not feel too helpless when
1687        * an issuer certificate was found and gpgsm prints BAD
1688        * signature because it is not the correct one.  */
1689       if (!issuer_cert)
1690         {
1691           log_info ("issuer certificate ");
1692           if (keyid)
1693             {
1694               log_printf ("{");
1695               dump_serial (keyid);
1696               log_printf ("} ");
1697             }
1698           if (authidno)
1699             {
1700               log_printf ("(#");
1701               dump_serial (authidno);
1702               log_printf ("/");
1703               dump_string (s);
1704               log_printf (") ");
1705             }
1706           log_printf ("not found using authorityKeyIdentifier\n");
1707         }
1708       ksba_name_release (authid);
1709       xfree (authidno);
1710       xfree (keyid);
1711     }
1712
1713   /* If this did not work, try just with the issuer's name and assume
1714    * that there is only one such certificate.  We only look into our
1715    * cache then.  */
1716   if (err || !issuer_cert)
1717     {
1718       issuer_cert = get_cert_bysubject (issuer_dn, 0);
1719       if (issuer_cert)
1720         err = 0;
1721     }
1722
1723  leave:
1724   if (!err && !issuer_cert)
1725     err = gpg_error (GPG_ERR_NOT_FOUND);
1726
1727   xfree (issuer_dn);
1728
1729   if (err)
1730     ksba_cert_release (issuer_cert);
1731   else
1732     *r_cert = issuer_cert;
1733
1734   return err;
1735 }
1736
1737
1738 \f
1739 /* Read a list of certificates in PEM format from stream FP and store
1740  * them on success at R_CERTLIST.  On error NULL is stored at R_CERT
1741  * list and an error code returned.  Note that even on success an
1742  * empty list of certificates can be returned (i.e. NULL stored at
1743  * R_CERTLIST) iff the input stream has no certificates.  */
1744 gpg_error_t
1745 read_certlist_from_stream (certlist_t *r_certlist, estream_t fp)
1746 {
1747   gpg_error_t err;
1748   gnupg_ksba_io_t ioctx = NULL;
1749   ksba_reader_t reader;
1750   ksba_cert_t cert = NULL;
1751   certlist_t certlist = NULL;
1752   certlist_t cl, *cltail;
1753
1754   *r_certlist = NULL;
1755
1756   err = gnupg_ksba_create_reader (&ioctx,
1757                                   (GNUPG_KSBA_IO_PEM | GNUPG_KSBA_IO_MULTIPEM),
1758                                   fp, &reader);
1759   if (err)
1760     goto leave;
1761
1762   /* Loop to read all certificates from the stream.  */
1763   cltail = &certlist;
1764   do
1765     {
1766       ksba_cert_release (cert);
1767       cert = NULL;
1768       err = ksba_cert_new (&cert);
1769       if (!err)
1770         err = ksba_cert_read_der (cert, reader);
1771       if (err)
1772         {
1773           if (gpg_err_code (err) == GPG_ERR_EOF)
1774             err = 0;
1775           goto leave;
1776         }
1777
1778       /* Append the certificate to the list.  We also store the
1779        * fingerprint and check whether we have a cached certificate;
1780        * in that case the cached certificate is put into the list to
1781        * take advantage of a validation result which might be stored
1782        * in the cached certificate.  */
1783       cl = xtrycalloc (1, sizeof *cl);
1784       if (!cl)
1785         {
1786           err = gpg_error_from_syserror ();
1787           goto leave;
1788         }
1789       cert_compute_fpr (cert, cl->fpr);
1790       cl->cert = get_cert_byfpr (cl->fpr);
1791       if (!cl->cert)
1792         {
1793           cl->cert = cert;
1794           cert = NULL;
1795         }
1796       *cltail = cl;
1797       cltail = &cl->next;
1798       ksba_reader_clear (reader, NULL, NULL);
1799     }
1800   while (!gnupg_ksba_reader_eof_seen (ioctx));
1801
1802  leave:
1803   ksba_cert_release (cert);
1804   gnupg_ksba_destroy_reader (ioctx);
1805   if (err)
1806     release_certlist (certlist);
1807   else
1808     *r_certlist = certlist;
1809
1810   return err;
1811 }
1812
1813
1814 /* Release the certificate list CL.  */
1815 void
1816 release_certlist (certlist_t cl)
1817 {
1818   while (cl)
1819     {
1820       certlist_t next = cl->next;
1821       ksba_cert_release (cl->cert);
1822       cl = next;
1823     }
1824 }