Adjust for signed integer passed to OpenPGP card decrypt.
[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 = 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 && subject_dn)
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 }