Merged Dirmngr with GnuPG.
[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   FILE *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 = fopen (fname, "rb");
357       if (!fp)
358         {
359           log_error (_("can't open `%s': %s\n"),
360                      fname, strerror (errno));
361           continue;
362         }
363       err = ksba_reader_new (&reader);
364       if (!err)
365         err = ksba_reader_set_file (reader, fp);
366       if (err)
367         {
368           log_error (_("can't setup KSBA reader: %s\n"), gpg_strerror (err));
369           ksba_reader_release (reader);
370           fclose (fp);
371           continue;
372         }
373
374       err = ksba_cert_new (&cert);
375       if (!err)
376         err = ksba_cert_read_der (cert, reader);
377       ksba_reader_release (reader);
378       fclose (fp);
379       if (err)
380         {
381           log_error (_("can't parse certificate `%s': %s\n"),
382                      fname, gpg_strerror (err));
383           ksba_cert_release (cert);
384           continue;
385         }
386
387       err = put_cert (cert, 1, are_trusted, NULL);
388       if (gpg_err_code (err) == GPG_ERR_DUP_VALUE)
389         log_info (_("certificate `%s' already cached\n"), fname);
390       else if (!err)
391         {
392           if (are_trusted)
393             log_info (_("trusted certificate `%s' loaded\n"), fname);
394           else
395             log_info (_("certificate `%s' loaded\n"), fname);
396           if (opt.verbose)
397             {
398               p = get_fingerprint_hexstring_colon (cert);
399               log_info (_("  SHA1 fingerprint = %s\n"), p);
400               xfree (p);
401
402               cert_log_name (_("   issuer ="), cert);
403               cert_log_subject (_("  subject ="), cert);
404             }
405         }
406       else
407         log_error (_("error loading certificate `%s': %s\n"),
408                      fname, gpg_strerror (err));
409       ksba_cert_release (cert);
410     }
411
412   xfree (fname);
413   closedir (dir);
414   return 0;
415 }
416
417
418 /* Initialize the certificate cache if not yet done.  */
419 void
420 cert_cache_init (void)
421 {
422   char *dname;
423   
424   if (initialization_done)
425     return;
426   init_cache_lock ();
427   acquire_cache_write_lock ();
428
429   dname = make_filename (opt.homedir, "trusted-certs", NULL);
430   load_certs_from_dir (dname, 1);
431   xfree (dname);
432
433   dname = make_filename (opt.homedir_data, "extra-certs", NULL);
434   load_certs_from_dir (dname, 0);
435   xfree (dname);
436
437   initialization_done = 1;
438   release_cache_lock ();
439             
440   cert_cache_print_stats ();
441 }
442
443 /* Deinitialize the certificate cache.  With FULL set to true even the
444    unused certificate slots are released. */
445 void
446 cert_cache_deinit (int full)
447 {
448   cert_item_t ci, ci2;
449   int i;
450
451   if (!initialization_done)
452     return;
453
454   acquire_cache_write_lock ();
455
456   for (i=0; i < 256; i++)
457     for (ci=cert_cache[i]; ci; ci = ci->next)
458       clean_cache_slot (ci);
459
460   if (full)
461     {
462       for (i=0; i < 256; i++)
463         {
464           for (ci=cert_cache[i]; ci; ci = ci2)
465             {
466               ci2 = ci->next;
467               xfree (ci);
468             }
469           cert_cache[i] = NULL;
470         }
471     }
472
473   total_loaded_certificates = 0;
474   total_extra_certificates = 0;
475   initialization_done = 0;
476   release_cache_lock ();
477 }
478
479 /* Print some statistics to the log file.  */
480 void
481 cert_cache_print_stats (void)
482 {
483   log_info (_("permanently loaded certificates: %u\n"),
484             total_loaded_certificates);
485   log_info (_("    runtime cached certificates: %u\n"),
486             total_extra_certificates);
487 }
488
489
490 /* Put CERT into the certificate cache.  */
491 gpg_error_t
492 cache_cert (ksba_cert_t cert)
493 {
494   gpg_error_t err;
495
496   acquire_cache_write_lock ();
497   err = put_cert (cert, 0, 0, NULL);
498   release_cache_lock ();
499   if (gpg_err_code (err) == GPG_ERR_DUP_VALUE)
500     log_info (_("certificate already cached\n"));
501   else if (!err)
502     log_info (_("certificate cached\n"));
503   else
504     log_error (_("error caching certificate: %s\n"), gpg_strerror (err));
505   return err;
506 }
507
508
509 /* Put CERT into the certificate cache and store the fingerprint of
510    the certificate into FPR_BUFFER.  If the certificate is already in
511    the cache do not print a warning; just store the
512    fingerprint. FPR_BUFFER needs to be at least 20 bytes. */
513 gpg_error_t
514 cache_cert_silent (ksba_cert_t cert, void *fpr_buffer)
515 {
516   gpg_error_t err;
517
518   acquire_cache_write_lock ();
519   err = put_cert (cert, 0, 0, fpr_buffer);
520   release_cache_lock ();
521   if (gpg_err_code (err) == GPG_ERR_DUP_VALUE)
522     err = 0;
523   if (err)
524     log_error (_("error caching certificate: %s\n"), gpg_strerror (err));
525   return err;
526 }
527
528
529 \f
530 /* Return a certificate object for the given fingerprint.  FPR is
531    expected to be a 20 byte binary SHA-1 fingerprint.  If no matching
532    certificate is available in the cache NULL is returned.  The caller
533    must release a returned certificate.  Note that although we are
534    using reference counting the caller should not just compare the
535    pointers to check for identical certificates. */
536 ksba_cert_t
537 get_cert_byfpr (const unsigned char *fpr)
538 {
539   cert_item_t ci;
540
541   acquire_cache_read_lock ();
542   for (ci=cert_cache[*fpr]; ci; ci = ci->next)
543     if (ci->cert && !memcmp (ci->fpr, fpr, 20))
544       {
545         ksba_cert_ref (ci->cert);
546         release_cache_lock ();
547         return ci->cert;
548       }
549
550   release_cache_lock ();
551   return NULL;
552 }
553
554 /* Return a certificate object for the given fingerprint.  STRING is
555    expected to be a SHA-1 fingerprint in standard hex notation with or
556    without colons.  If no matching certificate is available in the
557    cache NULL is returned.  The caller must release a returned
558    certificate.  Note that although we are using reference counting
559    the caller should not just compare the pointers to check for
560    identical certificates. */
561 ksba_cert_t
562 get_cert_byhexfpr (const char *string)
563 {
564   unsigned char fpr[20];
565   const char *s;
566   int i;
567
568   if (strchr (string, ':'))
569     {
570       for (s=string,i=0; i < 20 && hexdigitp (s) && hexdigitp(s+1);)
571         {
572           if (s[2] && s[2] != ':')
573             break; /* Invalid string. */
574           fpr[i++] = xtoi_2 (s);
575           s += 2;
576           if (i!= 20 && *s == ':')
577             s++;
578         }
579     }
580   else
581     {
582       for (s=string,i=0; i < 20 && hexdigitp (s) && hexdigitp(s+1); s+=2 )
583         fpr[i++] = xtoi_2 (s);
584     }
585   if (i!=20 || *s)
586     {
587       log_error (_("invalid SHA1 fingerprint string `%s'\n"), string);
588       return NULL;
589     }
590
591   return get_cert_byfpr (fpr);
592 }
593
594
595
596 /* Return the certificate matching ISSUER_DN and SERIALNO.  */
597 ksba_cert_t
598 get_cert_bysn (const char *issuer_dn, ksba_sexp_t serialno)
599 {
600   /* Simple and inefficient implementation.   fixme! */
601   cert_item_t ci;
602   int i;
603
604   acquire_cache_read_lock ();
605   for (i=0; i < 256; i++)
606     {
607       for (ci=cert_cache[i]; ci; ci = ci->next)
608         if (ci->cert && !strcmp (ci->issuer_dn, issuer_dn)
609             && !compare_serialno (ci->sn, serialno))
610           {
611             ksba_cert_ref (ci->cert);
612             release_cache_lock ();
613             return ci->cert;
614           }
615     }
616
617   release_cache_lock ();
618   return NULL;
619 }
620
621
622 /* Return the certificate matching ISSUER_DN.  SEQ should initially be
623    set to 0 and bumped up to get the next issuer with that DN. */
624 ksba_cert_t
625 get_cert_byissuer (const char *issuer_dn, unsigned int seq)
626 {
627   /* Simple and very inefficient implementation and API.  fixme! */
628   cert_item_t ci;
629   int i;
630
631   acquire_cache_read_lock ();
632   for (i=0; i < 256; i++)
633     {
634       for (ci=cert_cache[i]; ci; ci = ci->next)
635         if (ci->cert && !strcmp (ci->issuer_dn, issuer_dn))
636           if (!seq--)
637             {
638               ksba_cert_ref (ci->cert);
639               release_cache_lock ();
640               return ci->cert;
641             }
642     }
643
644   release_cache_lock ();
645   return NULL;
646 }
647
648
649 /* Return the certificate matching SUBJECT_DN.  SEQ should initially be
650    set to 0 and bumped up to get the next subject with that DN. */
651 ksba_cert_t
652 get_cert_bysubject (const char *subject_dn, unsigned int seq)
653 {
654   /* Simple and very inefficient implementation and API.  fixme! */
655   cert_item_t ci;
656   int i;
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 = PATTERN_UNKNOWN;
685   const char *s;
686   int hexprefix = 0;
687   int hexlength;
688   int mode = 0;   
689     
690   *r_offset = *r_sn_offset = 0;
691
692   /* Skip leading spaces. */
693   for(s = pattern; *s && spacep (s); s++ )
694     ;
695
696   switch (*s) 
697     {
698     case 0:  /* Empty string is an error. */
699       result = PATTERN_UNKNOWN;
700       break;
701
702     case '.': /* An email address, compare from end.  */
703       result = PATTERN_UNKNOWN;  /* Not implemented.  */
704       break;
705
706     case '<': /* An email address.  */
707       result = PATTERN_EMAIL;
708       s++;
709       break;
710
711     case '@': /* Part of an email address.  */
712       result = PATTERN_EMAIL_SUBSTR;
713       s++;
714       break;
715
716     case '=':  /* Exact compare. */
717       result = PATTERN_UNKNOWN; /* Does not make sense for X.509.  */
718       break;
719
720     case '*':  /* Case insensitive substring search.  */
721       mode = PATTERN_SUBSTR;
722       s++;
723       break;
724
725     case '+':  /* Compare individual words. */
726       result = PATTERN_UNKNOWN;  /* Not implemented.  */
727       break;
728
729     case '/': /* Subject's DN. */
730       s++;
731       if (!*s || spacep (s))
732         result = PATTERN_UNKNOWN; /* No DN or prefixed with a space. */
733       else
734         result = PATTERN_SUBJECT;
735       break;
736
737     case '#': /* Serial number or issuer DN. */
738       { 
739         const char *si;
740         
741         s++;
742         if ( *s == '/')
743           { 
744             /* An issuer's DN is indicated by "#/" */
745             s++;
746             if (!*s || spacep (s))
747               result = PATTERN_UNKNOWN; /* No DN or prefixed with a space. */
748             else
749               result = PATTERN_ISSUER;
750           }
751         else 
752           { /* Serialnumber + optional issuer ID. */
753             for (si=s; *si && *si != '/'; si++)
754               if (!strchr("01234567890abcdefABCDEF", *si))
755                 break;
756             if (*si && *si != '/')
757               result = PATTERN_UNKNOWN; /* Invalid digit in serial number. */
758             else
759               {
760                 *r_sn_offset = s - pattern;
761                 if (!*si)
762                   result = PATTERN_SERIALNO;
763                 else
764                   {
765                     s = si+1;
766                     if (!*s || spacep (s))
767                       result = PATTERN_UNKNOWN; /* No DN or prefixed
768                                                    with a space. */
769                     else
770                       result = PATTERN_SERIALNO_ISSUER;
771                   }
772               }
773           }
774       }
775       break;
776
777     case ':': /* Unified fingerprint. */
778       {  
779         const char *se, *si;
780         int i;
781         
782         se = strchr (++s, ':');
783         if (!se)
784           result = PATTERN_UNKNOWN;
785         else
786           {
787             for (i=0, si=s; si < se; si++, i++ )
788               if (!strchr("01234567890abcdefABCDEF", *si))
789                 break;
790             if ( si < se )
791               result = PATTERN_UNKNOWN; /* Invalid digit. */
792             else if (i == 32)
793               result = PATTERN_FINGERPRINT16;
794             else if (i == 40)
795               result = PATTERN_FINGERPRINT20;
796             else
797               result = PATTERN_UNKNOWN; /* Invalid length for a fingerprint. */
798           }
799       } 
800       break;
801
802     case '&': /* Keygrip. */
803       result = PATTERN_UNKNOWN;  /* Not implemented.  */
804       break;
805
806     default:
807       if (s[0] == '0' && s[1] == 'x')
808         {
809           hexprefix = 1;
810           s += 2;
811         }
812
813       hexlength = strspn(s, "0123456789abcdefABCDEF");
814
815       /* Check if a hexadecimal number is terminated by EOS or blank. */
816       if (hexlength && s[hexlength] && !spacep (s+hexlength)) 
817         {
818           /* If the "0x" prefix is used a correct termination is required. */
819           if (hexprefix) 
820             {
821               result = PATTERN_UNKNOWN;   
822               break; /* switch */
823             }
824           hexlength = 0;  /* Not a hex number.  */
825         }
826       
827       if (hexlength == 8 || (!hexprefix && hexlength == 9 && *s == '0'))
828         { 
829           if (hexlength == 9)
830             s++;
831           result = PATTERN_SHORT_KEYID;
832         }
833       else if (hexlength == 16 || (!hexprefix && hexlength == 17 && *s == '0'))
834         { 
835           if (hexlength == 17)
836             s++;
837           result = PATTERN_LONG_KEYID;
838         }
839       else if (hexlength == 32 || (!hexprefix && hexlength == 33 && *s == '0'))
840         { 
841           if (hexlength == 33)
842             s++;
843           result = PATTERN_FINGERPRINT16;
844         }
845       else if (hexlength == 40 || (!hexprefix && hexlength == 41 && *s == '0'))
846         { 
847           if (hexlength == 41)
848             s++;
849           result = PATTERN_FINGERPRINT20;
850         }
851       else if (!hexprefix)
852         { 
853           /* The fingerprints used with X.509 are often delimited by
854              colons, so we try to single this case out. */
855           result = PATTERN_UNKNOWN;
856           hexlength = strspn (s, ":0123456789abcdefABCDEF");
857           if (hexlength == 59 && (!s[hexlength] || spacep (s+hexlength))) 
858             {
859               int i, c;
860
861               for (i=0; i < 20; i++, s += 3) 
862                 {
863                   c = hextobyte(s);
864                   if (c == -1 || (i < 19 && s[2] != ':'))
865                     break;
866                 }
867               if (i == 20)
868                 result = PATTERN_FINGERPRINT20;
869             }
870           if (result == PATTERN_UNKNOWN) /* Default to substring match. */
871             { 
872               result = PATTERN_SUBSTR;
873             }
874         }
875       else /* A hex number with a prefix but with a wrong length.  */
876         result = PATTERN_UNKNOWN;
877     }
878   
879   if (result != PATTERN_UNKNOWN)
880     *r_offset = s - pattern;
881   return result;
882 }
883
884
885
886 /* Given PATTERN, which is a string as used by GnuPG to specify a
887    certificate, return all matching certificates by calling the
888    supplied function RETFNC.  */
889 gpg_error_t
890 get_certs_bypattern (const char *pattern, 
891                      gpg_error_t (*retfnc)(void*,ksba_cert_t),
892                      void *retfnc_data)
893 {
894   gpg_error_t err = GPG_ERR_BUG;
895   enum pattern_class class;
896   size_t offset, sn_offset;
897   const char *hexserialno;
898   ksba_sexp_t serialno = NULL;
899   ksba_cert_t cert = NULL;
900   unsigned int seq;
901
902   if (!pattern || !retfnc)
903     return gpg_error (GPG_ERR_INV_ARG);
904
905   class = classify_pattern (pattern, &offset, &sn_offset);
906   hexserialno = pattern + sn_offset;
907   pattern += offset;
908   switch (class)
909     {
910     case PATTERN_UNKNOWN: 
911       err = gpg_error (GPG_ERR_INV_NAME);
912       break;
913
914     case PATTERN_FINGERPRINT20:
915       cert = get_cert_byhexfpr (pattern);
916       err = cert? 0 : gpg_error (GPG_ERR_NOT_FOUND);
917       break;
918
919     case PATTERN_SERIALNO_ISSUER:
920       serialno = hexsn_to_sexp (hexserialno);
921       if (!serialno)
922         err = gpg_error_from_syserror ();
923       else
924         {
925           cert = get_cert_bysn (pattern, serialno);
926           err = cert? 0 : gpg_error (GPG_ERR_NOT_FOUND);
927         }
928       break;
929
930     case PATTERN_ISSUER:
931       for (seq=0,err=0; !err && (cert = get_cert_byissuer (pattern, seq)); seq++)
932         {
933           err = retfnc (retfnc_data, cert);
934           ksba_cert_release (cert);
935           cert = NULL;
936         }
937       if (!err && !seq)
938         err = gpg_error (GPG_ERR_NOT_FOUND);
939       break;
940
941     case PATTERN_SUBJECT:
942       for (seq=0,err=0; !err && (cert = get_cert_bysubject (pattern, seq));seq++)
943         {
944           err = retfnc (retfnc_data, cert);
945           ksba_cert_release (cert);
946           cert = NULL;
947         }
948       if (!err && !seq)
949         err = gpg_error (GPG_ERR_NOT_FOUND);
950       break;
951       
952     case PATTERN_EMAIL:
953     case PATTERN_EMAIL_SUBSTR:
954     case PATTERN_FINGERPRINT16:
955     case PATTERN_SHORT_KEYID:
956     case PATTERN_LONG_KEYID:
957     case PATTERN_SUBSTR:
958     case PATTERN_SERIALNO:
959       /* Not supported.  */
960       err = gpg_error (GPG_ERR_INV_NAME);
961     }
962
963
964   if (!err && cert)
965     err = retfnc (retfnc_data, cert);
966   ksba_cert_release (cert);
967   xfree (serialno);
968   return err;
969 }
970
971
972
973
974 \f
975 /* Return the certificate matching ISSUER_DN and SERIALNO; if it is
976    not already in the cache, try to find it from other resources.  */
977 ksba_cert_t
978 find_cert_bysn (ctrl_t ctrl, const char *issuer_dn, ksba_sexp_t serialno)
979 {
980   gpg_error_t err;
981   ksba_cert_t cert;
982   cert_fetch_context_t context = NULL;
983   char *hexsn, *buf;
984
985   /* First check whether it has already been cached.  */
986   cert = get_cert_bysn (issuer_dn, serialno);
987   if (cert)
988     return cert;
989
990   /* Ask back to the service requester to return the certificate.
991      This is because we can assume that he already used the
992      certificate while checking for the CRL. */
993   hexsn = serial_hex (serialno);
994   if (!hexsn)
995     {
996       log_error ("serial_hex() failed\n");
997       return NULL;
998     }
999   buf = xtrymalloc (1 + strlen (hexsn) + 1 + strlen (issuer_dn) + 1);
1000   if (!buf)
1001     {
1002       log_error ("can't allocate enough memory: %s\n", strerror (errno));
1003       xfree (hexsn);
1004       return NULL;
1005     }
1006   strcpy (stpcpy (stpcpy (stpcpy (buf, "#"), hexsn),"/"), issuer_dn);
1007   xfree (hexsn);
1008   cert = get_cert_local (ctrl, buf);
1009   xfree (buf);
1010   if (cert)
1011     {
1012       cache_cert (cert);
1013       return cert; /* Done. */
1014     }
1015
1016   if (DBG_LOOKUP)
1017     log_debug ("find_cert_bysn: certificate not returned by caller"
1018                " - doing lookup\n");
1019
1020   /* Retrieve the certificate from external resources. */
1021   while (!cert)
1022     {
1023       ksba_sexp_t sn;
1024       char *issdn;
1025
1026       if (!context)
1027         {
1028           err = ca_cert_fetch (ctrl, &context, issuer_dn);
1029           if (err)
1030             {
1031               log_error (_("error fetching certificate by S/N: %s\n"),
1032                          gpg_strerror (err));
1033               break;
1034             }
1035         }
1036       
1037       err = fetch_next_ksba_cert (context, &cert);
1038       if (err)
1039         {
1040           log_error (_("error fetching certificate by S/N: %s\n"),
1041                      gpg_strerror (err) );
1042           break;
1043         }
1044       
1045       issdn = ksba_cert_get_issuer (cert, 0);
1046       if (strcmp (issuer_dn, issdn))
1047         {
1048           log_debug ("find_cert_bysn: Ooops: issuer DN does not match\n");
1049           ksba_cert_release (cert);
1050           cert = NULL;
1051           ksba_free (issdn);
1052           break; 
1053         }
1054
1055       sn = ksba_cert_get_serial (cert);
1056
1057       if (DBG_LOOKUP)
1058         {
1059           log_debug ("   considering certificate (#");
1060           dump_serial (sn);
1061           log_printf ("/");
1062           dump_string (issdn);
1063           log_printf (")\n");
1064         }
1065
1066       if (!compare_serialno (serialno, sn))
1067         {
1068           ksba_free (sn);
1069           ksba_free (issdn);
1070           cache_cert (cert);
1071           if (DBG_LOOKUP)
1072             log_debug ("   found\n");
1073           break; /* Ready.  */
1074         }
1075
1076       ksba_free (sn);
1077       ksba_free (issdn);
1078       ksba_cert_release (cert);
1079       cert = NULL;
1080     }
1081
1082   end_cert_fetch (context);
1083   return cert;
1084 }
1085
1086
1087 /* Return the certificate matching SUBJECT_DN and (if not NULL)
1088    KEYID. If it is not already in the cache, try to find it from other
1089    resources.  Note, that the external search does not work for user
1090    certificates because the LDAP lookup is on the caCertificate
1091    attribute. For our purposes this is just fine.  */
1092 ksba_cert_t
1093 find_cert_bysubject (ctrl_t ctrl, const char *subject_dn, ksba_sexp_t keyid)
1094 {
1095   gpg_error_t err;
1096   int seq;
1097   ksba_cert_t cert = NULL;
1098   cert_fetch_context_t context = NULL;
1099   ksba_sexp_t subj;
1100
1101   /* If we have certificates from an OCSP request we first try to use
1102      them.  This is because these certificates will really be the
1103      required ones and thus even in the case that they can't be
1104      uniquely located by the following code we can use them.  This is
1105      for example required by Telesec certificates where a keyId is
1106      used but the issuer certificate comes without a subject keyId! */
1107   if (ctrl->ocsp_certs)
1108     {
1109       cert_item_t ci;
1110       cert_ref_t cr;
1111       int i;
1112
1113       /* For efficiency reasons we won't use get_cert_bysubject here. */
1114       acquire_cache_read_lock ();
1115       for (i=0; i < 256; i++)
1116         for (ci=cert_cache[i]; ci; ci = ci->next)
1117           if (ci->cert && ci->subject_dn
1118               && !strcmp (ci->subject_dn, subject_dn))
1119             for (cr=ctrl->ocsp_certs; cr; cr = cr->next)
1120               if (!memcmp (ci->fpr, cr->fpr, 20))
1121                 {
1122                   ksba_cert_ref (ci->cert);
1123                   release_cache_lock ();
1124                   return ci->cert; /* We use this certificate. */
1125                 }
1126       release_cache_lock ();
1127       if (DBG_LOOKUP)
1128         log_debug ("find_cert_bysubject: certificate not in ocsp_certs\n");
1129     }
1130
1131
1132   /* First we check whether the certificate is cached.  */
1133   for (seq=0; (cert = get_cert_bysubject (subject_dn, seq)); seq++)
1134     {
1135       if (!keyid)
1136         break; /* No keyid requested, so return the first one found. */
1137       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj)
1138           && !cmp_simple_canon_sexp (keyid, subj))
1139         {
1140           xfree (subj);
1141           break; /* Found matching cert. */
1142         }
1143       xfree (subj);
1144       ksba_cert_release (cert);
1145     }
1146   if (cert)
1147     return cert; /* Done.  */
1148
1149   if (DBG_LOOKUP)
1150     log_debug ("find_cert_bysubject: certificate not in cache\n");
1151
1152   /* Ask back to the service requester to return the certificate.
1153      This is because we can assume that he already used the
1154      certificate while checking for the CRL. */
1155   if (keyid)
1156     cert = get_cert_local_ski (ctrl, subject_dn, keyid);
1157   else
1158     {
1159       /* In contrast to get_cert_local_ski, get_cert_local uses any
1160          passed pattern, so we need to make sure that an exact subject
1161          search is done. */
1162       char *buf;
1163
1164       buf = xtrymalloc (1 + strlen (subject_dn) + 1);
1165       if (!buf)
1166         {
1167           log_error ("can't allocate enough memory: %s\n", strerror (errno));
1168           return NULL;
1169         }
1170       strcpy (stpcpy (buf, "/"), subject_dn);
1171       cert = get_cert_local (ctrl, buf);
1172       xfree (buf);
1173     }
1174   if (cert)
1175     {
1176       cache_cert (cert);
1177       return cert; /* Done. */
1178     }
1179
1180   if (DBG_LOOKUP)
1181     log_debug ("find_cert_bysubject: certificate not returned by caller"
1182                " - doing lookup\n");
1183
1184   /* Locate the certificate using external resources. */
1185   while (!cert)
1186     {
1187       char *subjdn;
1188
1189       if (!context)
1190         {
1191           err = ca_cert_fetch (ctrl, &context, subject_dn);
1192           if (err)
1193             {
1194               log_error (_("error fetching certificate by subject: %s\n"),
1195                          gpg_strerror (err));
1196               break;
1197             }
1198         }
1199       
1200       err = fetch_next_ksba_cert (context, &cert);
1201       if (err)
1202         {
1203           log_error (_("error fetching certificate by subject: %s\n"),
1204                      gpg_strerror (err) );
1205           break;
1206         }
1207       
1208       subjdn = ksba_cert_get_subject (cert, 0);
1209       if (strcmp (subject_dn, subjdn))
1210         {
1211           log_info ("find_cert_bysubject: subject DN does not match\n");
1212           ksba_cert_release (cert);
1213           cert = NULL;
1214           ksba_free (subjdn);
1215           continue; 
1216         }
1217
1218
1219       if (DBG_LOOKUP)
1220         {
1221           log_debug ("   considering certificate (/");
1222           dump_string (subjdn);
1223           log_printf (")\n");
1224         }
1225       ksba_free (subjdn);
1226
1227       /* If no key ID has been provided, we return the first match.  */
1228       if (!keyid)
1229         {
1230           cache_cert (cert);
1231           if (DBG_LOOKUP)
1232             log_debug ("   found\n");
1233           break; /* Ready.  */
1234         }
1235
1236       /* With the key ID given we need to compare it.  */
1237       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj))
1238         {
1239           if (!cmp_simple_canon_sexp (keyid, subj))
1240             {
1241               ksba_free (subj);
1242               cache_cert (cert);
1243               if (DBG_LOOKUP)
1244                 log_debug ("   found\n");
1245               break; /* Ready.  */
1246             }
1247         }
1248
1249       ksba_free (subj);
1250       ksba_cert_release (cert);
1251       cert = NULL;
1252     }
1253
1254   end_cert_fetch (context);
1255   return cert;
1256 }
1257
1258
1259
1260 /* Return 0 if the certificate is a trusted certificate. Returns
1261    GPG_ERR_NOT_TRUSTED if it is not trusted or other error codes in
1262    case of systems errors. */
1263 gpg_error_t 
1264 is_trusted_cert (ksba_cert_t cert)
1265 {
1266   unsigned char fpr[20];
1267   cert_item_t ci;
1268
1269   cert_compute_fpr (cert, fpr);
1270
1271   acquire_cache_read_lock ();
1272   for (ci=cert_cache[*fpr]; ci; ci = ci->next)
1273     if (ci->cert && !memcmp (ci->fpr, fpr, 20))
1274       {
1275         if (ci->flags.trusted)
1276           {
1277             release_cache_lock ();
1278             return 0; /* Yes, it is trusted. */
1279           }
1280         break;
1281       }
1282
1283   release_cache_lock ();
1284   return gpg_error (GPG_ERR_NOT_TRUSTED);
1285 }
1286
1287
1288 \f
1289 /* Given the certificate CERT locate the issuer for this certificate
1290    and return it at R_CERT.  Returns 0 on success or
1291    GPG_ERR_NOT_FOUND.  */
1292 gpg_error_t
1293 find_issuing_cert (ctrl_t ctrl, ksba_cert_t cert, ksba_cert_t *r_cert)
1294 {
1295   gpg_error_t err;
1296   char *issuer_dn;
1297   ksba_cert_t issuer_cert = NULL;
1298   ksba_name_t authid;
1299   ksba_sexp_t authidno;
1300   ksba_sexp_t keyid;
1301
1302   *r_cert = NULL;
1303
1304   issuer_dn = ksba_cert_get_issuer (cert, 0);
1305   if (!issuer_dn)
1306     {
1307       log_error (_("no issuer found in certificate\n"));
1308       err = gpg_error (GPG_ERR_BAD_CERT);
1309       goto leave;
1310     }
1311
1312   /* First we need to check whether we can return that certificate
1313      using the authorithyKeyIdentifier.  */
1314   err = ksba_cert_get_auth_key_id (cert, &keyid, &authid, &authidno);
1315   if (err)
1316     {
1317       log_info (_("error getting authorityKeyIdentifier: %s\n"),
1318                 gpg_strerror (err));
1319     }
1320   else
1321     {
1322       const char *s = ksba_name_enum (authid, 0);
1323       if (s && *authidno)
1324         {
1325           issuer_cert = find_cert_bysn (ctrl, s, authidno);
1326         }
1327       if (!issuer_cert && keyid)
1328         {
1329           /* Not found by issuer+s/n.  Now that we have an AKI
1330              keyIdentifier look for a certificate with a matching
1331              SKI. */
1332           issuer_cert = find_cert_bysubject (ctrl, issuer_dn, keyid);
1333         }
1334       /* Print a note so that the user does not feel too helpless when
1335          an issuer certificate was found and gpgsm prints BAD
1336          signature because it is not the correct one. */
1337       if (!issuer_cert)
1338         {
1339           log_info ("issuer certificate ");
1340           if (keyid)
1341             {
1342               log_printf ("{");
1343               dump_serial (keyid);
1344               log_printf ("} ");
1345             }
1346           if (authidno)
1347             {
1348               log_printf ("(#");
1349               dump_serial (authidno);
1350               log_printf ("/");
1351               dump_string (s);
1352               log_printf (") ");
1353             }
1354           log_printf ("not found using authorityKeyIdentifier\n");
1355         }
1356       ksba_name_release (authid);
1357       xfree (authidno);
1358       xfree (keyid);
1359     }
1360
1361   /* If this did not work, try just with the issuer's name and assume
1362      that there is only one such certificate.  We only look into our
1363      cache then. */
1364   if (err || !issuer_cert)
1365     {
1366       issuer_cert = get_cert_bysubject (issuer_dn, 0);
1367       if (issuer_cert)
1368         err = 0;
1369     }
1370
1371  leave:  
1372   if (!err && !issuer_cert)
1373     err = gpg_error (GPG_ERR_NOT_FOUND);
1374
1375   xfree (issuer_dn);
1376
1377   if (err)
1378     ksba_cert_release (issuer_cert);
1379   else
1380     *r_cert = issuer_cert;
1381
1382   return err;
1383 }
1384