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