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