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