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