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