d10e3ca7871db86d6b7f6384849bd149056de2f1
[gnupg.git] / dirmngr / crlcache.c
1 /* crlcache.c - LDAP access
2  * Copyright (C) 2002 Klarälvdalens Datakonsult AB
3  * Copyright (C) 2003, 2004, 2005, 2008 g10 Code GmbH
4  *
5  * This file is part of DirMngr.
6  *
7  * DirMngr is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * DirMngr is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 /*
22
23    1. To keep track of the CRLs actually cached and to store the meta
24       information of the CRLs a simple record oriented text file is
25       used.  Fields in the file are colon (':') separated and values
26       containing colons or linefeeds are percent escaped (e.g. a colon
27       itself is represented as "%3A").
28
29       The first field is a record type identifier, so that the file is
30       useful to keep track of other meta data too.
31
32       The name of the file is "DIR.txt".
33
34
35    1.1. Comment record
36
37         Field 1: Constant beginning with "#".
38
39         Other fields are not defined and such a record is simply
40         skipped during processing.
41
42    1.2. Version record
43
44         Field 1: Constant "v"
45         Field 2: Version number of this file.  Must be 1.
46
47         This record must be the first non-comment record record and
48         there shall only exist one record of this type.
49
50    1.3. CRL cache record
51
52         Field 1: Constant "c", "u" or "i".
53                  A "c" or "u" indicate a valid cache entry, however
54                  "u" requires that a user root certificate check needs
55                  to be done.
56                  An "i" indicates an invalid cache entry which should
57                  not be used but still exists so that it can be
58                  updated at NEXT_UPDATE.
59         Field 2: Hexadecimal encoded SHA-1 hash of the issuer DN using
60                  uppercase letters.
61         Field 3: Issuer DN in RFC-2253 notation.
62         Field 4: URL used to retrieve the corresponding CRL.
63         Field 5: 15 character ISO timestamp with THIS_UPDATE.
64         Field 6: 15 character ISO timestamp with NEXT_UPDATE.
65         Field 7: Hexadecimal encoded MD-5 hash of the DB file to detect
66                  accidental modified (i.e. deleted and created) cache files.
67         Field 8: optional CRL number as a hex string.
68         Field 9:  AuthorityKeyID.issuer, each Name separated by 0x01
69         Field 10: AuthorityKeyID.serial
70         Field 11: Hex fingerprint of trust anchor if field 1 is 'u'.
71
72    2. Layout of the standard CRL Cache DB file:
73
74       We use records of variable length with this structure
75
76       n  bytes  Serialnumber (binary) used as key
77                 thus there is no need to store the length explicitly with DB2.
78       1  byte   Reason for revocation
79                 (currently the KSBA reason flags are used)
80       15 bytes  ISO date of revocation (e.g. 19980815T142000)
81                 Note that there is no terminating 0 stored.
82
83       The filename used is the hexadecimal (using uppercase letters)
84       SHA-1 hash value of the issuer DN prefixed with a "crl-" and
85       suffixed with a ".db".  Thus the length of the filename is 47.
86
87
88 */
89
90 #include <config.h>
91
92 #include <stdio.h>
93 #include <stdlib.h>
94 #include <errno.h>
95 #include <string.h>
96 #include <sys/stat.h>
97 #include <assert.h>
98 #include <dirent.h>
99 #include <fcntl.h>
100 #include <unistd.h>
101 #ifndef HAVE_W32_SYSTEM
102 #include <sys/utsname.h>
103 #endif
104 #ifdef MKDIR_TAKES_ONE_ARG
105 #undef mkdir
106 #define mkdir(a,b) mkdir(a)
107 #endif
108
109 #include "dirmngr.h"
110 #include "validate.h"
111 #include "certcache.h"
112 #include "crlcache.h"
113 #include "crlfetch.h"
114 #include "misc.h"
115 #include "cdb.h"
116
117 /* Change this whenever the format changes */
118 #define DBDIR_D (opt.system_daemon? "crls.d" : "dirmngr-cache.d")
119 #define DBDIRFILE "DIR.txt"
120 #define DBDIRVERSION 1
121
122 /* The number of DB files we may have open at one time.  We need to
123    limit this because there is no guarantee that the number of issuers
124    has a upper limit.  We are currently using mmap, so it is a good
125    idea anyway to limit the number of opened cache files. */
126 #define MAX_OPEN_DB_FILES 5
127
128
129 static const char oidstr_crlNumber[] = "2.5.29.20";
130 static const char oidstr_issuingDistributionPoint[] = "2.5.29.28";
131 static const char oidstr_authorityKeyIdentifier[] = "2.5.29.35";
132
133
134 /* Definition of one cached item. */
135 struct crl_cache_entry_s
136 {
137   struct crl_cache_entry_s *next;
138   int deleted;        /* True if marked for deletion. */
139   int mark;           /* Internally used by update_dir. */
140   unsigned int lineno;/* A 0 indicates a new entry. */
141   char *release_ptr;  /* The actual allocated memory. */
142   char *url;          /* Points into RELEASE_PTR. */
143   char *issuer;       /* Ditto. */
144   char *issuer_hash;  /* Ditto. */
145   char *dbfile_hash;  /* MD5 sum of the cache file, points into RELEASE_PTR.*/
146   int invalid;        /* Can't use this CRL. */
147   int user_trust_req; /* User supplied root certificate required.  */
148   char *check_trust_anchor;  /* Malloced fingerprint.  */
149   ksba_isotime_t this_update;
150   ksba_isotime_t next_update;
151   ksba_isotime_t last_refresh; /* Use for the force_crl_refresh feature. */
152   char *crl_number;
153   char *authority_issuer;
154   char *authority_serialno;
155
156   struct cdb *cdb;             /* The cache file handle or NULL if not open. */
157
158   unsigned int cdb_use_count;  /* Current use count. */
159   unsigned int cdb_lru_count;  /* Used for LRU purposes. */
160   int dbfile_checked;          /* Set to true if the dbfile_hash value has
161                                   been checked one. */
162 };
163
164
165 /* Definition of the entire cache object. */
166 struct crl_cache_s
167 {
168   crl_cache_entry_t entries;
169 };
170
171 typedef struct crl_cache_s *crl_cache_t;
172
173
174 /* Prototypes.  */
175 static crl_cache_entry_t find_entry (crl_cache_entry_t first,
176                                      const char *issuer_hash);
177
178
179
180 /* The currently loaded cache object.  This is usually initialized
181    right at startup.  */
182 static crl_cache_t current_cache;
183
184
185
186
187 \f
188 /* Return the current cache object or bail out if it is has not yet
189    been initialized.  */
190 static crl_cache_t
191 get_current_cache (void)
192 {
193   if (!current_cache)
194     log_fatal ("CRL cache has not yet been initialized\n");
195   return current_cache;
196 }
197
198
199 /*
200    Create ae directory if it does not yet exists.  Returns on
201    success, or -1 on error.
202  */
203 static int
204 create_directory_if_needed (const char *name)
205 {
206   DIR *dir;
207   char *fname;
208
209   fname = make_filename (opt.homedir_cache, name, NULL);
210   dir = opendir (fname);
211   if (!dir)
212     {
213       log_info (_("creating directory '%s'\n"), fname);
214       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR) )
215         {
216           int save_errno = errno;
217           log_error (_("error creating directory '%s': %s\n"),
218                      fname, strerror (errno));
219           xfree (fname);
220           gpg_err_set_errno (save_errno);
221           return -1;
222         }
223     }
224   else
225     closedir (dir);
226   xfree (fname);
227   return 0;
228 }
229
230 /* Remove all files from the cache directory.  If FORCE is not true,
231    some sanity checks on the filenames are done. Return 0 if
232    everything went fine. */
233 static int
234 cleanup_cache_dir (int force)
235 {
236   char *dname = make_filename (opt.homedir_cache, DBDIR_D, NULL);
237   DIR *dir;
238   struct dirent *de;
239   int problem = 0;
240
241   if (!force)
242     { /* Very minor sanity checks. */
243       if (!strcmp (dname, "~/") || !strcmp (dname, "/" ))
244         {
245           log_error (_("ignoring database dir '%s'\n"), dname);
246           xfree (dname);
247           return -1;
248         }
249     }
250
251   dir = opendir (dname);
252   if (!dir)
253     {
254       log_error (_("error reading directory '%s': %s\n"),
255                  dname, strerror (errno));
256       xfree (dname);
257       return -1;
258     }
259
260   while ((de = readdir (dir)))
261     {
262       if (strcmp (de->d_name, "." ) && strcmp (de->d_name, ".."))
263         {
264           char *cdbname = make_filename (dname, de->d_name, NULL);
265           int okay;
266           struct stat sbuf;
267
268           if (force)
269             okay = 1;
270           else
271             okay = (!stat (cdbname, &sbuf) && S_ISREG (sbuf.st_mode));
272
273           if (okay)
274             {
275               log_info (_("removing cache file '%s'\n"), cdbname);
276               if (gnupg_remove (cdbname))
277                 {
278                   log_error ("failed to remove '%s': %s\n",
279                              cdbname, strerror (errno));
280                   problem = -1;
281                 }
282             }
283           else
284             log_info (_("not removing file '%s'\n"), cdbname);
285           xfree (cdbname);
286         }
287     }
288   xfree (dname);
289   closedir (dir);
290   return problem;
291 }
292
293
294 /* Read the next line from the file FP and return the line in an
295    malloced buffer.  Return NULL on error or EOF.  There is no
296    limitation os the line length.  The trailing linefeed has been
297    removed, the function will read the last line of a file, even if
298    that is not terminated by a LF. */
299 static char *
300 next_line_from_file (estream_t fp, gpg_error_t *r_err)
301 {
302   char buf[300];
303   char *largebuf = NULL;
304   size_t buflen;
305   size_t len = 0;
306   unsigned char *p;
307   int c;
308   char *tmpbuf;
309
310   *r_err = 0;
311   p = buf;
312   buflen = sizeof buf - 1;
313   while ((c=es_getc (fp)) != EOF && c != '\n')
314     {
315       if (len >= buflen)
316         {
317           if (!largebuf)
318             {
319               buflen += 1024;
320               largebuf = xtrymalloc ( buflen + 1 );
321               if (!largebuf)
322                 {
323                   *r_err = gpg_error_from_syserror ();
324                   return NULL;
325                 }
326               memcpy (largebuf, buf, len);
327             }
328           else
329             {
330               buflen += 1024;
331               tmpbuf = xtryrealloc (largebuf, buflen + 1);
332               if (!tmpbuf)
333                 {
334                   *r_err = gpg_error_from_syserror ();
335                   xfree (largebuf);
336                   return NULL;
337                 }
338               largebuf = tmpbuf;
339             }
340           p = largebuf;
341         }
342       p[len++] = c;
343     }
344   if (c == EOF && !len)
345     return NULL;
346   p[len] = 0;
347
348   if (largebuf)
349     tmpbuf = xtryrealloc (largebuf, len+1);
350   else
351     tmpbuf = xtrystrdup (buf);
352   if (!tmpbuf)
353     {
354       *r_err = gpg_error_from_syserror ();
355       xfree (largebuf);
356     }
357   return tmpbuf;
358 }
359
360
361 /* Release one cache entry.  */
362 static void
363 release_one_cache_entry (crl_cache_entry_t entry)
364 {
365   if (entry)
366     {
367       if (entry->cdb)
368         {
369           int fd = cdb_fileno (entry->cdb);
370           cdb_free (entry->cdb);
371           xfree (entry->cdb);
372           if (close (fd))
373             log_error (_("error closing cache file: %s\n"), strerror(errno));
374         }
375       xfree (entry->release_ptr);
376       xfree (entry->check_trust_anchor);
377       xfree (entry);
378     }
379 }
380
381
382 /* Release the CACHE object. */
383 static void
384 release_cache (crl_cache_t cache)
385 {
386   crl_cache_entry_t entry, entry2;
387
388   if (!cache)
389     return;
390
391   for (entry = cache->entries; entry; entry = entry2)
392     {
393       entry2 = entry->next;
394       release_one_cache_entry (entry);
395     }
396   cache->entries = NULL;
397   xfree (cache);
398 }
399
400
401 /* Open the dir file FNAME or create a new one if it does not yet
402    exist. */
403 static estream_t
404 open_dir_file (const char *fname)
405 {
406   estream_t fp;
407
408   fp = es_fopen (fname, "r");
409   if (!fp)
410     {
411       log_error (_("failed to open cache dir file '%s': %s\n"),
412                  fname, strerror (errno));
413
414       /* Make sure that the directory exists, try to create if otherwise. */
415       if (create_directory_if_needed (NULL)
416           || create_directory_if_needed (DBDIR_D))
417         return NULL;
418       fp = es_fopen (fname, "w");
419       if (!fp)
420         {
421           log_error (_("error creating new cache dir file '%s': %s\n"),
422                      fname, strerror (errno));
423           return NULL;
424         }
425       es_fprintf (fp, "v:%d:\n", DBDIRVERSION);
426       if (es_ferror (fp))
427         {
428           log_error (_("error writing new cache dir file '%s': %s\n"),
429                      fname, strerror (errno));
430           es_fclose (fp);
431           return NULL;
432         }
433       if (es_fclose (fp))
434         {
435           log_error (_("error closing new cache dir file '%s': %s\n"),
436                      fname, strerror (errno));
437           return NULL;
438         }
439
440       log_info (_("new cache dir file '%s' created\n"), fname);
441
442       fp = es_fopen (fname, "r");
443       if (!fp)
444         {
445           log_error (_("failed to re-open cache dir file '%s': %s\n"),
446                      fname, strerror (errno));
447           return NULL;
448         }
449     }
450
451   return fp;
452 }
453
454 /* Helper for open_dir. */
455 static gpg_error_t
456 check_dir_version (estream_t *fpadr, const char *fname,
457                          unsigned int *lineno,
458                          int cleanup_on_mismatch)
459 {
460   char *line;
461   gpg_error_t lineerr = 0;
462   estream_t fp = *fpadr;
463   int created = 0;
464
465  retry:
466   while ((line = next_line_from_file (fp, &lineerr)))
467     {
468       ++*lineno;
469       if (*line == 'v' && line[1] == ':')
470         break;
471       else if (*line != '#')
472         {
473           log_error (_("first record of '%s' is not the version\n"), fname);
474           xfree (line);
475           return gpg_error (GPG_ERR_CONFIGURATION);
476         }
477       xfree (line);
478     }
479   if (lineerr)
480     return lineerr;
481
482   if (strtol (line+2, NULL, 10) != DBDIRVERSION)
483     {
484       if (!created && cleanup_on_mismatch)
485         {
486           log_error (_("old version of cache directory - cleaning up\n"));
487           es_fclose (fp);
488           *fpadr = NULL;
489           if (!cleanup_cache_dir (1))
490             {
491               *lineno = 0;
492               fp = *fpadr = open_dir_file (fname);
493               if (!fp)
494                 {
495                   xfree (line);
496                   return gpg_error (GPG_ERR_CONFIGURATION);
497                 }
498               created = 1;
499               goto retry;
500             }
501         }
502       log_error (_("old version of cache directory - giving up\n"));
503       xfree (line);
504       return gpg_error (GPG_ERR_CONFIGURATION);
505     }
506   xfree (line);
507   return 0;
508 }
509
510
511 /* Open the dir file and read in all available information.  Store
512    that in a newly allocated cache object and return that if
513    everything worked out fine.  Create the cache directory and the dir
514    if it does not yet exist.  Remove all files in that directory if
515    the version does not match. */
516 static gpg_error_t
517 open_dir (crl_cache_t *r_cache)
518 {
519   crl_cache_t cache;
520   char *fname;
521   char *line = NULL;
522   gpg_error_t lineerr = 0;
523   estream_t fp;
524   crl_cache_entry_t entry, *entrytail;
525   unsigned int lineno;
526   gpg_error_t err = 0;
527   int anyerr = 0;
528
529   cache = xtrycalloc (1, sizeof *cache);
530   if (!cache)
531     return gpg_error_from_syserror ();
532
533   fname = make_filename (opt.homedir_cache, DBDIR_D, DBDIRFILE, NULL);
534
535   lineno = 0;
536   fp = open_dir_file (fname);
537   if (!fp)
538     {
539       err = gpg_error (GPG_ERR_CONFIGURATION);
540       goto leave;
541     }
542
543   err = check_dir_version (&fp, fname, &lineno, 1);
544   if (err)
545     goto leave;
546
547
548   /* Read in all supported entries from the dir file. */
549   cache->entries = NULL;
550   entrytail = &cache->entries;
551   xfree (line);
552   while ((line = next_line_from_file (fp, &lineerr)))
553     {
554       int fieldno;
555       char *p, *endp;
556
557       lineno++;
558       if ( *line == 'c' || *line == 'u' || *line == 'i' )
559         {
560           entry = xtrycalloc (1, sizeof *entry);
561           if (!entry)
562             {
563               err = gpg_error_from_syserror ();
564               goto leave;
565             }
566           entry->lineno = lineno;
567           entry->release_ptr = line;
568           if (*line == 'i')
569             {
570               entry->invalid = atoi (line+1);
571               if (entry->invalid < 1)
572                 entry->invalid = 1;
573             }
574           else if (*line == 'u')
575             entry->user_trust_req = 1;
576
577           for (fieldno=1, p = line; p; p = endp, fieldno++)
578             {
579               endp = strchr (p, ':');
580               if (endp)
581                 *endp++ = '\0';
582
583               switch (fieldno)
584                 {
585                 case 1: /* record type */ break;
586                 case 2: entry->issuer_hash = p; break;
587                 case 3: entry->issuer = unpercent_string (p); break;
588                 case 4: entry->url = unpercent_string (p); break;
589                 case 5:
590                   strncpy (entry->this_update, p, 15);
591                   entry->this_update[15] = 0;
592                   break;
593                 case 6:
594                   strncpy (entry->next_update, p, 15);
595                   entry->next_update[15] = 0;
596                   break;
597                 case 7: entry->dbfile_hash = p; break;
598                 case 8: if (*p) entry->crl_number = p; break;
599                 case 9:
600                   if (*p)
601                     entry->authority_issuer = unpercent_string (p);
602                   break;
603                 case 10:
604                   if (*p)
605                     entry->authority_serialno = unpercent_string (p);
606                   break;
607                 case 11:
608                   if (*p)
609                     entry->check_trust_anchor = xtrystrdup (p);
610                   break;
611                 default:
612                   if (*p)
613                     log_info (_("extra field detected in crl record of "
614                                 "'%s' line %u\n"), fname, lineno);
615                   break;
616                 }
617             }
618
619           if (!entry->issuer_hash)
620             {
621               log_info (_("invalid line detected in '%s' line %u\n"),
622                         fname, lineno);
623               xfree (entry);
624               entry = NULL;
625             }
626           else if (find_entry (cache->entries, entry->issuer_hash))
627             {
628               /* Fixme: The duplicate checking used is not very
629                  effective for large numbers of issuers. */
630               log_info (_("duplicate entry detected in '%s' line %u\n"),
631                         fname, lineno);
632               xfree (entry);
633               entry = NULL;
634             }
635           else
636             {
637               line = NULL;
638               *entrytail = entry;
639               entrytail = &entry->next;
640             }
641         }
642       else if (*line == '#')
643         ;
644       else
645         log_info (_("unsupported record type in '%s' line %u skipped\n"),
646                   fname, lineno);
647
648       if (line)
649         xfree (line);
650     }
651   if (lineerr)
652     {
653       err = lineerr;
654       log_error (_("error reading '%s': %s\n"), fname, gpg_strerror (err));
655       goto leave;
656     }
657   if (es_ferror (fp))
658     {
659       log_error (_("error reading '%s': %s\n"), fname, strerror (errno));
660       err = gpg_error (GPG_ERR_CONFIGURATION);
661       goto leave;
662     }
663
664   /* Now do some basic checks on the data. */
665   for (entry = cache->entries; entry; entry = entry->next)
666     {
667       assert (entry->lineno);
668       if (strlen (entry->issuer_hash) != 40)
669         {
670           anyerr++;
671           log_error (_("invalid issuer hash in '%s' line %u\n"),
672                      fname, entry->lineno);
673         }
674       else if ( !*entry->issuer )
675         {
676           anyerr++;
677           log_error (_("no issuer DN in '%s' line %u\n"),
678                      fname, entry->lineno);
679         }
680       else if ( check_isotime (entry->this_update)
681                 || check_isotime (entry->next_update))
682         {
683           anyerr++;
684           log_error (_("invalid timestamp in '%s' line %u\n"),
685                      fname, entry->lineno);
686         }
687
688       /* Checks not leading to an immediate fail. */
689       if (strlen (entry->dbfile_hash) != 32)
690         log_info (_("WARNING: invalid cache file hash in '%s' line %u\n"),
691                   fname, entry->lineno);
692     }
693
694   if (anyerr)
695     {
696       log_error (_("detected errors in cache dir file\n"));
697       log_info (_("please check the reason and manually delete that file\n"));
698       err = gpg_error (GPG_ERR_CONFIGURATION);
699     }
700
701
702  leave:
703   es_fclose (fp);
704   xfree (line);
705   xfree (fname);
706   if (err)
707     {
708       release_cache (cache);
709       cache = NULL;
710     }
711   *r_cache = cache;
712   return err;
713 }
714
715 static void
716 write_percented_string (const char *s, estream_t fp)
717 {
718   for (; *s; s++)
719     if (*s == ':')
720       es_fputs ("%3A", fp);
721     else if (*s == '\n')
722       es_fputs ("%0A", fp);
723     else if (*s == '\r')
724       es_fputs ("%0D", fp);
725     else
726       es_putc (*s, fp);
727 }
728
729
730 static void
731 write_dir_line_crl (estream_t fp, crl_cache_entry_t e)
732 {
733   if (e->invalid)
734     es_fprintf (fp, "i%d", e->invalid);
735   else if (e->user_trust_req)
736     es_putc ('u', fp);
737   else
738     es_putc ('c', fp);
739   es_putc (':', fp);
740   es_fputs (e->issuer_hash, fp);
741   es_putc (':', fp);
742   write_percented_string (e->issuer, fp);
743   es_putc (':', fp);
744   write_percented_string (e->url, fp);
745   es_putc (':', fp);
746   es_fwrite (e->this_update, 15, 1, fp);
747   es_putc (':', fp);
748   es_fwrite (e->next_update, 15, 1, fp);
749   es_putc (':', fp);
750   es_fputs (e->dbfile_hash, fp);
751   es_putc (':', fp);
752   if (e->crl_number)
753     es_fputs (e->crl_number, fp);
754   es_putc (':', fp);
755   if (e->authority_issuer)
756     write_percented_string (e->authority_issuer, fp);
757   es_putc (':', fp);
758   if (e->authority_serialno)
759     es_fputs (e->authority_serialno, fp);
760   es_putc (':', fp);
761   if (e->check_trust_anchor && e->user_trust_req)
762     es_fputs (e->check_trust_anchor, fp);
763   es_putc ('\n', fp);
764 }
765
766
767 /* Update the current dir file using the cache. */
768 static gpg_error_t
769 update_dir (crl_cache_t cache)
770 {
771   char *fname = NULL;
772   char *tmpfname = NULL;
773   char *line = NULL;
774   gpg_error_t lineerr = 0;
775   estream_t fp;
776   estream_t fpout = NULL;
777   crl_cache_entry_t e;
778   unsigned int lineno;
779   gpg_error_t err = 0;
780
781   fname = make_filename (opt.homedir_cache, DBDIR_D, DBDIRFILE, NULL);
782
783   /* Fixme: Take an update file lock here. */
784
785   for (e= cache->entries; e; e = e->next)
786     e->mark = 1;
787
788   lineno = 0;
789   fp = es_fopen (fname, "r");
790   if (!fp)
791     {
792       err = gpg_error_from_errno (errno);
793       log_error (_("failed to open cache dir file '%s': %s\n"),
794                  fname, strerror (errno));
795       goto leave;
796     }
797   err = check_dir_version (&fp, fname, &lineno, 0);
798   if (err)
799     goto leave;
800   es_rewind (fp);
801   lineno = 0;
802
803   /* Create a temporary DIR file. */
804   {
805     char *tmpbuf, *p;
806     const char *nodename;
807 #ifndef HAVE_W32_SYSTEM
808     struct utsname utsbuf;
809 #endif
810
811 #ifdef HAVE_W32_SYSTEM
812     nodename = "unknown";
813 #else
814     if (uname (&utsbuf))
815       nodename = "unknown";
816     else
817       nodename = utsbuf.nodename;
818 #endif
819
820     gpgrt_asprintf (&tmpbuf, "DIR-tmp-%s-%u-%p.txt.tmp",
821                     nodename, (unsigned int)getpid (), &tmpbuf);
822     if (!tmpbuf)
823       {
824         err = gpg_error_from_errno (errno);
825         log_error (_("failed to create temporary cache dir file '%s': %s\n"),
826                    tmpfname, strerror (errno));
827         goto leave;
828       }
829     for (p=tmpbuf; *p; p++)
830       if (*p == '/')
831         *p = '.';
832     tmpfname = make_filename (opt.homedir_cache, DBDIR_D, tmpbuf, NULL);
833     xfree (tmpbuf);
834   }
835   fpout = es_fopen (tmpfname, "w");
836   if (!fpout)
837     {
838       err = gpg_error_from_errno (errno);
839       log_error (_("failed to create temporary cache dir file '%s': %s\n"),
840                  tmpfname, strerror (errno));
841       goto leave;
842     }
843
844   while ((line = next_line_from_file (fp, &lineerr)))
845     {
846       lineno++;
847       if (*line == 'c' || *line == 'u' || *line == 'i')
848         {
849           /* Extract the issuer hash field. */
850           char *fieldp, *endp;
851
852           fieldp = strchr (line, ':');
853           endp = fieldp? strchr (++fieldp, ':') : NULL;
854           if (endp)
855             {
856               /* There should be no percent within the issuer hash
857                  field, thus we can compare it pretty easily. */
858               *endp = 0;
859               e = find_entry ( cache->entries, fieldp);
860               *endp = ':'; /* Restore orginal line. */
861               if (e && e->deleted)
862                 {
863                   /* Marked for deletion, so don't write it. */
864                   e->mark = 0;
865                 }
866               else if (e)
867                 {
868                   /* Yep, this is valid entry we know about; write it out */
869                   write_dir_line_crl (fpout, e);
870                   e->mark = 0;
871                 }
872               else
873                 { /* We ignore entries we don't have in our cache
874                      because they may have been added in the meantime
875                      by other instances of dirmngr. */
876                   es_fprintf (fpout, "# Next line added by "
877                               "another process; our pid is %lu\n",
878                               (unsigned long)getpid ());
879                   es_fputs (line, fpout);
880                   es_putc ('\n', fpout);
881                 }
882             }
883           else
884             {
885               es_fputs ("# Invalid line detected: ", fpout);
886               es_fputs (line, fpout);
887               es_putc ('\n', fpout);
888             }
889         }
890       else
891         {
892           /* Write out all non CRL lines as they are. */
893           es_fputs (line, fpout);
894           es_putc ('\n', fpout);
895         }
896
897       xfree (line);
898     }
899   if (!es_ferror (fp) && !es_ferror (fpout) && !lineerr)
900     {
901       /* Write out the remaining entries. */
902       for (e= cache->entries; e; e = e->next)
903         if (e->mark)
904           {
905             if (!e->deleted)
906               write_dir_line_crl (fpout, e);
907             e->mark = 0;
908           }
909     }
910   if (lineerr)
911     {
912       err = lineerr;
913       log_error (_("error reading '%s': %s\n"), fname, gpg_strerror (err));
914       goto leave;
915     }
916   if (es_ferror (fp))
917     {
918       err = gpg_error_from_errno (errno);
919       log_error (_("error reading '%s': %s\n"), fname, strerror (errno));
920     }
921   if (es_ferror (fpout))
922     {
923       err = gpg_error_from_errno (errno);
924       log_error (_("error writing '%s': %s\n"), tmpfname, strerror (errno));
925     }
926   if (err)
927     goto leave;
928
929   /* Rename the files. */
930   es_fclose (fp);
931   fp = NULL;
932   if (es_fclose (fpout))
933     {
934       err = gpg_error_from_errno (errno);
935       log_error (_("error closing '%s': %s\n"), tmpfname, strerror (errno));
936       goto leave;
937     }
938   fpout = NULL;
939
940 #ifdef HAVE_W32_SYSTEM
941   /* No atomic mv on W32 systems.  */
942   gnupg_remove (fname);
943 #endif
944   if (rename (tmpfname, fname))
945     {
946       err = gpg_error_from_errno (errno);
947       log_error (_("error renaming '%s' to '%s': %s\n"),
948                  tmpfname, fname, strerror (errno));
949       goto leave;
950     }
951
952  leave:
953   /* Fixme: Relinquish update lock. */
954   xfree (line);
955   es_fclose (fp);
956   xfree (fname);
957   if (fpout)
958     {
959       es_fclose (fpout);
960       if (err && tmpfname)
961         gnupg_remove (tmpfname);
962     }
963   xfree (tmpfname);
964   return err;
965 }
966
967
968
969
970 /* Create the filename for the cache file from the 40 byte ISSUER_HASH
971    string. Caller must release the return string. */
972 static char *
973 make_db_file_name (const char *issuer_hash)
974 {
975   char bname[50];
976
977   assert (strlen (issuer_hash) == 40);
978   memcpy (bname, "crl-", 4);
979   memcpy (bname + 4, issuer_hash, 40);
980   strcpy (bname + 44, ".db");
981   return make_filename (opt.homedir_cache, DBDIR_D, bname, NULL);
982 }
983
984
985 /* Hash the file FNAME and return the MD5 digest in MD5BUFFER. The
986    caller must allocate MD%buffer wityh at least 16 bytes. Returns 0
987    on success. */
988 static int
989 hash_dbfile (const char *fname, unsigned char *md5buffer)
990 {
991   estream_t fp;
992   char *buffer;
993   size_t n;
994   gcry_md_hd_t md5;
995   gpg_err_code_t err;
996
997   buffer = xtrymalloc (65536);
998   fp = buffer? es_fopen (fname, "rb") : NULL;
999   if (!fp)
1000     {
1001       log_error (_("can't hash '%s': %s\n"), fname, strerror (errno));
1002       xfree (buffer);
1003       return -1;
1004     }
1005
1006   err = gcry_md_open (&md5, GCRY_MD_MD5, 0);
1007   if (err)
1008     {
1009       log_error (_("error setting up MD5 hash context: %s\n"),
1010                  gpg_strerror (err));
1011       xfree (buffer);
1012       es_fclose (fp);
1013       return -1;
1014     }
1015
1016   /* We better hash some information about the cache file layout in. */
1017   sprintf (buffer, "%.100s/%.100s:%d", DBDIR_D, DBDIRFILE, DBDIRVERSION);
1018   gcry_md_write (md5, buffer, strlen (buffer));
1019
1020   for (;;)
1021     {
1022       n = es_fread (buffer, 1, 65536, fp);
1023       if (n < 65536 && es_ferror (fp))
1024         {
1025           log_error (_("error hashing '%s': %s\n"), fname, strerror (errno));
1026           xfree (buffer);
1027           es_fclose (fp);
1028           gcry_md_close (md5);
1029           return -1;
1030         }
1031       if (!n)
1032         break;
1033       gcry_md_write (md5, buffer, n);
1034     }
1035   es_fclose (fp);
1036   xfree (buffer);
1037   gcry_md_final (md5);
1038
1039   memcpy (md5buffer, gcry_md_read (md5, GCRY_MD_MD5), 16);
1040   gcry_md_close (md5);
1041   return 0;
1042 }
1043
1044 /* Compare the file FNAME against the dexified MD5 hash MD5HASH and
1045    return 0 if they match. */
1046 static int
1047 check_dbfile (const char *fname, const char *md5hexvalue)
1048 {
1049   unsigned char buffer1[16], buffer2[16];
1050
1051   if (strlen (md5hexvalue) != 32)
1052     {
1053       log_error (_("invalid formatted checksum for '%s'\n"), fname);
1054       return -1;
1055     }
1056   unhexify (buffer1, md5hexvalue);
1057
1058   if (hash_dbfile (fname, buffer2))
1059     return -1;
1060
1061   return memcmp (buffer1, buffer2, 16);
1062 }
1063
1064
1065 /* Open the cache file for ENTRY.  This function implements a caching
1066    strategy and might close unused cache files. It is required to use
1067    unlock_db_file after using the file. */
1068 static struct cdb *
1069 lock_db_file (crl_cache_t cache, crl_cache_entry_t entry)
1070 {
1071   char *fname;
1072   int fd;
1073   int open_count;
1074   crl_cache_entry_t e;
1075
1076   if (entry->cdb)
1077     {
1078       entry->cdb_use_count++;
1079       return entry->cdb;
1080     }
1081
1082   for (open_count = 0, e = cache->entries; e; e = e->next)
1083     {
1084       if (e->cdb)
1085         open_count++;
1086 /*       log_debug ("CACHE: cdb=%p use_count=%u lru_count=%u\n", */
1087 /*                  e->cdb,e->cdb_use_count,e->cdb_lru_count); */
1088     }
1089
1090   /* If there are too many file open, find the least recent used DB
1091      file and close it.  Note that for Pth thread safeness we need to
1092      use a loop here. */
1093   while (open_count >= MAX_OPEN_DB_FILES )
1094     {
1095       crl_cache_entry_t last_e = NULL;
1096       unsigned int last_lru = (unsigned int)(-1);
1097
1098       for (e = cache->entries; e; e = e->next)
1099         if (e->cdb && !e->cdb_use_count && e->cdb_lru_count < last_lru)
1100           {
1101             last_lru = e->cdb_lru_count;
1102             last_e = e;
1103           }
1104       if (!last_e)
1105         {
1106           log_error (_("too many open cache files; can't open anymore\n"));
1107           return NULL;
1108         }
1109
1110 /*       log_debug ("CACHE: closing file at cdb=%p\n", last_e->cdb); */
1111
1112       fd = cdb_fileno (last_e->cdb);
1113       cdb_free (last_e->cdb);
1114       xfree (last_e->cdb);
1115       last_e->cdb = NULL;
1116       if (close (fd))
1117         log_error (_("error closing cache file: %s\n"), strerror(errno));
1118       open_count--;
1119     }
1120
1121
1122   fname = make_db_file_name (entry->issuer_hash);
1123   if (opt.verbose)
1124     log_info (_("opening cache file '%s'\n"), fname );
1125
1126   if (!entry->dbfile_checked)
1127     {
1128       if (!check_dbfile (fname, entry->dbfile_hash))
1129         entry->dbfile_checked = 1;
1130       /* Note, in case of an error we don't print an error here but
1131          let require the caller to do that check. */
1132     }
1133
1134   entry->cdb = xtrycalloc (1, sizeof *entry->cdb);
1135   if (!entry->cdb)
1136     {
1137       xfree (fname);
1138       return NULL;
1139     }
1140   fd = open (fname, O_RDONLY);
1141   if (fd == -1)
1142     {
1143       log_error (_("error opening cache file '%s': %s\n"),
1144                  fname, strerror (errno));
1145       xfree (entry->cdb);
1146       entry->cdb = NULL;
1147       xfree (fname);
1148       return NULL;
1149     }
1150   if (cdb_init (entry->cdb, fd))
1151     {
1152       log_error (_("error initializing cache file '%s' for reading: %s\n"),
1153                  fname, strerror (errno));
1154       xfree (entry->cdb);
1155       entry->cdb = NULL;
1156       close (fd);
1157       xfree (fname);
1158       return NULL;
1159     }
1160   xfree (fname);
1161
1162   entry->cdb_use_count = 1;
1163   entry->cdb_lru_count = 0;
1164
1165   return entry->cdb;
1166 }
1167
1168 /* Unlock a cache file, so that it can be reused. */
1169 static void
1170 unlock_db_file (crl_cache_t cache, crl_cache_entry_t entry)
1171 {
1172   if (!entry->cdb)
1173     log_error (_("calling unlock_db_file on a closed file\n"));
1174   else if (!entry->cdb_use_count)
1175     log_error (_("calling unlock_db_file on an unlocked file\n"));
1176   else
1177     {
1178       entry->cdb_use_count--;
1179       entry->cdb_lru_count++;
1180     }
1181
1182   /* If the entry was marked for deletion in the meantime do it now.
1183      We do this for the sake of Pth thread safeness. */
1184   if (!entry->cdb_use_count && entry->deleted)
1185     {
1186       crl_cache_entry_t eprev, enext;
1187
1188       enext = entry->next;
1189       for (eprev = cache->entries;
1190            eprev && eprev->next != entry; eprev = eprev->next)
1191         ;
1192       assert (eprev);
1193       if (eprev == cache->entries)
1194         cache->entries = enext;
1195       else
1196         eprev->next = enext;
1197       /* FIXME: Do we leak ENTRY? */
1198     }
1199 }
1200
1201
1202 /* Find ISSUER_HASH in our cache FIRST. This may be used to enumerate
1203    the linked list we use to keep the CRLs of an issuer. */
1204 static crl_cache_entry_t
1205 find_entry (crl_cache_entry_t first, const char *issuer_hash)
1206 {
1207   while (first && (first->deleted || strcmp (issuer_hash, first->issuer_hash)))
1208     first = first->next;
1209   return first;
1210 }
1211
1212
1213 /* Create a new CRL cache. This fucntion is usually called only once.
1214    never fail. */
1215 void
1216 crl_cache_init(void)
1217 {
1218   crl_cache_t cache = NULL;
1219   gpg_error_t err;
1220
1221   if (current_cache)
1222     {
1223       log_error ("crl cache has already been initialized - not doing twice\n");
1224       return;
1225     }
1226
1227   err = open_dir (&cache);
1228   if (err)
1229     log_fatal (_("failed to create a new cache object: %s\n"),
1230                gpg_strerror (err));
1231   current_cache = cache;
1232 }
1233
1234
1235 /* Remove the cache information and all its resources.  Note that we
1236    still keep the cache on disk. */
1237 void
1238 crl_cache_deinit (void)
1239 {
1240   if (current_cache)
1241     {
1242       release_cache (current_cache);
1243       current_cache = NULL;
1244     }
1245 }
1246
1247
1248 /* Delete the cache from disk. Return 0 on success.*/
1249 int
1250 crl_cache_flush (void)
1251 {
1252   int rc;
1253
1254   rc = cleanup_cache_dir (0)? -1 : 0;
1255
1256   return rc;
1257 }
1258
1259
1260 /* Check whether the certificate identified by ISSUER_HASH and
1261    SN/SNLEN is valid; i.e. not listed in our cache.  With
1262    FORCE_REFRESH set to true, a new CRL will be retrieved even if the
1263    cache has not yet expired.  We use a 30 minutes threshold here so
1264    that invoking this function several times won't load the CRL over
1265    and over.  */
1266 static crl_cache_result_t
1267 cache_isvalid (ctrl_t ctrl, const char *issuer_hash,
1268                const unsigned char *sn, size_t snlen,
1269                int force_refresh)
1270 {
1271   crl_cache_t cache = get_current_cache ();
1272   crl_cache_result_t retval;
1273   struct cdb *cdb;
1274   int rc;
1275   crl_cache_entry_t entry;
1276   gnupg_isotime_t current_time;
1277   size_t n;
1278
1279   (void)ctrl;
1280
1281   entry = find_entry (cache->entries, issuer_hash);
1282   if (!entry)
1283     {
1284       log_info (_("no CRL available for issuer id %s\n"), issuer_hash );
1285       return CRL_CACHE_DONTKNOW;
1286     }
1287
1288   gnupg_get_isotime (current_time);
1289   if (strcmp (entry->next_update, current_time) < 0 )
1290     {
1291       log_info (_("cached CRL for issuer id %s too old; update required\n"),
1292                 issuer_hash);
1293       return CRL_CACHE_DONTKNOW;
1294     }
1295   if (force_refresh)
1296     {
1297       gnupg_isotime_t tmptime;
1298
1299       if (*entry->last_refresh)
1300         {
1301           gnupg_copy_time (tmptime, entry->last_refresh);
1302           add_seconds_to_isotime (tmptime, 30 * 60);
1303           if (strcmp (tmptime, current_time) < 0 )
1304             {
1305               log_info (_("force-crl-refresh active and %d minutes passed for"
1306                           " issuer id %s; update required\n"),
1307                         30, issuer_hash);
1308               return CRL_CACHE_DONTKNOW;
1309             }
1310         }
1311       else
1312         {
1313           log_info (_("force-crl-refresh active for"
1314                       " issuer id %s; update required\n"),
1315                     issuer_hash);
1316           return CRL_CACHE_DONTKNOW;
1317         }
1318     }
1319
1320   if (entry->invalid)
1321     {
1322       log_info (_("available CRL for issuer ID %s can't be used\n"),
1323                 issuer_hash);
1324       return CRL_CACHE_CANTUSE;
1325     }
1326
1327   cdb = lock_db_file (cache, entry);
1328   if (!cdb)
1329     return CRL_CACHE_DONTKNOW; /* Hmmm, not the best error code. */
1330
1331   if (!entry->dbfile_checked)
1332     {
1333       log_error (_("cached CRL for issuer id %s tampered; we need to update\n")
1334                  , issuer_hash);
1335       unlock_db_file (cache, entry);
1336       return CRL_CACHE_DONTKNOW;
1337     }
1338
1339   rc = cdb_find (cdb, sn, snlen);
1340   if (rc == 1)
1341     {
1342       n = cdb_datalen (cdb);
1343       if (n != 16)
1344         {
1345           log_error (_("WARNING: invalid cache record length for S/N "));
1346           log_printhex ("", sn, snlen);
1347         }
1348       else if (opt.verbose)
1349         {
1350           unsigned char record[16];
1351           char *tmp = hexify_data (sn, snlen);
1352
1353           if (cdb_read (cdb, record, n, cdb_datapos (cdb)))
1354             log_error (_("problem reading cache record for S/N %s: %s\n"),
1355                        tmp, strerror (errno));
1356           else
1357             log_info (_("S/N %s is not valid; reason=%02X  date=%.15s\n"),
1358                       tmp, *record, record+1);
1359           xfree (tmp);
1360         }
1361       retval = CRL_CACHE_INVALID;
1362     }
1363   else if (!rc)
1364     {
1365       if (opt.verbose)
1366         {
1367           char *serialno = hexify_data (sn, snlen);
1368           log_info (_("S/N %s is valid, it is not listed in the CRL\n"),
1369                     serialno );
1370           xfree (serialno);
1371         }
1372       retval = CRL_CACHE_VALID;
1373     }
1374   else
1375     {
1376       log_error (_("error getting data from cache file: %s\n"),
1377                  strerror (errno));
1378       retval = CRL_CACHE_DONTKNOW;
1379     }
1380
1381
1382   if (entry->user_trust_req
1383       && (retval == CRL_CACHE_VALID || retval == CRL_CACHE_INVALID))
1384     {
1385       if (!entry->check_trust_anchor)
1386         {
1387           log_error ("inconsistent data on user trust check\n");
1388           retval = CRL_CACHE_CANTUSE;
1389         }
1390       else if (get_istrusted_from_client (ctrl, entry->check_trust_anchor))
1391         {
1392           if (opt.verbose)
1393             log_info ("no system trust and client does not trust either\n");
1394           retval = CRL_CACHE_CANTUSE;
1395         }
1396       else
1397         {
1398           /* Okay, the CRL is considered valid by the client and thus
1399              we can return the result as is.  */
1400         }
1401     }
1402
1403   unlock_db_file (cache, entry);
1404
1405   return retval;
1406 }
1407
1408
1409 /* Check whether the certificate identified by ISSUER_HASH and
1410    SERIALNO is valid; i.e. not listed in our cache.  With
1411    FORCE_REFRESH set to true, a new CRL will be retrieved even if the
1412    cache has not yet expired.  We use a 30 minutes threshold here so
1413    that invoking this function several times won't load the CRL over
1414    and over.  */
1415 crl_cache_result_t
1416 crl_cache_isvalid (ctrl_t ctrl, const char *issuer_hash, const char *serialno,
1417                    int force_refresh)
1418 {
1419   crl_cache_result_t result;
1420   unsigned char snbuf_buffer[50];
1421   unsigned char *snbuf;
1422   size_t n;
1423
1424   n = strlen (serialno)/2+1;
1425   if (n < sizeof snbuf_buffer - 1)
1426     snbuf = snbuf_buffer;
1427   else
1428     {
1429       snbuf = xtrymalloc (n);
1430       if (!snbuf)
1431         return CRL_CACHE_DONTKNOW;
1432     }
1433
1434   n = unhexify (snbuf, serialno);
1435
1436   result = cache_isvalid (ctrl, issuer_hash, snbuf, n, force_refresh);
1437
1438   if (snbuf != snbuf_buffer)
1439     xfree (snbuf);
1440
1441   return result;
1442 }
1443
1444
1445 /* Check whether the certificate CERT is valid; i.e. not listed in our
1446    cache.  With FORCE_REFRESH set to true, a new CRL will be retrieved
1447    even if the cache has not yet expired.  We use a 30 minutes
1448    threshold here so that invoking this function several times won't
1449    load the CRL over and over.  */
1450 gpg_error_t
1451 crl_cache_cert_isvalid (ctrl_t ctrl, ksba_cert_t cert,
1452                         int force_refresh)
1453 {
1454   gpg_error_t err;
1455   crl_cache_result_t result;
1456   unsigned char issuerhash[20];
1457   char issuerhash_hex[41];
1458   ksba_sexp_t serial;
1459   unsigned char *sn;
1460   size_t snlen;
1461   char *endp, *tmp;
1462   int i;
1463
1464   /* Compute the hash value of the issuer name.  */
1465   tmp = ksba_cert_get_issuer (cert, 0);
1466   if (!tmp)
1467     {
1468       log_error ("oops: issuer missing in certificate\n");
1469       return gpg_error (GPG_ERR_INV_CERT_OBJ);
1470     }
1471   gcry_md_hash_buffer (GCRY_MD_SHA1, issuerhash, tmp, strlen (tmp));
1472   xfree (tmp);
1473   for (i=0,tmp=issuerhash_hex; i < 20; i++, tmp += 2)
1474     sprintf (tmp, "%02X", issuerhash[i]);
1475
1476   /* Get the serial number.  */
1477   serial = ksba_cert_get_serial (cert);
1478   if (!serial)
1479     {
1480       log_error ("oops: S/N missing in certificate\n");
1481       return gpg_error (GPG_ERR_INV_CERT_OBJ);
1482     }
1483   sn = serial;
1484   if (*sn != '(')
1485     {
1486       log_error ("oops: invalid S/N\n");
1487       xfree (serial);
1488       return gpg_error (GPG_ERR_INV_CERT_OBJ);
1489     }
1490   sn++;
1491   snlen = strtoul (sn, &endp, 10);
1492   sn = endp;
1493   if (*sn != ':')
1494     {
1495       log_error ("oops: invalid S/N\n");
1496       xfree (serial);
1497       return gpg_error (GPG_ERR_INV_CERT_OBJ);
1498     }
1499   sn++;
1500
1501   /* Check the cache.  */
1502   result = cache_isvalid (ctrl, issuerhash_hex, sn, snlen, force_refresh);
1503   switch (result)
1504     {
1505     case CRL_CACHE_VALID:
1506       err = 0;
1507       break;
1508     case CRL_CACHE_INVALID:
1509       err = gpg_error (GPG_ERR_CERT_REVOKED);
1510       break;
1511     case CRL_CACHE_DONTKNOW:
1512       err = gpg_error (GPG_ERR_NO_CRL_KNOWN);
1513     case CRL_CACHE_CANTUSE:
1514       err = gpg_error (GPG_ERR_NO_CRL_KNOWN);
1515       break;
1516     default:
1517       log_fatal ("cache_isvalid returned invalid status code %d\n", result);
1518     }
1519
1520   xfree (serial);
1521   return err;
1522 }
1523
1524
1525 /* Prepare a hash context for the signature verification.  Input is
1526    the CRL and the output is the hash context MD as well as the uses
1527    algorithm identifier ALGO. */
1528 static gpg_error_t
1529 start_sig_check (ksba_crl_t crl, gcry_md_hd_t *md, int *algo)
1530 {
1531   gpg_error_t err;
1532   const char *algoid;
1533
1534   algoid = ksba_crl_get_digest_algo (crl);
1535   *algo = gcry_md_map_name (algoid);
1536   if (!*algo)
1537     {
1538       log_error (_("unknown hash algorithm '%s'\n"), algoid? algoid:"?");
1539       return gpg_error (GPG_ERR_DIGEST_ALGO);
1540     }
1541
1542   err = gcry_md_open (md, *algo, 0);
1543   if (err)
1544     {
1545       log_error (_("gcry_md_open for algorithm %d failed: %s\n"),
1546                  *algo, gcry_strerror (err));
1547       return err;
1548     }
1549   if (DBG_HASHING)
1550     gcry_md_debug (*md, "hash.cert");
1551
1552   ksba_crl_set_hash_function (crl, HASH_FNC, *md);
1553   return 0;
1554 }
1555
1556
1557 /* Finish a hash context and verify the signature.  This function
1558    should return 0 on a good signature, GPG_ERR_BAD_SIGNATURE if the
1559    signature does not verify or any other error code. CRL is the CRL
1560    object we are working on, MD the hash context and ISSUER_CERT the
1561    certificate of the CRL issuer.  This function closes MD.  */
1562 static gpg_error_t
1563 finish_sig_check (ksba_crl_t crl, gcry_md_hd_t md, int algo,
1564                   ksba_cert_t issuer_cert)
1565 {
1566   gpg_error_t err;
1567   ksba_sexp_t sigval = NULL, pubkey = NULL;
1568   const char *s;
1569   char algoname[50];
1570   size_t n;
1571   gcry_sexp_t s_sig = NULL, s_hash = NULL, s_pkey = NULL;
1572   unsigned int i;
1573
1574   /* This also stops debugging on the MD.  */
1575   gcry_md_final (md);
1576
1577   /* Get and convert the signature value. */
1578   sigval = ksba_crl_get_sig_val (crl);
1579   n = gcry_sexp_canon_len (sigval, 0, NULL, NULL);
1580   if (!n)
1581     {
1582       log_error (_("got an invalid S-expression from libksba\n"));
1583       err = gpg_error (GPG_ERR_INV_SEXP);
1584       goto leave;
1585     }
1586   err = gcry_sexp_sscan (&s_sig, NULL, sigval, n);
1587   if (err)
1588     {
1589       log_error (_("converting S-expression failed: %s\n"),
1590                  gcry_strerror (err));
1591       goto leave;
1592     }
1593
1594   /* Get and convert the public key for the issuer certificate. */
1595   if (DBG_X509)
1596     dump_cert ("crl_issuer_cert", issuer_cert);
1597   pubkey = ksba_cert_get_public_key (issuer_cert);
1598   n = gcry_sexp_canon_len (pubkey, 0, NULL, NULL);
1599   if (!n)
1600     {
1601       log_error (_("got an invalid S-expression from libksba\n"));
1602       err = gpg_error (GPG_ERR_INV_SEXP);
1603       goto leave;
1604     }
1605   err = gcry_sexp_sscan (&s_pkey, NULL, pubkey, n);
1606   if (err)
1607     {
1608       log_error (_("converting S-expression failed: %s\n"),
1609                  gcry_strerror (err));
1610       goto leave;
1611     }
1612
1613   /* Create an S-expression with the actual hash value. */
1614   s = gcry_md_algo_name (algo);
1615   for (i = 0; *s && i < sizeof(algoname) - 1; s++, i++)
1616     algoname[i] = ascii_tolower (*s);
1617   algoname[i] = 0;
1618   err = gcry_sexp_build (&s_hash, NULL, "(data(flags pkcs1)(hash %s %b))",
1619                          algoname,
1620                          gcry_md_get_algo_dlen (algo), gcry_md_read (md, algo));
1621   if (err)
1622     {
1623       log_error (_("creating S-expression failed: %s\n"), gcry_strerror (err));
1624       goto leave;
1625     }
1626
1627   /* Pass this on to the signature verification. */
1628   err = gcry_pk_verify (s_sig, s_hash, s_pkey);
1629   if (DBG_X509)
1630     log_debug ("gcry_pk_verify: %s\n", gpg_strerror (err));
1631
1632  leave:
1633   xfree (sigval);
1634   xfree (pubkey);
1635   gcry_sexp_release (s_sig);
1636   gcry_sexp_release (s_hash);
1637   gcry_sexp_release (s_pkey);
1638   gcry_md_close (md);
1639
1640   return err;
1641 }
1642
1643
1644 /* Call this to match a start_sig_check that can not be completed
1645    normally.  */
1646 static void
1647 abort_sig_check (ksba_crl_t crl, gcry_md_hd_t md)
1648 {
1649   (void)crl;
1650   gcry_md_close (md);
1651 }
1652
1653
1654 /* Workhorse of the CRL loading machinery.  The CRL is read using the
1655    CRL object and stored in the data base file DB with the name FNAME
1656    (only used for printing error messages).  That DB should be a
1657    temporary one and not the actual one.  If the function fails the
1658    caller should delete this temporary database file.  CTRL is
1659    required to retrieve certificates using the general dirmngr
1660    callback service.  R_CRLISSUER returns an allocated string with the
1661    crl-issuer DN, THIS_UPDATE and NEXT_UPDATE are filled with the
1662    corresponding data from the CRL.  Note that these values might get
1663    set even if the CRL processing fails at a later step; thus the
1664    caller should free *R_ISSUER even if the function returns with an
1665    error.  R_TRUST_ANCHOR is set on exit to NULL or a string with the
1666    hexified fingerprint of the root certificate, if checking this
1667    certificate for trustiness is required.
1668 */
1669 static int
1670 crl_parse_insert (ctrl_t ctrl, ksba_crl_t crl,
1671                   struct cdb_make *cdb, const char *fname,
1672                   char **r_crlissuer,
1673                   ksba_isotime_t thisupdate, ksba_isotime_t nextupdate,
1674                   char **r_trust_anchor)
1675 {
1676   gpg_error_t err;
1677   ksba_stop_reason_t stopreason;
1678   ksba_cert_t crlissuer_cert = NULL;
1679   gcry_md_hd_t md = NULL;
1680   int algo = 0;
1681   size_t n;
1682
1683   (void)fname;
1684
1685   *r_crlissuer = NULL;
1686   *thisupdate = *nextupdate = 0;
1687   *r_trust_anchor = NULL;
1688
1689   /* Start of the KSBA parser loop. */
1690   do
1691     {
1692       err = ksba_crl_parse (crl, &stopreason);
1693       if (err)
1694         {
1695           log_error (_("ksba_crl_parse failed: %s\n"), gpg_strerror (err) );
1696           goto failure;
1697         }
1698
1699       switch (stopreason)
1700         {
1701         case KSBA_SR_BEGIN_ITEMS:
1702           {
1703             if (start_sig_check (crl, &md, &algo ))
1704               goto failure;
1705
1706             err = ksba_crl_get_update_times (crl, thisupdate, nextupdate);
1707             if (err)
1708               {
1709                 log_error (_("error getting update times of CRL: %s\n"),
1710                            gpg_strerror (err));
1711                 err = gpg_error (GPG_ERR_INV_CRL);
1712                 goto failure;
1713               }
1714
1715             if (opt.verbose || !*nextupdate)
1716               log_info (_("update times of this CRL: this=%s next=%s\n"),
1717                         thisupdate, nextupdate);
1718             if (!*nextupdate)
1719               {
1720                 log_info (_("nextUpdate not given; "
1721                             "assuming a validity period of one day\n"));
1722                 gnupg_copy_time (nextupdate, thisupdate);
1723                 add_seconds_to_isotime (nextupdate, 86400);
1724               }
1725           }
1726           break;
1727
1728         case KSBA_SR_GOT_ITEM:
1729           {
1730             ksba_sexp_t serial;
1731             const unsigned char *p;
1732             ksba_isotime_t rdate;
1733             ksba_crl_reason_t reason;
1734             int rc;
1735             unsigned char record[1+15];
1736
1737             err = ksba_crl_get_item (crl, &serial, rdate, &reason);
1738             if (err)
1739               {
1740                 log_error (_("error getting CRL item: %s\n"),
1741                            gpg_strerror (err));
1742                 err = gpg_error (GPG_ERR_INV_CRL);
1743                 ksba_free (serial);
1744                 goto failure;
1745               }
1746             p = serial_to_buffer (serial, &n);
1747             if (!p)
1748               BUG ();
1749             record[0] = (reason & 0xff);
1750             memcpy (record+1, rdate, 15);
1751             rc = cdb_make_add (cdb, p, n, record, 1+15);
1752             if (rc)
1753               {
1754                 err = gpg_error_from_errno (errno);
1755                 log_error (_("error inserting item into "
1756                              "temporary cache file: %s\n"),
1757                            strerror (errno));
1758                 goto failure;
1759               }
1760
1761             ksba_free (serial);
1762           }
1763           break;
1764
1765         case KSBA_SR_END_ITEMS:
1766           break;
1767
1768         case KSBA_SR_READY:
1769           {
1770             char *crlissuer;
1771             ksba_name_t authid;
1772             ksba_sexp_t authidsn;
1773             ksba_sexp_t keyid;
1774
1775             /* We need to look for the issuer only after having read
1776                all items.  The issuer itselfs comes before the items
1777                but the optional authorityKeyIdentifier comes after the
1778                items. */
1779             err = ksba_crl_get_issuer (crl, &crlissuer);
1780             if( err )
1781               {
1782                 log_error (_("no CRL issuer found in CRL: %s\n"),
1783                            gpg_strerror (err) );
1784                 err = gpg_error (GPG_ERR_INV_CRL);
1785                 goto failure;
1786               }
1787             /* Note: This should be released by ksba_free, not xfree.
1788                May need a memory reallocation dance.  */
1789             *r_crlissuer = crlissuer; /* (Do it here so we don't need
1790                                          to free it later) */
1791
1792             if (!ksba_crl_get_auth_key_id (crl, &keyid, &authid, &authidsn))
1793               {
1794                 const char *s;
1795
1796                 if (opt.verbose)
1797                   log_info (_("locating CRL issuer certificate by "
1798                               "authorityKeyIdentifier\n"));
1799
1800                 s = ksba_name_enum (authid, 0);
1801                 if (s && *authidsn)
1802                   crlissuer_cert = find_cert_bysn (ctrl, s, authidsn);
1803                 if (!crlissuer_cert && keyid)
1804                   crlissuer_cert = find_cert_bysubject (ctrl,
1805                                                         crlissuer, keyid);
1806
1807                 if (!crlissuer_cert)
1808                   {
1809                     log_info ("CRL issuer certificate ");
1810                     if (keyid)
1811                       {
1812                         log_printf ("{");
1813                         dump_serial (keyid);
1814                         log_printf ("} ");
1815                       }
1816                     if (authidsn)
1817                       {
1818                         log_printf ("(#");
1819                         dump_serial (authidsn);
1820                         log_printf ("/");
1821                         dump_string (s);
1822                         log_printf (") ");
1823                       }
1824                     log_printf ("not found\n");
1825                   }
1826                 ksba_name_release (authid);
1827                 xfree (authidsn);
1828                 xfree (keyid);
1829               }
1830             else
1831               crlissuer_cert = find_cert_bysubject (ctrl, crlissuer, NULL);
1832             err = 0;
1833             if (!crlissuer_cert)
1834               {
1835                 err = gpg_error (GPG_ERR_MISSING_CERT);
1836                 goto failure;
1837               }
1838
1839             err = finish_sig_check (crl, md, algo, crlissuer_cert);
1840             if (err)
1841               {
1842                 log_error (_("CRL signature verification failed: %s\n"),
1843                            gpg_strerror (err));
1844                 goto failure;
1845               }
1846             md = NULL;
1847
1848             err = validate_cert_chain (ctrl, crlissuer_cert, NULL,
1849                                        VALIDATE_MODE_CRL_RECURSIVE,
1850                                        r_trust_anchor);
1851             if (err)
1852               {
1853                 log_error (_("error checking validity of CRL "
1854                              "issuer certificate: %s\n"),
1855                            gpg_strerror (err));
1856                 goto failure;
1857               }
1858
1859           }
1860           break;
1861
1862         default:
1863           log_debug ("crl_parse_insert: unknown stop reason\n");
1864           err = gpg_error (GPG_ERR_BUG);
1865           goto failure;
1866         }
1867     }
1868   while (stopreason != KSBA_SR_READY);
1869   assert (!err);
1870
1871
1872  failure:
1873   if (md)
1874     abort_sig_check (crl, md);
1875   ksba_cert_release (crlissuer_cert);
1876   return err;
1877 }
1878
1879
1880
1881 /* Return the crlNumber extension as an allocated hex string or NULL
1882    if there is none. */
1883 static char *
1884 get_crl_number (ksba_crl_t crl)
1885 {
1886   gpg_error_t err;
1887   ksba_sexp_t number;
1888   char *string;
1889
1890   err = ksba_crl_get_crl_number (crl, &number);
1891   if (err)
1892     return NULL;
1893   string = serial_hex (number);
1894   ksba_free (number);
1895   return string;
1896 }
1897
1898
1899 /* Return the authorityKeyIdentifier or NULL if it is not available.
1900    The issuer name may consists of several parts - they are delimted by
1901    0x01. */
1902 static char *
1903 get_auth_key_id (ksba_crl_t crl, char **serialno)
1904 {
1905   gpg_error_t err;
1906   ksba_name_t name;
1907   ksba_sexp_t sn;
1908   int idx;
1909   const char *s;
1910   char *string;
1911   size_t length;
1912
1913   *serialno = NULL;
1914   err = ksba_crl_get_auth_key_id (crl, NULL, &name, &sn);
1915   if (err)
1916     return NULL;
1917   *serialno = serial_hex (sn);
1918   ksba_free (sn);
1919
1920   if (!name)
1921     return xstrdup ("");
1922
1923   length = 0;
1924   for (idx=0; (s = ksba_name_enum (name, idx)); idx++)
1925     {
1926       char *p = ksba_name_get_uri (name, idx);
1927       length += strlen (p?p:s) + 1;
1928       xfree (p);
1929     }
1930   string = xtrymalloc (length+1);
1931   if (string)
1932     {
1933       *string = 0;
1934       for (idx=0; (s = ksba_name_enum (name, idx)); idx++)
1935         {
1936           char *p = ksba_name_get_uri (name, idx);
1937           if (*string)
1938             strcat (string, "\x01");
1939           strcat (string, p?p:s);
1940           xfree (p);
1941         }
1942     }
1943   ksba_name_release (name);
1944   return string;
1945 }
1946
1947
1948
1949 /* Insert the CRL retrieved using URL into the cache specified by
1950    CACHE.  The CRL itself will be read from the stream FP and is
1951    expected in binary format.
1952
1953    Called by:
1954       crl_cache_load
1955          cmd_loadcrl
1956          --load-crl
1957       crl_cache_reload_crl
1958          cmd_isvalid
1959          cmd_checkcrl
1960       cmd_loadcrl
1961       --fetch-crl
1962
1963  */
1964 gpg_error_t
1965 crl_cache_insert (ctrl_t ctrl, const char *url, ksba_reader_t reader)
1966 {
1967   crl_cache_t cache = get_current_cache ();
1968   gpg_error_t err, err2;
1969   ksba_crl_t crl;
1970   char *fname = NULL;
1971   char *newfname = NULL;
1972   struct cdb_make cdb;
1973   int fd_cdb = -1;
1974   char *issuer = NULL;
1975   char *issuer_hash = NULL;
1976   ksba_isotime_t thisupdate, nextupdate;
1977   crl_cache_entry_t entry = NULL;
1978   crl_cache_entry_t e;
1979   gnupg_isotime_t current_time;
1980   char *checksum = NULL;
1981   int invalidate_crl = 0;
1982   int idx;
1983   const char *oid;
1984   int critical;
1985   char *trust_anchor = NULL;
1986
1987   /* FIXME: We should acquire a mutex for the URL, so that we don't
1988      simultaneously enter the same CRL twice.  However this needs to be
1989      interweaved with the checking function.*/
1990
1991   err2 = 0;
1992
1993   err = ksba_crl_new (&crl);
1994   if (err)
1995     {
1996       log_error (_("ksba_crl_new failed: %s\n"), gpg_strerror (err));
1997       goto leave;
1998     }
1999
2000   err = ksba_crl_set_reader (crl, reader);
2001   if ( err )
2002     {
2003       log_error (_("ksba_crl_set_reader failed: %s\n"), gpg_strerror (err));
2004       goto leave;
2005     }
2006
2007   /* Create a temporary cache file to load the CRL into. */
2008   {
2009     char *tmpfname, *p;
2010     const char *nodename;
2011 #ifndef HAVE_W32_SYSTEM
2012     struct utsname utsbuf;
2013 #endif
2014
2015 #ifdef HAVE_W32_SYSTEM
2016     nodename = "unknown";
2017 #else
2018     if (uname (&utsbuf))
2019       nodename = "unknown";
2020     else
2021       nodename = utsbuf.nodename;
2022 #endif
2023
2024     gpgrt_asprintf (&tmpfname, "crl-tmp-%s-%u-%p.db.tmp",
2025                     nodename, (unsigned int)getpid (), &tmpfname);
2026     if (!tmpfname)
2027       {
2028         err = gpg_error_from_syserror ();
2029         goto leave;
2030       }
2031     for (p=tmpfname; *p; p++)
2032       if (*p == '/')
2033         *p = '.';
2034     fname = make_filename (opt.homedir_cache, DBDIR_D, tmpfname, NULL);
2035     xfree (tmpfname);
2036     if (!gnupg_remove (fname))
2037       log_info (_("removed stale temporary cache file '%s'\n"), fname);
2038     else if (errno != ENOENT)
2039       {
2040         err = gpg_error_from_syserror ();
2041         log_error (_("problem removing stale temporary cache file '%s': %s\n"),
2042                    fname, gpg_strerror (err));
2043         goto leave;
2044       }
2045   }
2046
2047   fd_cdb = open (fname, O_WRONLY | O_CREAT | O_TRUNC, 0644);
2048   if (fd_cdb == -1)
2049     {
2050       err = gpg_error_from_errno (errno);
2051       log_error (_("error creating temporary cache file '%s': %s\n"),
2052                  fname, strerror (errno));
2053       goto leave;
2054     }
2055   cdb_make_start(&cdb, fd_cdb);
2056
2057   err = crl_parse_insert (ctrl, crl, &cdb, fname,
2058                           &issuer, thisupdate, nextupdate, &trust_anchor);
2059   if (err)
2060     {
2061       log_error (_("crl_parse_insert failed: %s\n"), gpg_strerror (err));
2062       /* Error in cleanup ignored.  */
2063       cdb_make_finish (&cdb);
2064       goto leave;
2065     }
2066
2067   /* Finish the database. */
2068   if (cdb_make_finish (&cdb))
2069     {
2070       err = gpg_error_from_errno (errno);
2071       log_error (_("error finishing temporary cache file '%s': %s\n"),
2072                  fname, strerror (errno));
2073       goto leave;
2074     }
2075   if (close (fd_cdb))
2076     {
2077       err = gpg_error_from_errno (errno);
2078       log_error (_("error closing temporary cache file '%s': %s\n"),
2079                  fname, strerror (errno));
2080       goto leave;
2081     }
2082   fd_cdb = -1;
2083
2084
2085   /* Create a checksum. */
2086   {
2087     unsigned char md5buf[16];
2088
2089     if (hash_dbfile (fname, md5buf))
2090       {
2091         err = gpg_error (GPG_ERR_CHECKSUM);
2092         goto leave;
2093       }
2094     checksum = hexify_data (md5buf, 16);
2095   }
2096
2097
2098   /* Check whether that new CRL is still not expired. */
2099   gnupg_get_isotime (current_time);
2100   if (strcmp (nextupdate, current_time) < 0 )
2101     {
2102       if (opt.force)
2103         log_info (_("WARNING: new CRL still too old; it expired on %s "
2104                     "- loading anyway\n"),  nextupdate);
2105       else
2106         {
2107           log_error (_("new CRL still too old; it expired on %s\n"),
2108                      nextupdate);
2109           if (!err2)
2110             err2 = gpg_error (GPG_ERR_CRL_TOO_OLD);
2111           invalidate_crl |= 1;
2112         }
2113     }
2114
2115   /* Check for unknown critical extensions. */
2116   for (idx=0; !(err=ksba_crl_get_extension (crl, idx, &oid, &critical,
2117                                               NULL, NULL)); idx++)
2118     {
2119       if (!critical
2120           || !strcmp (oid, oidstr_authorityKeyIdentifier)
2121           || !strcmp (oid, oidstr_crlNumber) )
2122         continue;
2123       log_error (_("unknown critical CRL extension %s\n"), oid);
2124       if (!err2)
2125         err2 = gpg_error (GPG_ERR_INV_CRL);
2126       invalidate_crl |= 2;
2127     }
2128   if (gpg_err_code (err) == GPG_ERR_EOF
2129       || gpg_err_code (err) == GPG_ERR_NO_DATA )
2130     err = 0;
2131   if (err)
2132     {
2133       log_error (_("error reading CRL extensions: %s\n"), gpg_strerror (err));
2134       err = gpg_error (GPG_ERR_INV_CRL);
2135     }
2136
2137
2138   /* Create an hex encoded SHA-1 hash of the issuer DN to be
2139      used as the key for the cache. */
2140   issuer_hash = hashify_data (issuer, strlen (issuer));
2141
2142   /* Create an ENTRY. */
2143   entry = xtrycalloc (1, sizeof *entry);
2144   if (!entry)
2145     {
2146       err = gpg_error_from_syserror ();
2147       goto leave;
2148     }
2149   entry->release_ptr = xtrymalloc (strlen (issuer_hash) + 1
2150                                    + strlen (issuer) + 1
2151                                    + strlen (url) + 1
2152                                    + strlen (checksum) + 1);
2153   if (!entry->release_ptr)
2154     {
2155       err = gpg_error_from_syserror ();
2156       xfree (entry);
2157       entry = NULL;
2158       goto leave;
2159     }
2160   entry->issuer_hash = entry->release_ptr;
2161   entry->issuer = stpcpy (entry->issuer_hash, issuer_hash) + 1;
2162   entry->url = stpcpy (entry->issuer, issuer) + 1;
2163   entry->dbfile_hash = stpcpy (entry->url, url) + 1;
2164   strcpy (entry->dbfile_hash, checksum);
2165   gnupg_copy_time (entry->this_update, thisupdate);
2166   gnupg_copy_time (entry->next_update, nextupdate);
2167   gnupg_copy_time (entry->last_refresh, current_time);
2168   entry->crl_number = get_crl_number (crl);
2169   entry->authority_issuer = get_auth_key_id (crl, &entry->authority_serialno);
2170   entry->invalid = invalidate_crl;
2171   entry->user_trust_req = !!trust_anchor;
2172   entry->check_trust_anchor = trust_anchor;
2173   trust_anchor = NULL;
2174
2175   /* Check whether we already have an entry for this issuer and mark
2176      it as deleted. We better use a loop, just in case duplicates got
2177      somehow into the list. */
2178   for (e = cache->entries; (e=find_entry (e, entry->issuer_hash)); e = e->next)
2179     e->deleted = 1;
2180
2181   /* Rename the temporary DB to the real name. */
2182   newfname = make_db_file_name (entry->issuer_hash);
2183   if (opt.verbose)
2184     log_info (_("creating cache file '%s'\n"), newfname);
2185
2186   /* Just in case close unused matching files.  Actually we need this
2187      only under Windows but saving file descriptors is never bad.  */
2188   {
2189     int any;
2190     do
2191       {
2192         any = 0;
2193         for (e = cache->entries; e; e = e->next)
2194           if (!e->cdb_use_count && e->cdb
2195               && !strcmp (e->issuer_hash, entry->issuer_hash))
2196             {
2197               int fd = cdb_fileno (e->cdb);
2198               cdb_free (e->cdb);
2199               xfree (e->cdb);
2200               e->cdb = NULL;
2201               if (close (fd))
2202                 log_error (_("error closing cache file: %s\n"),
2203                            strerror(errno));
2204               any = 1;
2205               break;
2206             }
2207       }
2208     while (any);
2209   }
2210 #ifdef HAVE_W32_SYSTEM
2211   gnupg_remove (newfname);
2212 #endif
2213   if (rename (fname, newfname))
2214     {
2215       err = gpg_error_from_syserror ();
2216       log_error (_("problem renaming '%s' to '%s': %s\n"),
2217                  fname, newfname, gpg_strerror (err));
2218       goto leave;
2219     }
2220   xfree (fname); fname = NULL; /*(let the cleanup code not try to remove it)*/
2221
2222   /* Link the new entry in. */
2223   entry->next = cache->entries;
2224   cache->entries = entry;
2225   entry = NULL;
2226
2227   err = update_dir (cache);
2228   if (err)
2229     {
2230       log_error (_("updating the DIR file failed - "
2231                    "cache entry will get lost with the next program start\n"));
2232       err = 0; /* Keep on running. */
2233     }
2234
2235
2236  leave:
2237   release_one_cache_entry (entry);
2238   if (fd_cdb != -1)
2239     close (fd_cdb);
2240   if (fname)
2241     {
2242       gnupg_remove (fname);
2243       xfree (fname);
2244     }
2245   xfree (newfname);
2246   ksba_crl_release (crl);
2247   xfree (issuer);
2248   xfree (issuer_hash);
2249   xfree (checksum);
2250   xfree (trust_anchor);
2251   return err ? err : err2;
2252 }
2253
2254
2255 /* Print one cached entry E in a human readable format to stream
2256    FP. Return 0 on success. */
2257 static gpg_error_t
2258 list_one_crl_entry (crl_cache_t cache, crl_cache_entry_t e, estream_t fp)
2259 {
2260   struct cdb_find cdbfp;
2261   struct cdb *cdb;
2262   int rc;
2263   int warn = 0;
2264   const unsigned char *s;
2265
2266   es_fputs ("--------------------------------------------------------\n", fp );
2267   es_fprintf (fp, _("Begin CRL dump (retrieved via %s)\n"), e->url );
2268   es_fprintf (fp, " Issuer:\t%s\n", e->issuer );
2269   es_fprintf (fp, " Issuer Hash:\t%s\n", e->issuer_hash );
2270   es_fprintf (fp, " This Update:\t%s\n", e->this_update );
2271   es_fprintf (fp, " Next Update:\t%s\n", e->next_update );
2272   es_fprintf (fp, " CRL Number :\t%s\n", e->crl_number? e->crl_number: "none");
2273   es_fprintf (fp, " AuthKeyId  :\t%s\n",
2274               e->authority_serialno? e->authority_serialno:"none");
2275   if (e->authority_serialno && e->authority_issuer)
2276     {
2277       es_fputs ("             \t", fp);
2278       for (s=e->authority_issuer; *s; s++)
2279         if (*s == '\x01')
2280           es_fputs ("\n             \t", fp);
2281         else
2282           es_putc (*s, fp);
2283       es_putc ('\n', fp);
2284     }
2285   es_fprintf (fp, " Trust Check:\t%s\n",
2286               !e->user_trust_req? "[system]" :
2287               e->check_trust_anchor? e->check_trust_anchor:"[missing]");
2288
2289   if ((e->invalid & 1))
2290     es_fprintf (fp, _(" ERROR: The CRL will not be used "
2291                       "because it was still too old after an update!\n"));
2292   if ((e->invalid & 2))
2293     es_fprintf (fp, _(" ERROR: The CRL will not be used "
2294                       "due to an unknown critical extension!\n"));
2295   if ((e->invalid & ~3))
2296     es_fprintf (fp, _(" ERROR: The CRL will not be used\n"));
2297
2298   cdb = lock_db_file (cache, e);
2299   if (!cdb)
2300     return gpg_error (GPG_ERR_GENERAL);
2301
2302   if (!e->dbfile_checked)
2303     es_fprintf (fp, _(" ERROR: This cached CRL may have been tampered with!\n"));
2304
2305   es_putc ('\n', fp);
2306
2307   rc = cdb_findinit (&cdbfp, cdb, NULL, 0);
2308   while (!rc && (rc=cdb_findnext (&cdbfp)) > 0 )
2309     {
2310       unsigned char keyrecord[256];
2311       unsigned char record[16];
2312       int reason;
2313       int any = 0;
2314       cdbi_t n;
2315       cdbi_t i;
2316
2317       rc = 0;
2318       n = cdb_datalen (cdb);
2319       if (n != 16)
2320         {
2321           log_error (_(" WARNING: invalid cache record length\n"));
2322           warn = 1;
2323           continue;
2324         }
2325
2326       if (cdb_read (cdb, record, n, cdb_datapos (cdb)))
2327         {
2328           log_error (_("problem reading cache record: %s\n"),
2329                      strerror (errno));
2330           warn = 1;
2331           continue;
2332         }
2333
2334       n = cdb_keylen (cdb);
2335       if (n > sizeof keyrecord)
2336         n = sizeof keyrecord;
2337       if (cdb_read (cdb, keyrecord, n, cdb_keypos (cdb)))
2338         {
2339           log_error (_("problem reading cache key: %s\n"), strerror (errno));
2340           warn = 1;
2341           continue;
2342         }
2343
2344       reason = *record;
2345       es_fputs ("  ", fp);
2346       for (i = 0; i < n; i++)
2347         es_fprintf (fp, "%02X", keyrecord[i]);
2348       es_fputs (":\t reasons( ", fp);
2349
2350       if (reason & KSBA_CRLREASON_UNSPECIFIED)
2351         es_fputs( "unspecified ", fp ), any = 1;
2352       if (reason & KSBA_CRLREASON_KEY_COMPROMISE )
2353         es_fputs( "key_compromise ", fp ), any = 1;
2354       if (reason & KSBA_CRLREASON_CA_COMPROMISE )
2355         es_fputs( "ca_compromise ", fp ), any = 1;
2356       if (reason & KSBA_CRLREASON_AFFILIATION_CHANGED )
2357         es_fputs( "affiliation_changed ", fp ), any = 1;
2358       if (reason & KSBA_CRLREASON_SUPERSEDED )
2359         es_fputs( "superseeded", fp ), any = 1;
2360       if (reason & KSBA_CRLREASON_CESSATION_OF_OPERATION )
2361         es_fputs( "cessation_of_operation", fp ), any = 1;
2362       if (reason & KSBA_CRLREASON_CERTIFICATE_HOLD )
2363         es_fputs( "certificate_hold", fp ), any = 1;
2364       if (reason && !any)
2365         es_fputs( "other", fp );
2366
2367       es_fprintf (fp, ") rdate: %.15s\n", record+1);
2368     }
2369   if (rc)
2370     log_error (_("error reading cache entry from db: %s\n"), strerror (rc));
2371
2372   unlock_db_file (cache, e);
2373   es_fprintf (fp, _("End CRL dump\n") );
2374   es_putc ('\n', fp);
2375
2376   return (rc||warn)? gpg_error (GPG_ERR_GENERAL) : 0;
2377 }
2378
2379
2380 /* Print the contents of the CRL CACHE in a human readable format to
2381    stream FP. */
2382 gpg_error_t
2383 crl_cache_list (estream_t fp)
2384 {
2385   crl_cache_t cache = get_current_cache ();
2386   crl_cache_entry_t entry;
2387   gpg_error_t err = 0;
2388
2389   for (entry = cache->entries;
2390        entry && !entry->deleted && !err;
2391        entry = entry->next )
2392     err = list_one_crl_entry (cache, entry, fp);
2393
2394   return err;
2395 }
2396
2397
2398 /* Load the CRL containing the file named FILENAME into our CRL cache. */
2399 gpg_error_t
2400 crl_cache_load (ctrl_t ctrl, const char *filename)
2401 {
2402   gpg_error_t err;
2403   estream_t fp;
2404   ksba_reader_t reader;
2405
2406   fp = es_fopen (filename, "r");
2407   if (!fp)
2408     {
2409       err = gpg_error_from_errno (errno);
2410       log_error (_("can't open '%s': %s\n"), filename, strerror (errno));
2411       return err;
2412     }
2413
2414   err = create_estream_ksba_reader (&reader, fp);
2415   if (!err)
2416     {
2417       err = crl_cache_insert (ctrl, filename, reader);
2418       ksba_reader_release (reader);
2419     }
2420   es_fclose (fp);
2421   return err;
2422 }
2423
2424
2425 /* Locate the corresponding CRL for the certificate CERT, read and
2426    verify the CRL and store it in the cache.  */
2427 gpg_error_t
2428 crl_cache_reload_crl (ctrl_t ctrl, ksba_cert_t cert)
2429 {
2430   gpg_error_t err;
2431   ksba_reader_t reader = NULL;
2432   char *issuer = NULL;
2433   ksba_name_t distpoint = NULL;
2434   ksba_name_t issuername = NULL;
2435   char *distpoint_uri = NULL;
2436   char *issuername_uri = NULL;
2437   int any_dist_point = 0;
2438   int seq;
2439
2440   /* Loop over all distribution points, get the CRLs and put them into
2441      the cache. */
2442   if (opt.verbose)
2443     log_info ("checking distribution points\n");
2444   seq = 0;
2445   while ( !(err = ksba_cert_get_crl_dist_point (cert, seq++,
2446                                                 &distpoint,
2447                                                 &issuername, NULL )))
2448     {
2449       int name_seq;
2450       gpg_error_t last_err = 0;
2451
2452       if (!distpoint && !issuername)
2453         {
2454           if (opt.verbose)
2455             log_info ("no issuer name and no distribution point\n");
2456           break; /* Not allowed; i.e. an invalid certificate.  We give
2457                     up here and hope that the default method returns a
2458                     suitable CRL. */
2459         }
2460
2461       xfree (issuername_uri); issuername_uri = NULL;
2462
2463       /* Get the URIs.  We do this in a loop to iterate over all names
2464          in the crlDP. */
2465       for (name_seq=0; ksba_name_enum (distpoint, name_seq); name_seq++)
2466         {
2467           xfree (distpoint_uri); distpoint_uri = NULL;
2468           distpoint_uri = ksba_name_get_uri (distpoint, name_seq);
2469           if (!distpoint_uri)
2470             continue;
2471
2472           if (!strncmp (distpoint_uri, "ldap:", 5)
2473               || !strncmp (distpoint_uri, "ldaps:", 6))
2474             {
2475               if (opt.ignore_ldap_dp)
2476                 continue;
2477             }
2478           else if (!strncmp (distpoint_uri, "http:", 5)
2479                    || !strncmp (distpoint_uri, "https:", 6))
2480             {
2481               if (opt.ignore_http_dp)
2482                 continue;
2483             }
2484           else
2485             continue; /* Skip unknown schemes. */
2486
2487           any_dist_point = 1;
2488
2489           if (opt.verbose)
2490             log_info ("fetching CRL from '%s'\n", distpoint_uri);
2491           err = crl_fetch (ctrl, distpoint_uri, &reader);
2492           if (err)
2493             {
2494               log_error (_("crl_fetch via DP failed: %s\n"),
2495                          gpg_strerror (err));
2496               last_err = err;
2497               continue; /* with the next name. */
2498             }
2499
2500           if (opt.verbose)
2501             log_info ("inserting CRL (reader %p)\n", reader);
2502           err = crl_cache_insert (ctrl, distpoint_uri, reader);
2503           if (err)
2504             {
2505               log_error (_("crl_cache_insert via DP failed: %s\n"),
2506                          gpg_strerror (err));
2507               last_err = err;
2508               continue; /* with the next name. */
2509             }
2510           last_err = 0;
2511           break; /* Ready. */
2512         }
2513       if (last_err)
2514         {
2515           err = last_err;
2516           goto leave;
2517         }
2518
2519       ksba_name_release (distpoint); distpoint = NULL;
2520
2521       /* We don't do anything with issuername_uri yet but we keep the
2522          code for documentation. */
2523       issuername_uri =  ksba_name_get_uri (issuername, 0);
2524       ksba_name_release (issuername); issuername = NULL;
2525
2526     }
2527   if (gpg_err_code (err) == GPG_ERR_EOF)
2528     err = 0;
2529
2530   /* If we did not found any distpoint, try something reasonable. */
2531   if (!any_dist_point )
2532     {
2533       if (opt.verbose)
2534         log_info ("no distribution point - trying issuer name\n");
2535
2536       if (reader)
2537         {
2538           crl_close_reader (reader);
2539           reader = NULL;
2540         }
2541
2542       issuer = ksba_cert_get_issuer (cert, 0);
2543       if (!issuer)
2544         {
2545           log_error ("oops: issuer missing in certificate\n");
2546           err = gpg_error (GPG_ERR_INV_CERT_OBJ);
2547           goto leave;
2548         }
2549
2550       if (opt.verbose)
2551         log_info ("fetching CRL from default location\n");
2552       err = crl_fetch_default (ctrl, issuer, &reader);
2553       if (err)
2554           {
2555             log_error ("crl_fetch via issuer failed: %s\n",
2556                        gpg_strerror (err));
2557             goto leave;
2558           }
2559
2560       if (opt.verbose)
2561         log_info ("inserting CRL (reader %p)\n", reader);
2562       err = crl_cache_insert (ctrl, "default location(s)", reader);
2563       if (err)
2564         {
2565           log_error (_("crl_cache_insert via issuer failed: %s\n"),
2566                      gpg_strerror (err));
2567           goto leave;
2568         }
2569     }
2570
2571  leave:
2572   if (reader)
2573     crl_close_reader (reader);
2574   xfree (distpoint_uri);
2575   xfree (issuername_uri);
2576   ksba_name_release (distpoint);
2577   ksba_name_release (issuername);
2578   ksba_free (issuer);
2579   return err;
2580 }