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