Fix setting of default homedir for Wince
[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   acquire_cache_read_lock ();
656   for (i=0; i < 256; i++)
657     {
658       for (ci=cert_cache[i]; ci; ci = ci->next)
659         if (ci->cert && ci->subject_dn
660             && !strcmp (ci->subject_dn, subject_dn))
661           if (!seq--)
662             {
663               ksba_cert_ref (ci->cert);
664               release_cache_lock ();
665               return ci->cert;
666             }
667     }
668
669   release_cache_lock ();
670   return NULL;
671 }
672
673
674
675 /* Return a value decribing the the class of PATTERN.  The offset of
676    the actual string to be used for the comparison is stored at
677    R_OFFSET.  The offset of the serialnumer is stored at R_SN_OFFSET. */
678 static enum pattern_class
679 classify_pattern (const char *pattern, size_t *r_offset, size_t *r_sn_offset)
680 {
681   enum pattern_class result = PATTERN_UNKNOWN;
682   const char *s;
683   int hexprefix = 0;
684   int hexlength;
685   int mode = 0;   
686     
687   *r_offset = *r_sn_offset = 0;
688
689   /* Skip leading spaces. */
690   for(s = pattern; *s && spacep (s); s++ )
691     ;
692
693   switch (*s) 
694     {
695     case 0:  /* Empty string is an error. */
696       result = PATTERN_UNKNOWN;
697       break;
698
699     case '.': /* An email address, compare from end.  */
700       result = PATTERN_UNKNOWN;  /* Not implemented.  */
701       break;
702
703     case '<': /* An email address.  */
704       result = PATTERN_EMAIL;
705       s++;
706       break;
707
708     case '@': /* Part of an email address.  */
709       result = PATTERN_EMAIL_SUBSTR;
710       s++;
711       break;
712
713     case '=':  /* Exact compare. */
714       result = PATTERN_UNKNOWN; /* Does not make sense for X.509.  */
715       break;
716
717     case '*':  /* Case insensitive substring search.  */
718       mode = PATTERN_SUBSTR;
719       s++;
720       break;
721
722     case '+':  /* Compare individual words. */
723       result = PATTERN_UNKNOWN;  /* Not implemented.  */
724       break;
725
726     case '/': /* Subject's DN. */
727       s++;
728       if (!*s || spacep (s))
729         result = PATTERN_UNKNOWN; /* No DN or prefixed with a space. */
730       else
731         result = PATTERN_SUBJECT;
732       break;
733
734     case '#': /* Serial number or issuer DN. */
735       { 
736         const char *si;
737         
738         s++;
739         if ( *s == '/')
740           { 
741             /* An issuer's DN is indicated by "#/" */
742             s++;
743             if (!*s || spacep (s))
744               result = PATTERN_UNKNOWN; /* No DN or prefixed with a space. */
745             else
746               result = PATTERN_ISSUER;
747           }
748         else 
749           { /* Serialnumber + optional issuer ID. */
750             for (si=s; *si && *si != '/'; si++)
751               if (!strchr("01234567890abcdefABCDEF", *si))
752                 break;
753             if (*si && *si != '/')
754               result = PATTERN_UNKNOWN; /* Invalid digit in serial number. */
755             else
756               {
757                 *r_sn_offset = s - pattern;
758                 if (!*si)
759                   result = PATTERN_SERIALNO;
760                 else
761                   {
762                     s = si+1;
763                     if (!*s || spacep (s))
764                       result = PATTERN_UNKNOWN; /* No DN or prefixed
765                                                    with a space. */
766                     else
767                       result = PATTERN_SERIALNO_ISSUER;
768                   }
769               }
770           }
771       }
772       break;
773
774     case ':': /* Unified fingerprint. */
775       {  
776         const char *se, *si;
777         int i;
778         
779         se = strchr (++s, ':');
780         if (!se)
781           result = PATTERN_UNKNOWN;
782         else
783           {
784             for (i=0, si=s; si < se; si++, i++ )
785               if (!strchr("01234567890abcdefABCDEF", *si))
786                 break;
787             if ( si < se )
788               result = PATTERN_UNKNOWN; /* Invalid digit. */
789             else if (i == 32)
790               result = PATTERN_FINGERPRINT16;
791             else if (i == 40)
792               result = PATTERN_FINGERPRINT20;
793             else
794               result = PATTERN_UNKNOWN; /* Invalid length for a fingerprint. */
795           }
796       } 
797       break;
798
799     case '&': /* Keygrip. */
800       result = PATTERN_UNKNOWN;  /* Not implemented.  */
801       break;
802
803     default:
804       if (s[0] == '0' && s[1] == 'x')
805         {
806           hexprefix = 1;
807           s += 2;
808         }
809
810       hexlength = strspn(s, "0123456789abcdefABCDEF");
811
812       /* Check if a hexadecimal number is terminated by EOS or blank. */
813       if (hexlength && s[hexlength] && !spacep (s+hexlength)) 
814         {
815           /* If the "0x" prefix is used a correct termination is required. */
816           if (hexprefix) 
817             {
818               result = PATTERN_UNKNOWN;   
819               break; /* switch */
820             }
821           hexlength = 0;  /* Not a hex number.  */
822         }
823       
824       if (hexlength == 8 || (!hexprefix && hexlength == 9 && *s == '0'))
825         { 
826           if (hexlength == 9)
827             s++;
828           result = PATTERN_SHORT_KEYID;
829         }
830       else if (hexlength == 16 || (!hexprefix && hexlength == 17 && *s == '0'))
831         { 
832           if (hexlength == 17)
833             s++;
834           result = PATTERN_LONG_KEYID;
835         }
836       else if (hexlength == 32 || (!hexprefix && hexlength == 33 && *s == '0'))
837         { 
838           if (hexlength == 33)
839             s++;
840           result = PATTERN_FINGERPRINT16;
841         }
842       else if (hexlength == 40 || (!hexprefix && hexlength == 41 && *s == '0'))
843         { 
844           if (hexlength == 41)
845             s++;
846           result = PATTERN_FINGERPRINT20;
847         }
848       else if (!hexprefix)
849         { 
850           /* The fingerprints used with X.509 are often delimited by
851              colons, so we try to single this case out. */
852           result = PATTERN_UNKNOWN;
853           hexlength = strspn (s, ":0123456789abcdefABCDEF");
854           if (hexlength == 59 && (!s[hexlength] || spacep (s+hexlength))) 
855             {
856               int i, c;
857
858               for (i=0; i < 20; i++, s += 3) 
859                 {
860                   c = hextobyte(s);
861                   if (c == -1 || (i < 19 && s[2] != ':'))
862                     break;
863                 }
864               if (i == 20)
865                 result = PATTERN_FINGERPRINT20;
866             }
867           if (result == PATTERN_UNKNOWN) /* Default to substring match. */
868             { 
869               result = PATTERN_SUBSTR;
870             }
871         }
872       else /* A hex number with a prefix but with a wrong length.  */
873         result = PATTERN_UNKNOWN;
874     }
875   
876   if (result != PATTERN_UNKNOWN)
877     *r_offset = s - pattern;
878   return result;
879 }
880
881
882
883 /* Given PATTERN, which is a string as used by GnuPG to specify a
884    certificate, return all matching certificates by calling the
885    supplied function RETFNC.  */
886 gpg_error_t
887 get_certs_bypattern (const char *pattern, 
888                      gpg_error_t (*retfnc)(void*,ksba_cert_t),
889                      void *retfnc_data)
890 {
891   gpg_error_t err = GPG_ERR_BUG;
892   enum pattern_class class;
893   size_t offset, sn_offset;
894   const char *hexserialno;
895   ksba_sexp_t serialno = NULL;
896   ksba_cert_t cert = NULL;
897   unsigned int seq;
898
899   if (!pattern || !retfnc)
900     return gpg_error (GPG_ERR_INV_ARG);
901
902   class = classify_pattern (pattern, &offset, &sn_offset);
903   hexserialno = pattern + sn_offset;
904   pattern += offset;
905   switch (class)
906     {
907     case PATTERN_UNKNOWN: 
908       err = gpg_error (GPG_ERR_INV_NAME);
909       break;
910
911     case PATTERN_FINGERPRINT20:
912       cert = get_cert_byhexfpr (pattern);
913       err = cert? 0 : gpg_error (GPG_ERR_NOT_FOUND);
914       break;
915
916     case PATTERN_SERIALNO_ISSUER:
917       serialno = hexsn_to_sexp (hexserialno);
918       if (!serialno)
919         err = gpg_error_from_syserror ();
920       else
921         {
922           cert = get_cert_bysn (pattern, serialno);
923           err = cert? 0 : gpg_error (GPG_ERR_NOT_FOUND);
924         }
925       break;
926
927     case PATTERN_ISSUER:
928       for (seq=0,err=0; !err && (cert = get_cert_byissuer (pattern, seq)); seq++)
929         {
930           err = retfnc (retfnc_data, cert);
931           ksba_cert_release (cert);
932           cert = NULL;
933         }
934       if (!err && !seq)
935         err = gpg_error (GPG_ERR_NOT_FOUND);
936       break;
937
938     case PATTERN_SUBJECT:
939       for (seq=0,err=0; !err && (cert = get_cert_bysubject (pattern, seq));seq++)
940         {
941           err = retfnc (retfnc_data, cert);
942           ksba_cert_release (cert);
943           cert = NULL;
944         }
945       if (!err && !seq)
946         err = gpg_error (GPG_ERR_NOT_FOUND);
947       break;
948       
949     case PATTERN_EMAIL:
950     case PATTERN_EMAIL_SUBSTR:
951     case PATTERN_FINGERPRINT16:
952     case PATTERN_SHORT_KEYID:
953     case PATTERN_LONG_KEYID:
954     case PATTERN_SUBSTR:
955     case PATTERN_SERIALNO:
956       /* Not supported.  */
957       err = gpg_error (GPG_ERR_INV_NAME);
958     }
959
960
961   if (!err && cert)
962     err = retfnc (retfnc_data, cert);
963   ksba_cert_release (cert);
964   xfree (serialno);
965   return err;
966 }
967
968
969
970
971 \f
972 /* Return the certificate matching ISSUER_DN and SERIALNO; if it is
973    not already in the cache, try to find it from other resources.  */
974 ksba_cert_t
975 find_cert_bysn (ctrl_t ctrl, const char *issuer_dn, ksba_sexp_t serialno)
976 {
977   gpg_error_t err;
978   ksba_cert_t cert;
979   cert_fetch_context_t context = NULL;
980   char *hexsn, *buf;
981
982   /* First check whether it has already been cached.  */
983   cert = get_cert_bysn (issuer_dn, serialno);
984   if (cert)
985     return cert;
986
987   /* Ask back to the service requester to return the certificate.
988      This is because we can assume that he already used the
989      certificate while checking for the CRL. */
990   hexsn = serial_hex (serialno);
991   if (!hexsn)
992     {
993       log_error ("serial_hex() failed\n");
994       return NULL;
995     }
996   buf = xtrymalloc (1 + strlen (hexsn) + 1 + strlen (issuer_dn) + 1);
997   if (!buf)
998     {
999       log_error ("can't allocate enough memory: %s\n", strerror (errno));
1000       xfree (hexsn);
1001       return NULL;
1002     }
1003   strcpy (stpcpy (stpcpy (stpcpy (buf, "#"), hexsn),"/"), issuer_dn);
1004   xfree (hexsn);
1005   cert = get_cert_local (ctrl, buf);
1006   xfree (buf);
1007   if (cert)
1008     {
1009       cache_cert (cert);
1010       return cert; /* Done. */
1011     }
1012
1013   if (DBG_LOOKUP)
1014     log_debug ("find_cert_bysn: certificate not returned by caller"
1015                " - doing lookup\n");
1016
1017   /* Retrieve the certificate from external resources. */
1018   while (!cert)
1019     {
1020       ksba_sexp_t sn;
1021       char *issdn;
1022
1023       if (!context)
1024         {
1025           err = ca_cert_fetch (ctrl, &context, issuer_dn);
1026           if (err)
1027             {
1028               log_error (_("error fetching certificate by S/N: %s\n"),
1029                          gpg_strerror (err));
1030               break;
1031             }
1032         }
1033       
1034       err = fetch_next_ksba_cert (context, &cert);
1035       if (err)
1036         {
1037           log_error (_("error fetching certificate by S/N: %s\n"),
1038                      gpg_strerror (err) );
1039           break;
1040         }
1041       
1042       issdn = ksba_cert_get_issuer (cert, 0);
1043       if (strcmp (issuer_dn, issdn))
1044         {
1045           log_debug ("find_cert_bysn: Ooops: issuer DN does not match\n");
1046           ksba_cert_release (cert);
1047           cert = NULL;
1048           ksba_free (issdn);
1049           break; 
1050         }
1051
1052       sn = ksba_cert_get_serial (cert);
1053
1054       if (DBG_LOOKUP)
1055         {
1056           log_debug ("   considering certificate (#");
1057           dump_serial (sn);
1058           log_printf ("/");
1059           dump_string (issdn);
1060           log_printf (")\n");
1061         }
1062
1063       if (!compare_serialno (serialno, sn))
1064         {
1065           ksba_free (sn);
1066           ksba_free (issdn);
1067           cache_cert (cert);
1068           if (DBG_LOOKUP)
1069             log_debug ("   found\n");
1070           break; /* Ready.  */
1071         }
1072
1073       ksba_free (sn);
1074       ksba_free (issdn);
1075       ksba_cert_release (cert);
1076       cert = NULL;
1077     }
1078
1079   end_cert_fetch (context);
1080   return cert;
1081 }
1082
1083
1084 /* Return the certificate matching SUBJECT_DN and (if not NULL)
1085    KEYID. If it is not already in the cache, try to find it from other
1086    resources.  Note, that the external search does not work for user
1087    certificates because the LDAP lookup is on the caCertificate
1088    attribute. For our purposes this is just fine.  */
1089 ksba_cert_t
1090 find_cert_bysubject (ctrl_t ctrl, const char *subject_dn, ksba_sexp_t keyid)
1091 {
1092   gpg_error_t err;
1093   int seq;
1094   ksba_cert_t cert = NULL;
1095   cert_fetch_context_t context = NULL;
1096   ksba_sexp_t subj;
1097
1098   /* If we have certificates from an OCSP request we first try to use
1099      them.  This is because these certificates will really be the
1100      required ones and thus even in the case that they can't be
1101      uniquely located by the following code we can use them.  This is
1102      for example required by Telesec certificates where a keyId is
1103      used but the issuer certificate comes without a subject keyId! */
1104   if (ctrl->ocsp_certs)
1105     {
1106       cert_item_t ci;
1107       cert_ref_t cr;
1108       int i;
1109
1110       /* For efficiency reasons we won't use get_cert_bysubject here. */
1111       acquire_cache_read_lock ();
1112       for (i=0; i < 256; i++)
1113         for (ci=cert_cache[i]; ci; ci = ci->next)
1114           if (ci->cert && ci->subject_dn
1115               && !strcmp (ci->subject_dn, subject_dn))
1116             for (cr=ctrl->ocsp_certs; cr; cr = cr->next)
1117               if (!memcmp (ci->fpr, cr->fpr, 20))
1118                 {
1119                   ksba_cert_ref (ci->cert);
1120                   release_cache_lock ();
1121                   return ci->cert; /* We use this certificate. */
1122                 }
1123       release_cache_lock ();
1124       if (DBG_LOOKUP)
1125         log_debug ("find_cert_bysubject: certificate not in ocsp_certs\n");
1126     }
1127
1128
1129   /* First we check whether the certificate is cached.  */
1130   for (seq=0; (cert = get_cert_bysubject (subject_dn, seq)); seq++)
1131     {
1132       if (!keyid)
1133         break; /* No keyid requested, so return the first one found. */
1134       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj)
1135           && !cmp_simple_canon_sexp (keyid, subj))
1136         {
1137           xfree (subj);
1138           break; /* Found matching cert. */
1139         }
1140       xfree (subj);
1141       ksba_cert_release (cert);
1142     }
1143   if (cert)
1144     return cert; /* Done.  */
1145
1146   if (DBG_LOOKUP)
1147     log_debug ("find_cert_bysubject: certificate not in cache\n");
1148
1149   /* Ask back to the service requester to return the certificate.
1150      This is because we can assume that he already used the
1151      certificate while checking for the CRL. */
1152   if (keyid)
1153     cert = get_cert_local_ski (ctrl, subject_dn, keyid);
1154   else
1155     {
1156       /* In contrast to get_cert_local_ski, get_cert_local uses any
1157          passed pattern, so we need to make sure that an exact subject
1158          search is done. */
1159       char *buf;
1160
1161       buf = xtrymalloc (1 + strlen (subject_dn) + 1);
1162       if (!buf)
1163         {
1164           log_error ("can't allocate enough memory: %s\n", strerror (errno));
1165           return NULL;
1166         }
1167       strcpy (stpcpy (buf, "/"), subject_dn);
1168       cert = get_cert_local (ctrl, buf);
1169       xfree (buf);
1170     }
1171   if (cert)
1172     {
1173       cache_cert (cert);
1174       return cert; /* Done. */
1175     }
1176
1177   if (DBG_LOOKUP)
1178     log_debug ("find_cert_bysubject: certificate not returned by caller"
1179                " - doing lookup\n");
1180
1181   /* Locate the certificate using external resources. */
1182   while (!cert)
1183     {
1184       char *subjdn;
1185
1186       if (!context)
1187         {
1188           err = ca_cert_fetch (ctrl, &context, subject_dn);
1189           if (err)
1190             {
1191               log_error (_("error fetching certificate by subject: %s\n"),
1192                          gpg_strerror (err));
1193               break;
1194             }
1195         }
1196       
1197       err = fetch_next_ksba_cert (context, &cert);
1198       if (err)
1199         {
1200           log_error (_("error fetching certificate by subject: %s\n"),
1201                      gpg_strerror (err) );
1202           break;
1203         }
1204       
1205       subjdn = ksba_cert_get_subject (cert, 0);
1206       if (strcmp (subject_dn, subjdn))
1207         {
1208           log_info ("find_cert_bysubject: subject DN does not match\n");
1209           ksba_cert_release (cert);
1210           cert = NULL;
1211           ksba_free (subjdn);
1212           continue; 
1213         }
1214
1215
1216       if (DBG_LOOKUP)
1217         {
1218           log_debug ("   considering certificate (/");
1219           dump_string (subjdn);
1220           log_printf (")\n");
1221         }
1222       ksba_free (subjdn);
1223
1224       /* If no key ID has been provided, we return the first match.  */
1225       if (!keyid)
1226         {
1227           cache_cert (cert);
1228           if (DBG_LOOKUP)
1229             log_debug ("   found\n");
1230           break; /* Ready.  */
1231         }
1232
1233       /* With the key ID given we need to compare it.  */
1234       if (!ksba_cert_get_subj_key_id (cert, NULL, &subj))
1235         {
1236           if (!cmp_simple_canon_sexp (keyid, subj))
1237             {
1238               ksba_free (subj);
1239               cache_cert (cert);
1240               if (DBG_LOOKUP)
1241                 log_debug ("   found\n");
1242               break; /* Ready.  */
1243             }
1244         }
1245
1246       ksba_free (subj);
1247       ksba_cert_release (cert);
1248       cert = NULL;
1249     }
1250
1251   end_cert_fetch (context);
1252   return cert;
1253 }
1254
1255
1256
1257 /* Return 0 if the certificate is a trusted certificate. Returns
1258    GPG_ERR_NOT_TRUSTED if it is not trusted or other error codes in
1259    case of systems errors. */
1260 gpg_error_t 
1261 is_trusted_cert (ksba_cert_t cert)
1262 {
1263   unsigned char fpr[20];
1264   cert_item_t ci;
1265
1266   cert_compute_fpr (cert, fpr);
1267
1268   acquire_cache_read_lock ();
1269   for (ci=cert_cache[*fpr]; ci; ci = ci->next)
1270     if (ci->cert && !memcmp (ci->fpr, fpr, 20))
1271       {
1272         if (ci->flags.trusted)
1273           {
1274             release_cache_lock ();
1275             return 0; /* Yes, it is trusted. */
1276           }
1277         break;
1278       }
1279
1280   release_cache_lock ();
1281   return gpg_error (GPG_ERR_NOT_TRUSTED);
1282 }
1283
1284
1285 \f
1286 /* Given the certificate CERT locate the issuer for this certificate
1287    and return it at R_CERT.  Returns 0 on success or
1288    GPG_ERR_NOT_FOUND.  */
1289 gpg_error_t
1290 find_issuing_cert (ctrl_t ctrl, ksba_cert_t cert, ksba_cert_t *r_cert)
1291 {
1292   gpg_error_t err;
1293   char *issuer_dn;
1294   ksba_cert_t issuer_cert = NULL;
1295   ksba_name_t authid;
1296   ksba_sexp_t authidno;
1297   ksba_sexp_t keyid;
1298
1299   *r_cert = NULL;
1300
1301   issuer_dn = ksba_cert_get_issuer (cert, 0);
1302   if (!issuer_dn)
1303     {
1304       log_error (_("no issuer found in certificate\n"));
1305       err = gpg_error (GPG_ERR_BAD_CERT);
1306       goto leave;
1307     }
1308
1309   /* First we need to check whether we can return that certificate
1310      using the authorithyKeyIdentifier.  */
1311   err = ksba_cert_get_auth_key_id (cert, &keyid, &authid, &authidno);
1312   if (err)
1313     {
1314       log_info (_("error getting authorityKeyIdentifier: %s\n"),
1315                 gpg_strerror (err));
1316     }
1317   else
1318     {
1319       const char *s = ksba_name_enum (authid, 0);
1320       if (s && *authidno)
1321         {
1322           issuer_cert = find_cert_bysn (ctrl, s, authidno);
1323         }
1324       if (!issuer_cert && keyid)
1325         {
1326           /* Not found by issuer+s/n.  Now that we have an AKI
1327              keyIdentifier look for a certificate with a matching
1328              SKI. */
1329           issuer_cert = find_cert_bysubject (ctrl, issuer_dn, keyid);
1330         }
1331       /* Print a note so that the user does not feel too helpless when
1332          an issuer certificate was found and gpgsm prints BAD
1333          signature because it is not the correct one. */
1334       if (!issuer_cert)
1335         {
1336           log_info ("issuer certificate ");
1337           if (keyid)
1338             {
1339               log_printf ("{");
1340               dump_serial (keyid);
1341               log_printf ("} ");
1342             }
1343           if (authidno)
1344             {
1345               log_printf ("(#");
1346               dump_serial (authidno);
1347               log_printf ("/");
1348               dump_string (s);
1349               log_printf (") ");
1350             }
1351           log_printf ("not found using authorityKeyIdentifier\n");
1352         }
1353       ksba_name_release (authid);
1354       xfree (authidno);
1355       xfree (keyid);
1356     }
1357
1358   /* If this did not work, try just with the issuer's name and assume
1359      that there is only one such certificate.  We only look into our
1360      cache then. */
1361   if (err || !issuer_cert)
1362     {
1363       issuer_cert = get_cert_bysubject (issuer_dn, 0);
1364       if (issuer_cert)
1365         err = 0;
1366     }
1367
1368  leave:  
1369   if (!err && !issuer_cert)
1370     err = gpg_error (GPG_ERR_NOT_FOUND);
1371
1372   xfree (issuer_dn);
1373
1374   if (err)
1375     ksba_cert_release (issuer_cert);
1376   else
1377     *r_cert = issuer_cert;
1378
1379   return err;
1380 }
1381