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