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