dirmngr: Prepare certcache for forthcoming changes.
[gnupg.git] / dirmngr / certcache.c
1 /* certcache.c - Certificate caching
2  *      Copyright (C) 2004, 2005, 2007, 2008 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 "crlfetch.h"
33 #include "certcache.h"
34
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) and extra certifcates cached during operation.  */
97 static unsigned int total_config_certificates;
98 static unsigned int total_extra_certificates;
99
100
101 \f
102 /* Helper to do the cache locking.  */
103 static void
104 init_cache_lock (void)
105 {
106   int err;
107
108   err = npth_rwlock_init (&cert_cache_lock, NULL);
109   if (err)
110     log_fatal (_("can't initialize certificate cache lock: %s\n"),
111                strerror (err));
112 }
113
114 static void
115 acquire_cache_read_lock (void)
116 {
117   int err;
118
119   err = npth_rwlock_rdlock (&cert_cache_lock);
120   if (err)
121     log_fatal (_("can't acquire read lock on the certificate cache: %s\n"),
122                strerror (err));
123 }
124
125 static void
126 acquire_cache_write_lock (void)
127 {
128   int err;
129
130   err = npth_rwlock_wrlock (&cert_cache_lock);
131   if (err)
132     log_fatal (_("can't acquire write lock on the certificate cache: %s\n"),
133                strerror (err));
134 }
135
136 static void
137 release_cache_lock (void)
138 {
139   int err;
140
141   err = npth_rwlock_unlock (&cert_cache_lock);
142   if (err)
143     log_fatal (_("can't release lock on the certificate cache: %s\n"),
144                strerror (err));
145 }
146
147
148 /* Return false if both serial numbers match.  Can't be used for
149    sorting. */
150 static int
151 compare_serialno (ksba_sexp_t serial1, ksba_sexp_t serial2 )
152 {
153   unsigned char *a = serial1;
154   unsigned char *b = serial2;
155   return cmp_simple_canon_sexp (a, b);
156 }
157
158
159
160 /* Return a malloced canonical S-Expression with the serial number
161  * converted from the hex string HEXSN.  Return NULL on memory
162  * error.  */
163 ksba_sexp_t
164 hexsn_to_sexp (const char *hexsn)
165 {
166   char *buffer, *p;
167   size_t len;
168   char numbuf[40];
169
170   len = unhexify (NULL, hexsn);
171   snprintf (numbuf, sizeof numbuf, "(%u:", (unsigned int)len);
172   buffer = xtrymalloc (strlen (numbuf) + len + 2 );
173   if (!buffer)
174     return NULL;
175   p = stpcpy (buffer, numbuf);
176   len = unhexify (p, hexsn);
177   p[len] = ')';
178   p[len+1] = 0;
179
180   return buffer;
181 }
182
183
184 /* Compute the fingerprint of the certificate CERT and put it into
185    the 20 bytes large buffer DIGEST.  Return address of this buffer.  */
186 unsigned char *
187 cert_compute_fpr (ksba_cert_t cert, unsigned char *digest)
188 {
189   gpg_error_t err;
190   gcry_md_hd_t md;
191
192   err = gcry_md_open (&md, GCRY_MD_SHA1, 0);
193   if (err)
194     log_fatal ("gcry_md_open failed: %s\n", gpg_strerror (err));
195
196   err = ksba_cert_hash (cert, 0, HASH_FNC, md);
197   if (err)
198     {
199       log_error ("oops: ksba_cert_hash failed: %s\n", gpg_strerror (err));
200       memset (digest, 0xff, 20); /* Use a dummy value. */
201     }
202   else
203     {
204       gcry_md_final (md);
205       memcpy (digest, gcry_md_read (md, GCRY_MD_SHA1), 20);
206     }
207   gcry_md_close (md);
208   return digest;
209 }
210
211
212 /* Cleanup one slot.  This releases all resourses but keeps the actual
213    slot in the cache marked for reuse. */
214 static void
215 clean_cache_slot (cert_item_t ci)
216 {
217   ksba_cert_t cert;
218
219   if (!ci->cert)
220     return; /* Already cleaned.  */
221
222   ksba_free (ci->sn);
223   ci->sn = NULL;
224   ksba_free (ci->issuer_dn);
225   ci->issuer_dn = NULL;
226   ksba_free (ci->subject_dn);
227   ci->subject_dn = NULL;
228   cert = ci->cert;
229   ci->cert = NULL;
230
231   ksba_cert_release (cert);
232 }
233
234
235 /* Put the certificate CERT into the cache.  It is assumed that the
236  * cache is locked while this function is called.
237  *
238  * FROM_CONFIG indicates that CERT is a permanent certificate and
239  * should stay in the cache.  IS_TRUSTED requests that the trusted
240  * flag is set for the certificate; a value of 1 indicates the the
241  * cert is trusted due to GnuPG mechanisms, a value of 2 indicates
242  * that it is trusted because it has been taken from the system's
243  * store of trusted certificates.  If FPR_BUFFER is not NULL the
244  * fingerprint of the certificate will be stored there.  FPR_BUFFER
245  * needs to point to a buffer of at least 20 bytes.  The fingerprint
246  * will be stored on success or when the function returns
247  * GPG_ERR_DUP_VALUE.  */
248 static gpg_error_t
249 put_cert (ksba_cert_t cert, int from_config, int is_trusted, void *fpr_buffer)
250 {
251   unsigned char help_fpr_buffer[20], *fpr;
252   cert_item_t ci;
253
254   fpr = fpr_buffer? fpr_buffer : &help_fpr_buffer;
255
256   /* If we already reached the caching limit, drop a couple of certs
257    * from the cache.  Our dropping strategy is simple: We keep a
258    * static index counter and use this to start looking for
259    * certificates, then we drop 5 percent of the oldest certificates
260    * starting at that index.  For a large cache this is a fair way of
261    * removing items.  An LRU strategy would be better of course.
262    * Because we append new entries to the head of the list and we want
263    * to remove old ones first, we need to do this from the tail.  The
264    * implementation is not very efficient but compared to the long
265    * time it takes to retrieve a certificate from an external resource
266    * it seems to be reasonable.  */
267   if (!from_config && total_extra_certificates >= MAX_EXTRA_CACHED_CERTS)
268     {
269       static int idx;
270       cert_item_t ci_mark;
271       int i;
272       unsigned int drop_count;
273
274       drop_count = MAX_EXTRA_CACHED_CERTS / 20;
275       if (drop_count < 2)
276         drop_count = 2;
277
278       log_info (_("dropping %u certificates from the cache\n"), drop_count);
279       assert (idx < 256);
280       for (i=idx; drop_count; i = ((i+1)%256))
281         {
282           ci_mark = NULL;
283           for (ci = cert_cache[i]; ci; ci = ci->next)
284             if (ci->cert && !ci->flags.config)
285               ci_mark = ci;
286           if (ci_mark)
287             {
288               clean_cache_slot (ci_mark);
289               drop_count--;
290               total_extra_certificates--;
291             }
292         }
293       if (i==idx)
294         idx++;
295       else
296         idx = i;
297       idx %= 256;
298     }
299
300   cert_compute_fpr (cert, fpr);
301   for (ci=cert_cache[*fpr]; ci; ci = ci->next)
302     if (ci->cert && !memcmp (ci->fpr, fpr, 20))
303       return gpg_error (GPG_ERR_DUP_VALUE);
304   /* Try to reuse an existing entry.  */
305   for (ci=cert_cache[*fpr]; ci; ci = ci->next)
306     if (!ci->cert)
307       break;
308   if (!ci)
309     { /* No: Create a new entry.  */
310       ci = xtrycalloc (1, sizeof *ci);
311       if (!ci)
312         return gpg_error_from_errno (errno);
313       ci->next = cert_cache[*fpr];
314       cert_cache[*fpr] = ci;
315     }
316   else
317     memset (&ci->flags, 0, sizeof ci->flags);
318
319   ksba_cert_ref (cert);
320   ci->cert = cert;
321   memcpy (ci->fpr, fpr, 20);
322   ci->sn = ksba_cert_get_serial (cert);
323   ci->issuer_dn = ksba_cert_get_issuer (cert, 0);
324   if (!ci->issuer_dn || !ci->sn)
325     {
326       clean_cache_slot (ci);
327       return gpg_error (GPG_ERR_INV_CERT_OBJ);
328     }
329   ci->subject_dn = ksba_cert_get_subject (cert, 0);
330   ci->flags.config  = !!from_config;
331   ci->flags.trusted = !!is_trusted;
332   ci->flags.systrust = (is_trusted && is_trusted == 2);
333
334   if (from_config)
335     total_config_certificates++;
336   else
337     total_extra_certificates++;
338
339   return 0;
340 }
341
342
343 /* Load certificates from the directory DIRNAME.  All certificates
344    matching the pattern "*.crt" or "*.der"  are loaded.  We assume that
345    certificates are DER encoded and not PEM encapsulated. The cache
346    should be in a locked state when calling this function.  */
347 static gpg_error_t
348 load_certs_from_dir (const char *dirname, int are_trusted)
349 {
350   gpg_error_t err;
351   DIR *dir;
352   struct dirent *ep;
353   char *p;
354   size_t n;
355   estream_t fp;
356   ksba_reader_t reader;
357   ksba_cert_t cert;
358   char *fname = NULL;
359
360   dir = opendir (dirname);
361   if (!dir)
362     {
363       return 0; /* We do not consider this a severe error.  */
364     }
365
366   while ( (ep=readdir (dir)) )
367     {
368       p = ep->d_name;
369       if (*p == '.' || !*p)
370         continue; /* Skip any hidden files and invalid entries.  */
371       n = strlen (p);
372       if ( n < 5 || (strcmp (p+n-4,".crt") && strcmp (p+n-4,".der")))
373         continue; /* Not the desired "*.crt" or "*.der" pattern.  */
374
375       xfree (fname);
376       fname = make_filename (dirname, p, NULL);
377       fp = es_fopen (fname, "rb");
378       if (!fp)
379         {
380           log_error (_("can't open '%s': %s\n"),
381                      fname, strerror (errno));
382           continue;
383         }
384
385       err = create_estream_ksba_reader (&reader, fp);
386       if (err)
387         {
388           es_fclose (fp);
389           continue;
390         }
391
392       err = ksba_cert_new (&cert);
393       if (!err)
394         err = ksba_cert_read_der (cert, reader);
395       ksba_reader_release (reader);
396       es_fclose (fp);
397       if (err)
398         {
399           log_error (_("can't parse certificate '%s': %s\n"),
400                      fname, gpg_strerror (err));
401           ksba_cert_release (cert);
402           continue;
403         }
404
405       err = put_cert (cert, 1, !!are_trusted, NULL);
406       if (gpg_err_code (err) == GPG_ERR_DUP_VALUE)
407         log_info (_("certificate '%s' already cached\n"), fname);
408       else if (!err)
409         {
410           if (are_trusted)
411             log_info (_("trusted certificate '%s' loaded\n"), fname);
412           else
413             log_info (_("certificate '%s' loaded\n"), fname);
414           if (opt.verbose)
415             {
416               p = get_fingerprint_hexstring_colon (cert);
417               log_info (_("  SHA1 fingerprint = %s\n"), p);
418               xfree (p);
419
420               cert_log_name (_("   issuer ="), cert);
421               cert_log_subject (_("  subject ="), cert);
422             }
423         }
424       else
425         log_error (_("error loading certificate '%s': %s\n"),
426                      fname, gpg_strerror (err));
427       ksba_cert_release (cert);
428     }
429
430   xfree (fname);
431   closedir (dir);
432   return 0;
433 }
434
435
436 /* Initialize the certificate cache if not yet done.  */
437 void
438 cert_cache_init (void)
439 {
440   char *dname;
441
442   if (initialization_done)
443     return;
444   init_cache_lock ();
445   acquire_cache_write_lock ();
446
447   dname = make_filename (gnupg_sysconfdir (), "trusted-certs", NULL);
448   load_certs_from_dir (dname, 1);
449   xfree (dname);
450
451   dname = make_filename (gnupg_sysconfdir (), "extra-certs", NULL);
452   load_certs_from_dir (dname, 0);
453   xfree (dname);
454
455   initialization_done = 1;
456   release_cache_lock ();
457
458   cert_cache_print_stats ();
459 }
460
461 /* Deinitialize the certificate cache.  With FULL set to true even the
462    unused certificate slots are released. */
463 void
464 cert_cache_deinit (int full)
465 {
466   cert_item_t ci, ci2;
467   int i;
468
469   if (!initialization_done)
470     return;
471
472   acquire_cache_write_lock ();
473
474   for (i=0; i < 256; i++)
475     for (ci=cert_cache[i]; ci; ci = ci->next)
476       clean_cache_slot (ci);
477
478   if (full)
479     {
480       for (i=0; i < 256; i++)
481         {
482           for (ci=cert_cache[i]; ci; ci = ci2)
483             {
484               ci2 = ci->next;
485               xfree (ci);
486             }
487           cert_cache[i] = NULL;
488         }
489     }
490
491   total_config_certificates = 0;
492   total_extra_certificates = 0;
493   initialization_done = 0;
494   release_cache_lock ();
495 }
496
497 /* Print some statistics to the log file.  */
498 void
499 cert_cache_print_stats (void)
500 {
501   log_info (_("permanently loaded certificates: %u\n"),
502             total_config_certificates);
503   log_info (_("    runtime cached certificates: %u\n"),
504             total_extra_certificates);
505 }
506
507
508 /* Put CERT into the certificate cache.  */
509 gpg_error_t
510 cache_cert (ksba_cert_t cert)
511 {
512   gpg_error_t err;
513
514   acquire_cache_write_lock ();
515   err = put_cert (cert, 0, 0, NULL);
516   release_cache_lock ();
517   if (gpg_err_code (err) == GPG_ERR_DUP_VALUE)
518     log_info (_("certificate already cached\n"));
519   else if (!err)
520     log_info (_("certificate cached\n"));
521   else
522     log_error (_("error caching certificate: %s\n"), gpg_strerror (err));
523   return err;
524 }
525
526
527 /* Put CERT into the certificate cache and store the fingerprint of
528    the certificate into FPR_BUFFER.  If the certificate is already in
529    the cache do not print a warning; just store the
530    fingerprint. FPR_BUFFER needs to be at least 20 bytes. */
531 gpg_error_t
532 cache_cert_silent (ksba_cert_t cert, void *fpr_buffer)
533 {
534   gpg_error_t err;
535
536   acquire_cache_write_lock ();
537   err = put_cert (cert, 0, 0, fpr_buffer);
538   release_cache_lock ();
539   if (gpg_err_code (err) == GPG_ERR_DUP_VALUE)
540     err = 0;
541   if (err)
542     log_error (_("error caching certificate: %s\n"), gpg_strerror (err));
543   return err;
544 }
545
546
547 \f
548 /* Return a certificate object for the given fingerprint.  FPR is
549    expected to be a 20 byte binary SHA-1 fingerprint.  If no matching
550    certificate is available in the cache NULL is returned.  The caller
551    must release a returned certificate.  Note that although we are
552    using reference counting the caller should not just compare the
553    pointers to check for identical certificates. */
554 ksba_cert_t
555 get_cert_byfpr (const unsigned char *fpr)
556 {
557   cert_item_t ci;
558
559   acquire_cache_read_lock ();
560   for (ci=cert_cache[*fpr]; ci; ci = ci->next)
561     if (ci->cert && !memcmp (ci->fpr, fpr, 20))
562       {
563         ksba_cert_ref (ci->cert);
564         release_cache_lock ();
565         return ci->cert;
566       }
567
568   release_cache_lock ();
569   return NULL;
570 }
571
572 /* Return a certificate object for the given fingerprint.  STRING is
573    expected to be a SHA-1 fingerprint in standard hex notation with or
574    without colons.  If no matching certificate is available in the
575    cache NULL is returned.  The caller must release a returned
576    certificate.  Note that although we are using reference counting
577    the caller should not just compare the pointers to check for
578    identical certificates. */
579 ksba_cert_t
580 get_cert_byhexfpr (const char *string)
581 {
582   unsigned char fpr[20];
583   const char *s;
584   int i;
585
586   if (strchr (string, ':'))
587     {
588       for (s=string,i=0; i < 20 && hexdigitp (s) && hexdigitp(s+1);)
589         {
590           if (s[2] && s[2] != ':')
591             break; /* Invalid string. */
592           fpr[i++] = xtoi_2 (s);
593           s += 2;
594           if (i!= 20 && *s == ':')
595             s++;
596         }
597     }
598   else
599     {
600       for (s=string,i=0; i < 20 && hexdigitp (s) && hexdigitp(s+1); s+=2 )
601         fpr[i++] = xtoi_2 (s);
602     }
603   if (i!=20 || *s)
604     {
605       log_error (_("invalid SHA1 fingerprint string '%s'\n"), string);
606       return NULL;
607     }
608
609   return get_cert_byfpr (fpr);
610 }
611
612
613
614 /* Return the certificate matching ISSUER_DN and SERIALNO.  */
615 ksba_cert_t
616 get_cert_bysn (const char *issuer_dn, ksba_sexp_t serialno)
617 {
618   /* Simple and inefficient implementation.   fixme! */
619   cert_item_t ci;
620   int i;
621
622   acquire_cache_read_lock ();
623   for (i=0; i < 256; i++)
624     {
625       for (ci=cert_cache[i]; ci; ci = ci->next)
626         if (ci->cert && !strcmp (ci->issuer_dn, issuer_dn)
627             && !compare_serialno (ci->sn, serialno))
628           {
629             ksba_cert_ref (ci->cert);
630             release_cache_lock ();
631             return ci->cert;
632           }
633     }
634
635   release_cache_lock ();
636   return NULL;
637 }
638
639
640 /* Return the certificate matching ISSUER_DN.  SEQ should initially be
641    set to 0 and bumped up to get the next issuer with that DN. */
642 ksba_cert_t
643 get_cert_byissuer (const char *issuer_dn, unsigned int seq)
644 {
645   /* Simple and very inefficient implementation and API.  fixme! */
646   cert_item_t ci;
647   int i;
648
649   acquire_cache_read_lock ();
650   for (i=0; i < 256; i++)
651     {
652       for (ci=cert_cache[i]; ci; ci = ci->next)
653         if (ci->cert && !strcmp (ci->issuer_dn, issuer_dn))
654           if (!seq--)
655             {
656               ksba_cert_ref (ci->cert);
657               release_cache_lock ();
658               return ci->cert;
659             }
660     }
661
662   release_cache_lock ();
663   return NULL;
664 }
665
666
667 /* Return the certificate matching SUBJECT_DN.  SEQ should initially be
668    set to 0 and bumped up to get the next subject with that DN. */
669 ksba_cert_t
670 get_cert_bysubject (const char *subject_dn, unsigned int seq)
671 {
672   /* Simple and very inefficient implementation and API.  fixme! */
673   cert_item_t ci;
674   int i;
675
676   if (!subject_dn)
677     return NULL;
678
679   acquire_cache_read_lock ();
680   for (i=0; i < 256; i++)
681     {
682       for (ci=cert_cache[i]; ci; ci = ci->next)
683         if (ci->cert && ci->subject_dn
684             && !strcmp (ci->subject_dn, subject_dn))
685           if (!seq--)
686             {
687               ksba_cert_ref (ci->cert);
688               release_cache_lock ();
689               return ci->cert;
690             }
691     }
692
693   release_cache_lock ();
694   return NULL;
695 }
696
697
698
699 /* Return a value describing the the class of PATTERN.  The offset of
700    the actual string to be used for the comparison is stored at
701    R_OFFSET.  The offset of the serialnumer is stored at R_SN_OFFSET. */
702 static enum pattern_class
703 classify_pattern (const char *pattern, size_t *r_offset, size_t *r_sn_offset)
704 {
705   enum pattern_class result;
706   const char *s;
707   int hexprefix = 0;
708   int hexlength;
709
710   *r_offset = *r_sn_offset = 0;
711
712   /* Skip leading spaces. */
713   for(s = pattern; *s && spacep (s); s++ )
714     ;
715
716   switch (*s)
717     {
718     case 0:  /* Empty string is an error. */
719       result = PATTERN_UNKNOWN;
720       break;
721
722     case '.': /* An email address, compare from end.  */
723       result = PATTERN_UNKNOWN;  /* Not implemented.  */
724       break;
725
726     case '<': /* An email address.  */
727       result = PATTERN_EMAIL;
728       s++;
729       break;
730
731     case '@': /* Part of an email address.  */
732       result = PATTERN_EMAIL_SUBSTR;
733       s++;
734       break;
735
736     case '=':  /* Exact compare. */
737       result = PATTERN_UNKNOWN; /* Does not make sense for X.509.  */
738       break;
739
740     case '*':  /* Case insensitive substring search.  */
741       result = PATTERN_SUBSTR;
742       s++;
743       break;
744
745     case '+':  /* Compare individual words. */
746       result = PATTERN_UNKNOWN;  /* Not implemented.  */
747       break;
748
749     case '/': /* Subject's DN. */
750       s++;
751       if (!*s || spacep (s))
752         result = PATTERN_UNKNOWN; /* No DN or prefixed with a space. */
753       else
754         result = PATTERN_SUBJECT;
755       break;
756
757     case '#': /* Serial number or issuer DN. */
758       {
759         const char *si;
760
761         s++;
762         if ( *s == '/')
763           {
764             /* An issuer's DN is indicated by "#/" */
765             s++;
766             if (!*s || spacep (s))
767               result = PATTERN_UNKNOWN; /* No DN or prefixed with a space. */
768             else
769               result = PATTERN_ISSUER;
770           }
771         else
772           { /* Serialnumber + optional issuer ID. */
773             for (si=s; *si && *si != '/'; si++)
774               if (!strchr("01234567890abcdefABCDEF", *si))
775                 break;
776             if (*si && *si != '/')
777               result = PATTERN_UNKNOWN; /* Invalid digit in serial number. */
778             else
779               {
780                 *r_sn_offset = s - pattern;
781                 if (!*si)
782                   result = PATTERN_SERIALNO;
783                 else
784                   {
785                     s = si+1;
786                     if (!*s || spacep (s))
787                       result = PATTERN_UNKNOWN; /* No DN or prefixed
788                                                    with a space. */
789                     else
790                       result = PATTERN_SERIALNO_ISSUER;
791                   }
792               }
793           }
794       }
795       break;
796
797     case ':': /* Unified fingerprint. */
798       {
799         const char *se, *si;
800         int i;
801
802         se = strchr (++s, ':');
803         if (!se)
804           result = PATTERN_UNKNOWN;
805         else
806           {
807             for (i=0, si=s; si < se; si++, i++ )
808               if (!strchr("01234567890abcdefABCDEF", *si))
809                 break;
810             if ( si < se )
811               result = PATTERN_UNKNOWN; /* Invalid digit. */
812             else if (i == 32)
813               result = PATTERN_FINGERPRINT16;
814             else if (i == 40)
815               result = PATTERN_FINGERPRINT20;
816             else
817               result = PATTERN_UNKNOWN; /* Invalid length for a fingerprint. */
818           }
819       }
820       break;
821
822     case '&': /* Keygrip. */
823       result = PATTERN_UNKNOWN;  /* Not implemented.  */
824       break;
825
826     default:
827       if (s[0] == '0' && s[1] == 'x')
828         {
829           hexprefix = 1;
830           s += 2;
831         }
832
833       hexlength = strspn(s, "0123456789abcdefABCDEF");
834
835       /* Check if a hexadecimal number is terminated by EOS or blank. */
836       if (hexlength && s[hexlength] && !spacep (s+hexlength))
837         {
838           /* If the "0x" prefix is used a correct termination is required. */
839           if (hexprefix)
840             {
841               result = PATTERN_UNKNOWN;
842               break; /* switch */
843             }
844           hexlength = 0;  /* Not a hex number.  */
845         }
846
847       if (hexlength == 8 || (!hexprefix && hexlength == 9 && *s == '0'))
848         {
849           if (hexlength == 9)
850             s++;
851           result = PATTERN_SHORT_KEYID;
852         }
853       else if (hexlength == 16 || (!hexprefix && hexlength == 17 && *s == '0'))
854         {
855           if (hexlength == 17)
856             s++;
857           result = PATTERN_LONG_KEYID;
858         }
859       else if (hexlength == 32 || (!hexprefix && hexlength == 33 && *s == '0'))
860         {
861           if (hexlength == 33)
862             s++;
863           result = PATTERN_FINGERPRINT16;
864         }
865       else if (hexlength == 40 || (!hexprefix && hexlength == 41 && *s == '0'))
866         {
867           if (hexlength == 41)
868             s++;
869           result = PATTERN_FINGERPRINT20;
870         }
871       else if (!hexprefix)
872         {
873           /* The fingerprints used with X.509 are often delimited by
874              colons, so we try to single this case out. */
875           result = PATTERN_UNKNOWN;
876           hexlength = strspn (s, ":0123456789abcdefABCDEF");
877           if (hexlength == 59 && (!s[hexlength] || spacep (s+hexlength)))
878             {
879               int i, c;
880
881               for (i=0; i < 20; i++, s += 3)
882                 {
883                   c = hextobyte(s);
884                   if (c == -1 || (i < 19 && s[2] != ':'))
885                     break;
886                 }
887               if (i == 20)
888                 result = PATTERN_FINGERPRINT20;
889             }
890           if (result == PATTERN_UNKNOWN) /* Default to substring match. */
891             {
892               result = PATTERN_SUBSTR;
893             }
894         }
895       else /* A hex number with a prefix but with a wrong length.  */
896         result = PATTERN_UNKNOWN;
897     }
898
899   if (result != PATTERN_UNKNOWN)
900     *r_offset = s - pattern;
901   return result;
902 }
903
904
905
906 /* Given PATTERN, which is a string as used by GnuPG to specify a
907    certificate, return all matching certificates by calling the
908    supplied function RETFNC.  */
909 gpg_error_t
910 get_certs_bypattern (const char *pattern,
911                      gpg_error_t (*retfnc)(void*,ksba_cert_t),
912                      void *retfnc_data)
913 {
914   gpg_error_t err = GPG_ERR_BUG;
915   enum pattern_class class;
916   size_t offset, sn_offset;
917   const char *hexserialno;
918   ksba_sexp_t serialno = NULL;
919   ksba_cert_t cert = NULL;
920   unsigned int seq;
921
922   if (!pattern || !retfnc)
923     return gpg_error (GPG_ERR_INV_ARG);
924
925   class = classify_pattern (pattern, &offset, &sn_offset);
926   hexserialno = pattern + sn_offset;
927   pattern += offset;
928   switch (class)
929     {
930     case PATTERN_UNKNOWN:
931       err = gpg_error (GPG_ERR_INV_NAME);
932       break;
933
934     case PATTERN_FINGERPRINT20:
935       cert = get_cert_byhexfpr (pattern);
936       err = cert? 0 : gpg_error (GPG_ERR_NOT_FOUND);
937       break;
938
939     case PATTERN_SERIALNO_ISSUER:
940       serialno = hexsn_to_sexp (hexserialno);
941       if (!serialno)
942         err = gpg_error_from_syserror ();
943       else
944         {
945           cert = get_cert_bysn (pattern, serialno);
946           err = cert? 0 : gpg_error (GPG_ERR_NOT_FOUND);
947         }
948       break;
949
950     case PATTERN_ISSUER:
951       for (seq=0,err=0; !err && (cert = get_cert_byissuer (pattern, seq)); seq++)
952         {
953           err = retfnc (retfnc_data, cert);
954           ksba_cert_release (cert);
955           cert = NULL;
956         }
957       if (!err && !seq)
958         err = gpg_error (GPG_ERR_NOT_FOUND);
959       break;
960
961     case PATTERN_SUBJECT:
962       for (seq=0,err=0; !err && (cert = get_cert_bysubject (pattern, seq));seq++)
963         {
964           err = retfnc (retfnc_data, cert);
965           ksba_cert_release (cert);
966           cert = NULL;
967         }
968       if (!err && !seq)
969         err = gpg_error (GPG_ERR_NOT_FOUND);
970       break;
971
972     case PATTERN_EMAIL:
973     case PATTERN_EMAIL_SUBSTR:
974     case PATTERN_FINGERPRINT16:
975     case PATTERN_SHORT_KEYID:
976     case PATTERN_LONG_KEYID:
977     case PATTERN_SUBSTR:
978     case PATTERN_SERIALNO:
979       /* Not supported.  */
980       err = gpg_error (GPG_ERR_INV_NAME);
981     }
982
983
984   if (!err && cert)
985     err = retfnc (retfnc_data, cert);
986   ksba_cert_release (cert);
987   xfree (serialno);
988   return err;
989 }
990
991
992
993
994 \f
995 /* Return the certificate matching ISSUER_DN and SERIALNO; if it is
996  * not already in the cache, try to find it from other resources.  */
997 ksba_cert_t
998 find_cert_bysn (ctrl_t ctrl, const char *issuer_dn, ksba_sexp_t serialno)
999 {
1000   gpg_error_t err;
1001   ksba_cert_t cert;
1002   cert_fetch_context_t context = NULL;
1003   char *hexsn, *buf;
1004
1005   /* First check whether it has already been cached.  */
1006   cert = get_cert_bysn (issuer_dn, serialno);
1007   if (cert)
1008     return cert;
1009
1010   /* Ask back to the service requester to return the certificate.
1011    * This is because we can assume that he already used the
1012    * certificate while checking for the CRL.  */
1013   hexsn = serial_hex (serialno);
1014   if (!hexsn)
1015     {
1016       log_error ("serial_hex() failed\n");
1017       return NULL;
1018     }
1019   buf = strconcat ("#", hexsn, "/", issuer_dn, NULL);
1020   if (!buf)
1021     {
1022       log_error ("can't allocate enough memory: %s\n", strerror (errno));
1023       xfree (hexsn);
1024       return NULL;
1025     }
1026   xfree (hexsn);
1027
1028   cert = get_cert_local (ctrl, buf);
1029   xfree (buf);
1030   if (cert)
1031     {
1032       cache_cert (cert);
1033       return cert; /* Done. */
1034     }
1035
1036   if (DBG_LOOKUP)
1037     log_debug ("find_cert_bysn: certificate not returned by caller"
1038                " - doing lookup\n");
1039
1040   /* Retrieve the certificate from external resources. */
1041   while (!cert)
1042     {
1043       ksba_sexp_t sn;
1044       char *issdn;
1045
1046       if (!context)
1047         {
1048           err = ca_cert_fetch (ctrl, &context, issuer_dn);
1049           if (err)
1050             {
1051               log_error (_("error fetching certificate by S/N: %s\n"),
1052                          gpg_strerror (err));
1053               break;
1054             }
1055         }
1056
1057       err = fetch_next_ksba_cert (context, &cert);
1058       if (err)
1059         {
1060           log_error (_("error fetching certificate by S/N: %s\n"),
1061                      gpg_strerror (err) );
1062           break;
1063         }
1064
1065       issdn = ksba_cert_get_issuer (cert, 0);
1066       if (strcmp (issuer_dn, issdn))
1067         {
1068           log_debug ("find_cert_bysn: Ooops: issuer DN does not match\n");
1069           ksba_cert_release (cert);
1070           cert = NULL;
1071           ksba_free (issdn);
1072           break;
1073         }
1074
1075       sn = ksba_cert_get_serial (cert);
1076
1077       if (DBG_LOOKUP)
1078         {
1079           log_debug ("   considering certificate (#");
1080           dump_serial (sn);
1081           log_printf ("/");
1082           dump_string (issdn);
1083           log_printf (")\n");
1084         }
1085
1086       if (!compare_serialno (serialno, sn))
1087         {
1088           ksba_free (sn);
1089           ksba_free (issdn);
1090           cache_cert (cert);
1091           if (DBG_LOOKUP)
1092             log_debug ("   found\n");
1093           break; /* Ready.  */
1094         }
1095
1096       ksba_free (sn);
1097       ksba_free (issdn);
1098       ksba_cert_release (cert);
1099       cert = NULL;
1100     }
1101
1102   end_cert_fetch (context);
1103   return cert;
1104 }
1105
1106
1107 /* Return the certificate matching SUBJECT_DN and (if not NULL)
1108  * KEYID. If it is not already in the cache, try to find it from other
1109  * resources.  Note, that the external search does not work for user
1110  * certificates because the LDAP lookup is on the caCertificate
1111  * attribute. For our purposes this is just fine.  */
1112 ksba_cert_t
1113 find_cert_bysubject (ctrl_t ctrl, const char *subject_dn, ksba_sexp_t keyid)
1114 {
1115   gpg_error_t err;
1116   int seq;
1117   ksba_cert_t cert = NULL;
1118   cert_fetch_context_t context = NULL;
1119   ksba_sexp_t subj;
1120
1121   /* If we have certificates from an OCSP request we first try to use
1122    * them.  This is because these certificates will really be the
1123    * required ones and thus even in the case that they can't be
1124    * uniquely located by the following code we can use them.  This is
1125    * for example required by Telesec certificates where a keyId is
1126    * used but the issuer certificate comes without a subject keyId! */
1127   if (ctrl->ocsp_certs && subject_dn)
1128     {
1129       cert_item_t ci;
1130       cert_ref_t cr;
1131       int i;
1132
1133       /* For efficiency reasons we won't use get_cert_bysubject here. */
1134       acquire_cache_read_lock ();
1135       for (i=0; i < 256; i++)
1136         for (ci=cert_cache[i]; ci; ci = ci->next)
1137           if (ci->cert && ci->subject_dn
1138               && !strcmp (ci->subject_dn, subject_dn))
1139             for (cr=ctrl->ocsp_certs; cr; cr = cr->next)
1140               if (!memcmp (ci->fpr, cr->fpr, 20))
1141                 {
1142                   ksba_cert_ref (ci->cert);
1143                   release_cache_lock ();
1144                   return ci->cert; /* We use this certificate. */
1145                 }
1146       release_cache_lock ();
1147       if (DBG_LOOKUP)
1148         log_debug ("find_cert_bysubject: certificate not in ocsp_certs\n");
1149     }
1150
1151   /* No check whether the certificate is cached.  */
1152   for (seq=0; (cert = get_cert_bysubject (subject_dn, seq)); seq++)
1153     {
1154       if (!keyid)
1155         break; /* No keyid requested, so return the first one found. */
1156       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj)
1157           && !cmp_simple_canon_sexp (keyid, subj))
1158         {
1159           xfree (subj);
1160           break; /* Found matching cert. */
1161         }
1162       xfree (subj);
1163       ksba_cert_release (cert);
1164     }
1165   if (cert)
1166     return cert; /* Done.  */
1167
1168   if (DBG_LOOKUP)
1169     log_debug ("find_cert_bysubject: certificate not in cache\n");
1170
1171   /* Ask back to the service requester to return the certificate.
1172    * This is because we can assume that he already used the
1173    * certificate while checking for the CRL. */
1174   if (keyid)
1175     cert = get_cert_local_ski (ctrl, subject_dn, keyid);
1176   else
1177     {
1178       /* In contrast to get_cert_local_ski, get_cert_local uses any
1179        * passed pattern, so we need to make sure that an exact subject
1180        * search is done.  */
1181       char *buf;
1182
1183       buf = strconcat ("/", subject_dn, NULL);
1184       if (!buf)
1185         {
1186           log_error ("can't allocate enough memory: %s\n", strerror (errno));
1187           return NULL;
1188         }
1189       cert = get_cert_local (ctrl, buf);
1190       xfree (buf);
1191     }
1192   if (cert)
1193     {
1194       cache_cert (cert);
1195       return cert; /* Done. */
1196     }
1197
1198   if (DBG_LOOKUP)
1199     log_debug ("find_cert_bysubject: certificate not returned by caller"
1200                " - doing lookup\n");
1201
1202   /* Locate the certificate using external resources. */
1203   while (!cert)
1204     {
1205       char *subjdn;
1206
1207       if (!context)
1208         {
1209           err = ca_cert_fetch (ctrl, &context, subject_dn);
1210           if (err)
1211             {
1212               log_error (_("error fetching certificate by subject: %s\n"),
1213                          gpg_strerror (err));
1214               break;
1215             }
1216         }
1217
1218       err = fetch_next_ksba_cert (context, &cert);
1219       if (err)
1220         {
1221           log_error (_("error fetching certificate by subject: %s\n"),
1222                      gpg_strerror (err) );
1223           break;
1224         }
1225
1226       subjdn = ksba_cert_get_subject (cert, 0);
1227       if (strcmp (subject_dn, subjdn))
1228         {
1229           log_info ("find_cert_bysubject: subject DN does not match\n");
1230           ksba_cert_release (cert);
1231           cert = NULL;
1232           ksba_free (subjdn);
1233           continue;
1234         }
1235
1236
1237       if (DBG_LOOKUP)
1238         {
1239           log_debug ("   considering certificate (/");
1240           dump_string (subjdn);
1241           log_printf (")\n");
1242         }
1243       ksba_free (subjdn);
1244
1245       /* If no key ID has been provided, we return the first match.  */
1246       if (!keyid)
1247         {
1248           cache_cert (cert);
1249           if (DBG_LOOKUP)
1250             log_debug ("   found\n");
1251           break; /* Ready.  */
1252         }
1253
1254       /* With the key ID given we need to compare it.  */
1255       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj))
1256         {
1257           if (!cmp_simple_canon_sexp (keyid, subj))
1258             {
1259               ksba_free (subj);
1260               cache_cert (cert);
1261               if (DBG_LOOKUP)
1262                 log_debug ("   found\n");
1263               break; /* Ready.  */
1264             }
1265         }
1266
1267       ksba_free (subj);
1268       ksba_cert_release (cert);
1269       cert = NULL;
1270     }
1271
1272   end_cert_fetch (context);
1273   return cert;
1274 }
1275
1276
1277 /* Return 0 if the certificate is a trusted certificate. Returns
1278    GPG_ERR_NOT_TRUSTED if it is not trusted or other error codes in
1279    case of systems errors. */
1280 gpg_error_t
1281 is_trusted_cert (ksba_cert_t cert)
1282 {
1283   unsigned char fpr[20];
1284   cert_item_t ci;
1285
1286   cert_compute_fpr (cert, fpr);
1287
1288   acquire_cache_read_lock ();
1289   for (ci=cert_cache[*fpr]; ci; ci = ci->next)
1290     if (ci->cert && !memcmp (ci->fpr, fpr, 20))
1291       {
1292         if (ci->flags.trusted)
1293           {
1294             release_cache_lock ();
1295             return 0; /* Yes, it is trusted. */
1296           }
1297         break;
1298       }
1299
1300   release_cache_lock ();
1301   return gpg_error (GPG_ERR_NOT_TRUSTED);
1302 }
1303
1304
1305 \f
1306 /* Given the certificate CERT locate the issuer for this certificate
1307  * and return it at R_CERT.  Returns 0 on success or
1308  * GPG_ERR_NOT_FOUND.  */
1309 gpg_error_t
1310 find_issuing_cert (ctrl_t ctrl, ksba_cert_t cert, ksba_cert_t *r_cert)
1311 {
1312   gpg_error_t err;
1313   char *issuer_dn;
1314   ksba_cert_t issuer_cert = NULL;
1315   ksba_name_t authid;
1316   ksba_sexp_t authidno;
1317   ksba_sexp_t keyid;
1318
1319   *r_cert = NULL;
1320
1321   issuer_dn = ksba_cert_get_issuer (cert, 0);
1322   if (!issuer_dn)
1323     {
1324       log_error (_("no issuer found in certificate\n"));
1325       err = gpg_error (GPG_ERR_BAD_CERT);
1326       goto leave;
1327     }
1328
1329   /* First we need to check whether we can return that certificate
1330      using the authorithyKeyIdentifier.  */
1331   err = ksba_cert_get_auth_key_id (cert, &keyid, &authid, &authidno);
1332   if (err)
1333     {
1334       log_info (_("error getting authorityKeyIdentifier: %s\n"),
1335                 gpg_strerror (err));
1336     }
1337   else
1338     {
1339       const char *s = ksba_name_enum (authid, 0);
1340       if (s && *authidno)
1341         {
1342           issuer_cert = find_cert_bysn (ctrl, s, authidno);
1343         }
1344
1345       if (!issuer_cert && keyid)
1346         {
1347           /* Not found by issuer+s/n.  Now that we have an AKI
1348            * keyIdentifier look for a certificate with a matching
1349            * SKI. */
1350           issuer_cert = find_cert_bysubject (ctrl, issuer_dn, keyid);
1351         }
1352
1353       /* Print a note so that the user does not feel too helpless when
1354        * an issuer certificate was found and gpgsm prints BAD
1355        * signature because it is not the correct one.  */
1356       if (!issuer_cert)
1357         {
1358           log_info ("issuer certificate ");
1359           if (keyid)
1360             {
1361               log_printf ("{");
1362               dump_serial (keyid);
1363               log_printf ("} ");
1364             }
1365           if (authidno)
1366             {
1367               log_printf ("(#");
1368               dump_serial (authidno);
1369               log_printf ("/");
1370               dump_string (s);
1371               log_printf (") ");
1372             }
1373           log_printf ("not found using authorityKeyIdentifier\n");
1374         }
1375       ksba_name_release (authid);
1376       xfree (authidno);
1377       xfree (keyid);
1378     }
1379
1380   /* If this did not work, try just with the issuer's name and assume
1381    * that there is only one such certificate.  We only look into our
1382    * cache then.  */
1383   if (err || !issuer_cert)
1384     {
1385       issuer_cert = get_cert_bysubject (issuer_dn, 0);
1386       if (issuer_cert)
1387         err = 0;
1388     }
1389
1390  leave:
1391   if (!err && !issuer_cert)
1392     err = gpg_error (GPG_ERR_NOT_FOUND);
1393
1394   xfree (issuer_dn);
1395
1396   if (err)
1397     ksba_cert_release (issuer_cert);
1398   else
1399     *r_cert = issuer_cert;
1400
1401   return err;
1402 }