No OneTemporary
Actions

Size

123 KB

Subscribers

None

View Options

	diff --git a/dirmngr/crlcache.c b/dirmngr/crlcache.c
	index 29b8a06da..00f76d4df 100644
	--- a/dirmngr/crlcache.c
	+++ b/dirmngr/crlcache.c
	@@ -1,2802 +1,2803 @@
	/* crlcache.c - LDAP access
	* Copyright (C) 2002 Klarälvdalens Datakonsult AB
	* Copyright (C) 2003, 2004, 2005, 2008 g10 Code GmbH
	*
	* This file is part of DirMngr.
	*
	* DirMngr is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* DirMngr is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, see <https://www.gnu.org/licenses/>.
	*/

	/*

	1. To keep track of the CRLs actually cached and to store the meta
	information of the CRLs a simple record oriented text file is
	used. Fields in the file are colon (':') separated and values
	containing colons or linefeeds are percent escaped (e.g. a colon
	itself is represented as "%3A").

	The first field is a record type identifier, so that the file is
	useful to keep track of other meta data too.

	The name of the file is "DIR.txt".


	1.1. Comment record

	Field 1: Constant beginning with "#".

	Other fields are not defined and such a record is simply
	skipped during processing.

	1.2. Version record

	Field 1: Constant "v"
	Field 2: Version number of this file. Must be 1.

	This record must be the first non-comment record and
	there shall only exist one record of this type.

	1.3. CRL cache record

	Field 1: Constant "c", "u" or "i".
	A "c" or "u" indicate a valid cache entry, however
	"u" requires that a user root certificate check needs
	to be done.
	An "i" indicates an invalid cache entry which should
	not be used but still exists so that it can be
	updated at NEXT_UPDATE.
	Field 2: Hexadecimal encoded SHA-1 hash of the issuer DN using
	uppercase letters.
	Field 3: Issuer DN in RFC-2253 notation.
	Field 4: URL used to retrieve the corresponding CRL.
	Field 5: 15 character ISO timestamp with THIS_UPDATE.
	Field 6: 15 character ISO timestamp with NEXT_UPDATE.
	Field 7: Hexadecimal encoded MD-5 hash of the DB file to detect
	accidental modified (i.e. deleted and created) cache files.
	Field 8: optional CRL number as a hex string.
	Field 9: AuthorityKeyID.issuer, each Name separated by 0x01
	Field 10: AuthorityKeyID.serial
	Field 11: Hex fingerprint of trust anchor if field 1 is 'u'.

	2. Layout of the standard CRL Cache DB file:

	We use records of variable length with this structure

	n bytes Serialnumber (binary) used as key
	thus there is no need to store the length explicitly with DB2.
	1 byte Reason for revocation
	(currently the KSBA reason flags are used)
	15 bytes ISO date of revocation (e.g. 19980815T142000)
	Note that there is no terminating 0 stored.

	The filename used is the hexadecimal (using uppercase letters)
	SHA-1 hash value of the issuer DN prefixed with a "crl-" and
	suffixed with a ".db". Thus the length of the filename is 47.


	*/

	#include <config.h>

	#include <stdio.h>
	#include <stdlib.h>
	#include <errno.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <assert.h>
	#include <dirent.h>
	#include <fcntl.h>
	#include <unistd.h>
	#ifndef HAVE_W32_SYSTEM
	#include <sys/utsname.h>
	#endif

	#include "dirmngr.h"
	#include "validate.h"
	#include "certcache.h"
	#include "crlcache.h"
	#include "crlfetch.h"
	#include "misc.h"
	#include "cdb.h"

	/* Change this whenever the format changes */
	#define DBDIR_D "crls.d"
	#define DBDIRFILE "DIR.txt"
	#define DBDIRVERSION 1

	/* The number of DB files we may have open at one time. We need to
	limit this because there is no guarantee that the number of issuers
	has a upper limit. We are currently using mmap, so it is a good
	idea anyway to limit the number of opened cache files. */
	#define MAX_OPEN_DB_FILES 5

	#ifndef O_BINARY
	# define O_BINARY 0
	#endif

	static const char oidstr_crlNumber[] = "2.5.29.20";
	/* static const char oidstr_issuingDistributionPoint[] = "2.5.29.28"; */
	static const char oidstr_authorityKeyIdentifier[] = "2.5.29.35";


	/* Definition of one cached item. */
	struct crl_cache_entry_s
	{
	struct crl_cache_entry_s *next;
	int deleted; /* True if marked for deletion. */
	int mark; /* Internally used by update_dir. */
	unsigned int lineno;/* A 0 indicates a new entry. */
	char release_ptr; / The actual allocated memory. */
	char url; / Points into RELEASE_PTR. */
	char issuer; / Ditto. */
	char issuer_hash; / Ditto. */
	char dbfile_hash; / MD5 sum of the cache file, points into RELEASE_PTR.*/
	int invalid; /* Can't use this CRL. */
	int user_trust_req; /* User supplied root certificate required. */
	char check_trust_anchor; / Malloced fingerprint. */
	ksba_isotime_t this_update;
	ksba_isotime_t next_update;
	ksba_isotime_t last_refresh; /* Use for the force_crl_refresh feature. */
	char *crl_number;
	char *authority_issuer;
	char *authority_serialno;

	struct cdb cdb; / The cache file handle or NULL if not open. */

	unsigned int cdb_use_count; /* Current use count. */
	unsigned int cdb_lru_count; /* Used for LRU purposes. */
	int dbfile_checked; /* Set to true if the dbfile_hash value has
	been checked one. */
	};


	/* Definition of the entire cache object. */
	struct crl_cache_s
	{
	crl_cache_entry_t entries;
	};

	typedef struct crl_cache_s *crl_cache_t;


	/* Prototypes. */
	static crl_cache_entry_t find_entry (crl_cache_entry_t first,
	const char *issuer_hash);



	/* The currently loaded cache object. This is usually initialized
	right at startup. */
	static crl_cache_t current_cache;





	/* Return the current cache object or bail out if it is has not yet
	been initialized. */
	static crl_cache_t
	get_current_cache (void)
	{
	if (!current_cache)
	log_fatal ("CRL cache has not yet been initialized\n");
	return current_cache;
	}


	/*
	Create ae directory if it does not yet exists. Returns on
	success, or -1 on error.
	*/
	static int
	create_directory_if_needed (const char *name)
	{
	gnupg_dir_t dir;
	char *fname;

	fname = make_filename (opt.homedir_cache, name, NULL);
	dir = gnupg_opendir (fname);
	if (!dir)
	{
	log_info (_("creating directory '%s'\n"), fname);
	if (gnupg_mkdir (fname, "-rwx"))
	{
	int save_errno = errno;
	log_error (_("error creating directory '%s': %s\n"),
	fname, strerror (errno));
	xfree (fname);
	gpg_err_set_errno (save_errno);
	return -1;
	}
	}
	else
	gnupg_closedir (dir);
	xfree (fname);
	return 0;
	}

	/* Remove all files from the cache directory. If FORCE is not true,
	some sanity checks on the filenames are done. Return 0 if
	everything went fine. */
	static int
	cleanup_cache_dir (int force)
	{
	char *dname = make_filename (opt.homedir_cache, DBDIR_D, NULL);
	gnupg_dir_t dir;
	gnupg_dirent_t de;
	int problem = 0;

	if (!force)
	{ /* Very minor sanity checks. */
	if (!strcmp (dname, "~/") \|\| !strcmp (dname, "/" ))
	{
	log_error (_("ignoring database dir '%s'\n"), dname);
	xfree (dname);
	return -1;
	}
	}

	dir = gnupg_opendir (dname);
	if (!dir)
	{
	log_error (_("error reading directory '%s': %s\n"),
	dname, strerror (errno));
	xfree (dname);
	return -1;
	}

	while ((de = gnupg_readdir (dir)))
	{
	if (strcmp (de->d_name, "." ) && strcmp (de->d_name, ".."))
	{
	char *cdbname = make_filename (dname, de->d_name, NULL);
	int okay;
	struct stat sbuf;

	if (force)
	okay = 1;
	else
	okay = (!gnupg_stat (cdbname, &sbuf) && S_ISREG (sbuf.st_mode));

	if (okay)
	{
	log_info (_("removing cache file '%s'\n"), cdbname);
	if (gnupg_remove (cdbname))
	{
	log_error ("failed to remove '%s': %s\n",
	cdbname, strerror (errno));
	problem = -1;
	}
	}
	else
	log_info (_("not removing file '%s'\n"), cdbname);
	xfree (cdbname);
	}
	}
	xfree (dname);
	gnupg_closedir (dir);
	return problem;
	}


	/* Read the next line from the file FP and return the line in an
	malloced buffer. Return NULL on error or EOF. There is no
	limitation os the line length. The trailing linefeed has been
	removed, the function will read the last line of a file, even if
	that is not terminated by a LF. */
	static char *
	next_line_from_file (estream_t fp, gpg_error_t *r_err)
	{
	char buf[300];
	char *largebuf = NULL;
	size_t buflen;
	size_t len = 0;
	unsigned char *p;
	int c;
	char *tmpbuf;

	*r_err = 0;
	p = buf;
	buflen = sizeof buf - 1;
	while ((c=es_getc (fp)) != EOF && c != '\n')
	{
	if (len >= buflen)
	{
	if (!largebuf)
	{
	buflen += 1024;
	largebuf = xtrymalloc ( buflen + 1 );
	if (!largebuf)
	{
	*r_err = gpg_error_from_syserror ();
	return NULL;
	}
	memcpy (largebuf, buf, len);
	}
	else
	{
	buflen += 1024;
	tmpbuf = xtryrealloc (largebuf, buflen + 1);
	if (!tmpbuf)
	{
	*r_err = gpg_error_from_syserror ();
	xfree (largebuf);
	return NULL;
	}
	largebuf = tmpbuf;
	}
	p = largebuf;
	}
	p[len++] = c;
	}
	if (c == EOF && !len)
	return NULL;
	p[len] = 0;

	if (largebuf)
	tmpbuf = xtryrealloc (largebuf, len+1);
	else
	tmpbuf = xtrystrdup (buf);
	if (!tmpbuf)
	{
	*r_err = gpg_error_from_syserror ();
	xfree (largebuf);
	}
	return tmpbuf;
	}


	/* Release one cache entry. */
	static void
	release_one_cache_entry (crl_cache_entry_t entry)
	{
	if (entry)
	{
	if (entry->cdb)
	{
	int fd = cdb_fileno (entry->cdb);
	cdb_free (entry->cdb);
	xfree (entry->cdb);
	if (close (fd))
	log_error (_("error closing cache file: %s\n"), strerror(errno));
	}
	xfree (entry->release_ptr);
	xfree (entry->check_trust_anchor);
	xfree (entry);
	}
	}


	/* Release the CACHE object. */
	static void
	release_cache (crl_cache_t cache)
	{
	crl_cache_entry_t entry, entry2;

	if (!cache)
	return;

	for (entry = cache->entries; entry; entry = entry2)
	{
	entry2 = entry->next;
	release_one_cache_entry (entry);
	}
	cache->entries = NULL;
	xfree (cache);
	}


	/* Open the dir file FNAME or create a new one if it does not yet
	exist. */
	static estream_t
	open_dir_file (const char *fname)
	{
	estream_t fp;

	fp = es_fopen (fname, "r");
	if (!fp)
	{
	log_error (_("failed to open cache dir file '%s': %s\n"),
	fname, strerror (errno));

	/* Make sure that the directory exists, try to create if otherwise. */
	if (create_directory_if_needed (NULL)
	\|\| create_directory_if_needed (DBDIR_D))
	return NULL;
	fp = es_fopen (fname, "w");
	if (!fp)
	{
	log_error (_("error creating new cache dir file '%s': %s\n"),
	fname, strerror (errno));
	return NULL;
	}
	es_fprintf (fp, "v:%d:\n", DBDIRVERSION);
	if (es_ferror (fp))
	{
	log_error (_("error writing new cache dir file '%s': %s\n"),
	fname, strerror (errno));
	es_fclose (fp);
	return NULL;
	}
	if (es_fclose (fp))
	{
	log_error (_("error closing new cache dir file '%s': %s\n"),
	fname, strerror (errno));
	return NULL;
	}

	log_info (_("new cache dir file '%s' created\n"), fname);

	fp = es_fopen (fname, "r");
	if (!fp)
	{
	log_error (_("failed to re-open cache dir file '%s': %s\n"),
	fname, strerror (errno));
	return NULL;
	}
	}

	return fp;
	}

	/* Helper for open_dir. */
	static gpg_error_t
	check_dir_version (estream_t fpadr, const char fname,
	unsigned int *lineno,
	int cleanup_on_mismatch)
	{
	char *line;
	gpg_error_t lineerr = 0;
	estream_t fp = *fpadr;
	int created = 0;

	retry:
	while ((line = next_line_from_file (fp, &lineerr)))
	{
	++*lineno;
	if (*line == 'v' && line[1] == ':')
	break;
	else if (*line != '#')
	{
	log_error (_("first record of '%s' is not the version\n"), fname);
	xfree (line);
	return gpg_error (GPG_ERR_CONFIGURATION);
	}
	xfree (line);
	}
	if (lineerr)
	return lineerr;

	/* The !line catches the case of an empty DIR file. We handle this
	the same as a non-matching version. */
	if (!line \|\| strtol (line+2, NULL, 10) != DBDIRVERSION)
	{
	if (!created && cleanup_on_mismatch)
	{
	log_error (_("old version of cache directory - cleaning up\n"));
	es_fclose (fp);
	*fpadr = NULL;
	if (!cleanup_cache_dir (1))
	{
	*lineno = 0;
	fp = *fpadr = open_dir_file (fname);
	if (!fp)
	{
	xfree (line);
	return gpg_error (GPG_ERR_CONFIGURATION);
	}
	created = 1;
	goto retry;
	}
	}
	log_error (_("old version of cache directory - giving up\n"));
	xfree (line);
	return gpg_error (GPG_ERR_CONFIGURATION);
	}
	xfree (line);
	return 0;
	}


	/* Open the dir file and read in all available information. Store
	that in a newly allocated cache object and return that if
	everything worked out fine. Create the cache directory and the dir
	if it does not yet exist. Remove all files in that directory if
	the version does not match. */
	static gpg_error_t
	open_dir (crl_cache_t *r_cache)
	{
	crl_cache_t cache;
	char *fname;
	char *line = NULL;
	gpg_error_t lineerr = 0;
	estream_t fp;
	crl_cache_entry_t entry, *entrytail;
	unsigned int lineno;
	gpg_error_t err = 0;
	int anyerr = 0;

	cache = xtrycalloc (1, sizeof *cache);
	if (!cache)
	return gpg_error_from_syserror ();

	fname = make_filename (opt.homedir_cache, DBDIR_D, DBDIRFILE, NULL);

	lineno = 0;
	fp = open_dir_file (fname);
	if (!fp)
	{
	err = gpg_error (GPG_ERR_CONFIGURATION);
	goto leave;
	}

	err = check_dir_version (&fp, fname, &lineno, 1);
	if (err)
	goto leave;


	/* Read in all supported entries from the dir file. */
	cache->entries = NULL;
	entrytail = &cache->entries;
	xfree (line);
	while ((line = next_line_from_file (fp, &lineerr)))
	{
	int fieldno;
	char p, endp;

	lineno++;
	if ( line == 'c' \|\| line == 'u' \|\| *line == 'i' )
	{
	entry = xtrycalloc (1, sizeof *entry);
	if (!entry)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	entry->lineno = lineno;
	entry->release_ptr = line;
	if (*line == 'i')
	{
	entry->invalid = atoi (line+1);
	if (entry->invalid < 1)
	entry->invalid = 1;
	}
	else if (*line == 'u')
	entry->user_trust_req = 1;

	for (fieldno=1, p = line; p; p = endp, fieldno++)
	{
	endp = strchr (p, ':');
	if (endp)
	*endp++ = '\0';

	switch (fieldno)
	{
	case 1: /* record type */ break;
	case 2: entry->issuer_hash = p; break;
	case 3: entry->issuer = unpercent_string (p); break;
	case 4: entry->url = unpercent_string (p); break;
	case 5:
	strncpy (entry->this_update, p, 15);
	entry->this_update[15] = 0;
	break;
	case 6:
	strncpy (entry->next_update, p, 15);
	entry->next_update[15] = 0;
	break;
	case 7: entry->dbfile_hash = p; break;
	case 8: if (*p) entry->crl_number = p; break;
	case 9:
	if (*p)
	entry->authority_issuer = unpercent_string (p);
	break;
	case 10:
	if (*p)
	entry->authority_serialno = unpercent_string (p);
	break;
	case 11:
	if (*p)
	entry->check_trust_anchor = xtrystrdup (p);
	break;
	default:
	if (*p)
	log_info (_("extra field detected in crl record of "
	"'%s' line %u\n"), fname, lineno);
	break;
	}
	}

	if (!entry->issuer_hash)
	{
	log_info (_("invalid line detected in '%s' line %u\n"),
	fname, lineno);
	xfree (entry);
	entry = NULL;
	}
	else if (find_entry (cache->entries, entry->issuer_hash))
	{
	/* Fixme: The duplicate checking used is not very
	effective for large numbers of issuers. */
	log_info (_("duplicate entry detected in '%s' line %u\n"),
	fname, lineno);
	xfree (entry);
	entry = NULL;
	}
	else
	{
	line = NULL;
	*entrytail = entry;
	entrytail = &entry->next;
	}
	}
	else if (*line == '#')
	;
	else
	log_info (_("unsupported record type in '%s' line %u skipped\n"),
	fname, lineno);

	if (line)
	xfree (line);
	}
	if (lineerr)
	{
	err = lineerr;
	log_error (_("error reading '%s': %s\n"), fname, gpg_strerror (err));
	goto leave;
	}
	if (es_ferror (fp))
	{
	log_error (_("error reading '%s': %s\n"), fname, strerror (errno));
	err = gpg_error (GPG_ERR_CONFIGURATION);
	goto leave;
	}

	/* Now do some basic checks on the data. */
	for (entry = cache->entries; entry; entry = entry->next)
	{
	assert (entry->lineno);
	if (strlen (entry->issuer_hash) != 40)
	{
	anyerr++;
	log_error (_("invalid issuer hash in '%s' line %u\n"),
	fname, entry->lineno);
	}
	else if ( !*entry->issuer )
	{
	anyerr++;
	log_error (_("no issuer DN in '%s' line %u\n"),
	fname, entry->lineno);
	}
	else if ( check_isotime (entry->this_update)
	\|\| check_isotime (entry->next_update))
	{
	anyerr++;
	log_error (_("invalid timestamp in '%s' line %u\n"),
	fname, entry->lineno);
	}

	/* Checks not leading to an immediate fail. */
	if (strlen (entry->dbfile_hash) != 32)
	log_info (_("WARNING: invalid cache file hash in '%s' line %u\n"),
	fname, entry->lineno);
	}

	if (anyerr)
	{
	log_error (_("detected errors in cache dir file\n"));
	log_info (_("please check the reason and manually delete that file\n"));
	err = gpg_error (GPG_ERR_CONFIGURATION);
	}


	leave:
	es_fclose (fp);
	xfree (line);
	xfree (fname);
	if (err)
	{
	release_cache (cache);
	cache = NULL;
	}
	*r_cache = cache;
	return err;
	}

	static void
	write_percented_string (const char *s, estream_t fp)
	{
	for (; *s; s++)
	if (*s == ':')
	es_fputs ("%3A", fp);
	else if (*s == '\n')
	es_fputs ("%0A", fp);
	else if (*s == '\r')
	es_fputs ("%0D", fp);
	else
	es_putc (*s, fp);
	}


	static void
	write_dir_line_crl (estream_t fp, crl_cache_entry_t e)
	{
	if (e->invalid)
	es_fprintf (fp, "i%d", e->invalid);
	else if (e->user_trust_req)
	es_putc ('u', fp);
	else
	es_putc ('c', fp);
	es_putc (':', fp);
	es_fputs (e->issuer_hash, fp);
	es_putc (':', fp);
	write_percented_string (e->issuer, fp);
	es_putc (':', fp);
	write_percented_string (e->url, fp);
	es_putc (':', fp);
	es_fwrite (e->this_update, 15, 1, fp);
	es_putc (':', fp);
	es_fwrite (e->next_update, 15, 1, fp);
	es_putc (':', fp);
	es_fputs (e->dbfile_hash, fp);
	es_putc (':', fp);
	if (e->crl_number)
	es_fputs (e->crl_number, fp);
	es_putc (':', fp);
	if (e->authority_issuer)
	write_percented_string (e->authority_issuer, fp);
	es_putc (':', fp);
	if (e->authority_serialno)
	es_fputs (e->authority_serialno, fp);
	es_putc (':', fp);
	if (e->check_trust_anchor && e->user_trust_req)
	es_fputs (e->check_trust_anchor, fp);
	es_putc ('\n', fp);
	}


	/* Update the current dir file using the cache. */
	static gpg_error_t
	update_dir (crl_cache_t cache)
	{
	char *fname = NULL;
	char *tmpfname = NULL;
	char *line = NULL;
	gpg_error_t lineerr = 0;
	estream_t fp;
	estream_t fpout = NULL;
	crl_cache_entry_t e;
	unsigned int lineno;
	gpg_error_t err = 0;

	fname = make_filename (opt.homedir_cache, DBDIR_D, DBDIRFILE, NULL);

	/* Fixme: Take an update file lock here. */

	for (e= cache->entries; e; e = e->next)
	e->mark = 1;

	lineno = 0;
	fp = es_fopen (fname, "r");
	if (!fp)
	{
	err = gpg_error_from_errno (errno);
	log_error (_("failed to open cache dir file '%s': %s\n"),
	fname, strerror (errno));
	goto leave;
	}
	err = check_dir_version (&fp, fname, &lineno, 0);
	if (err)
	goto leave;
	es_rewind (fp);
	lineno = 0;

	/* Create a temporary DIR file. */
	{
	char tmpbuf, p;
	const char *nodename;
	#ifndef HAVE_W32_SYSTEM
	struct utsname utsbuf;
	#endif

	#ifdef HAVE_W32_SYSTEM
	nodename = "unknown";
	#else
	if (uname (&utsbuf))
	nodename = "unknown";
	else
	nodename = utsbuf.nodename;
	#endif

	gpgrt_asprintf (&tmpbuf, "DIR-tmp-%s-%u-%p.txt.tmp",
	nodename, (unsigned int)getpid (), &tmpbuf);
	if (!tmpbuf)
	{
	err = gpg_error_from_errno (errno);
	log_error (_("failed to create temporary cache dir file '%s': %s\n"),
	tmpfname, strerror (errno));
	goto leave;
	}
	for (p=tmpbuf; *p; p++)
	if (*p == '/')
	*p = '.';
	tmpfname = make_filename (opt.homedir_cache, DBDIR_D, tmpbuf, NULL);
	xfree (tmpbuf);
	}
	fpout = es_fopen (tmpfname, "w");
	if (!fpout)
	{
	err = gpg_error_from_errno (errno);
	log_error (_("failed to create temporary cache dir file '%s': %s\n"),
	tmpfname, strerror (errno));
	goto leave;
	}

	while ((line = next_line_from_file (fp, &lineerr)))
	{
	lineno++;
	if (line == 'c' \|\| line == 'u' \|\| *line == 'i')
	{
	/* Extract the issuer hash field. */
	char fieldp, endp;

	fieldp = strchr (line, ':');
	endp = fieldp? strchr (++fieldp, ':') : NULL;
	if (endp)
	{
	/* There should be no percent within the issuer hash
	field, thus we can compare it pretty easily. */
	*endp = 0;
	e = find_entry ( cache->entries, fieldp);
	endp = ':'; / Restore original line. */
	if (e && e->deleted)
	{
	/* Marked for deletion, so don't write it. */
	e->mark = 0;
	}
	else if (e)
	{
	/* Yep, this is valid entry we know about; write it out */
	write_dir_line_crl (fpout, e);
	e->mark = 0;
	}
	else
	{ /* We ignore entries we don't have in our cache
	because they may have been added in the meantime
	by other instances of dirmngr. */
	es_fprintf (fpout, "# Next line added by "
	"another process; our pid is %lu\n",
	(unsigned long)getpid ());
	es_fputs (line, fpout);
	es_putc ('\n', fpout);
	}
	}
	else
	{
	es_fputs ("# Invalid line detected: ", fpout);
	es_fputs (line, fpout);
	es_putc ('\n', fpout);
	}
	}
	else
	{
	/* Write out all non CRL lines as they are. */
	es_fputs (line, fpout);
	es_putc ('\n', fpout);
	}

	xfree (line);
	}
	if (!es_ferror (fp) && !es_ferror (fpout) && !lineerr)
	{
	/* Write out the remaining entries. */
	for (e= cache->entries; e; e = e->next)
	if (e->mark)
	{
	if (!e->deleted)
	write_dir_line_crl (fpout, e);
	e->mark = 0;
	}
	}
	if (lineerr)
	{
	err = lineerr;
	log_error (_("error reading '%s': %s\n"), fname, gpg_strerror (err));
	goto leave;
	}
	if (es_ferror (fp))
	{
	err = gpg_error_from_errno (errno);
	log_error (_("error reading '%s': %s\n"), fname, strerror (errno));
	}
	if (es_ferror (fpout))
	{
	err = gpg_error_from_errno (errno);
	log_error (_("error writing '%s': %s\n"), tmpfname, strerror (errno));
	}
	if (err)
	goto leave;

	/* Rename the files. */
	es_fclose (fp);
	fp = NULL;
	if (es_fclose (fpout))
	{
	err = gpg_error_from_errno (errno);
	log_error (_("error closing '%s': %s\n"), tmpfname, strerror (errno));
	goto leave;
	}
	fpout = NULL;

	#ifdef HAVE_W32_SYSTEM
	/* No atomic mv on W32 systems. */
	gnupg_remove (fname);
	#endif
	if (rename (tmpfname, fname))
	{
	err = gpg_error_from_errno (errno);
	log_error (_("error renaming '%s' to '%s': %s\n"),
	tmpfname, fname, strerror (errno));
	goto leave;
	}

	leave:
	/* Fixme: Relinquish update lock. */
	xfree (line);
	es_fclose (fp);
	xfree (fname);
	if (fpout)
	{
	es_fclose (fpout);
	if (err && tmpfname)
	gnupg_remove (tmpfname);
	}
	xfree (tmpfname);
	return err;
	}




	/* Create the filename for the cache file from the 40 byte ISSUER_HASH
	string. Caller must release the return string. */
	static char *
	make_db_file_name (const char *issuer_hash)
	{
	char bname[50];

	assert (strlen (issuer_hash) == 40);
	memcpy (bname, "crl-", 4);
	memcpy (bname + 4, issuer_hash, 40);
	strcpy (bname + 44, ".db");
	return make_filename (opt.homedir_cache, DBDIR_D, bname, NULL);
	}


	/* Hash the file FNAME and return the MD5 digest in MD5BUFFER. The
	caller must allocate MD%buffer wityh at least 16 bytes. Returns 0
	on success. */
	static int
	hash_dbfile (const char fname, unsigned char md5buffer)
	{
	estream_t fp;
	char *buffer;
	size_t n;
	gcry_md_hd_t md5;
	gpg_error_t err;

	buffer = xtrymalloc (65536);
	fp = buffer? es_fopen (fname, "rb") : NULL;
	if (!fp)
	{
	log_error (_("can't hash '%s': %s\n"), fname, strerror (errno));
	xfree (buffer);
	return -1;
	}

	err = gcry_md_open (&md5, GCRY_MD_MD5, 0);
	if (err)
	{
	log_error (_("error setting up MD5 hash context: %s\n"),
	gpg_strerror (err));
	xfree (buffer);
	es_fclose (fp);
	return -1;
	}

	/* We better hash some information about the cache file layout in. */
	sprintf (buffer, "%.100s/%.100s:%d", DBDIR_D, DBDIRFILE, DBDIRVERSION);
	gcry_md_write (md5, buffer, strlen (buffer));

	for (;;)
	{
	n = es_fread (buffer, 1, 65536, fp);
	if (n < 65536 && es_ferror (fp))
	{
	log_error (_("error hashing '%s': %s\n"), fname, strerror (errno));
	xfree (buffer);
	es_fclose (fp);
	gcry_md_close (md5);
	return -1;
	}
	if (!n)
	break;
	gcry_md_write (md5, buffer, n);
	}
	es_fclose (fp);
	xfree (buffer);
	gcry_md_final (md5);

	memcpy (md5buffer, gcry_md_read (md5, GCRY_MD_MD5), 16);
	gcry_md_close (md5);
	return 0;
	}

	/* Compare the file FNAME against the dexified MD5 hash MD5HASH and
	return 0 if they match. */
	static int
	check_dbfile (const char fname, const char md5hexvalue)
	{
	unsigned char buffer1[16], buffer2[16];

	if (strlen (md5hexvalue) != 32)
	{
	log_error (_("invalid formatted checksum for '%s'\n"), fname);
	return -1;
	}
	unhexify (buffer1, md5hexvalue);

	if (hash_dbfile (fname, buffer2))
	return -1;

	return memcmp (buffer1, buffer2, 16);
	}


	/* Open the cache file for ENTRY. This function implements a caching
	strategy and might close unused cache files. It is required to use
	unlock_db_file after using the file. */
	static struct cdb *
	lock_db_file (crl_cache_t cache, crl_cache_entry_t entry)
	{
	char *fname;
	int fd;
	int open_count;
	crl_cache_entry_t e;

	if (entry->cdb)
	{
	entry->cdb_use_count++;
	return entry->cdb;
	}

	for (open_count = 0, e = cache->entries; e; e = e->next)
	{
	if (e->cdb)
	open_count++;
	/* log_debug ("CACHE: cdb=%p use_count=%u lru_count=%u\n", */
	/* e->cdb,e->cdb_use_count,e->cdb_lru_count); */
	}

	/* If there are too many file open, find the least recent used DB
	file and close it. Note that for Pth thread safeness we need to
	use a loop here. */
	while (open_count >= MAX_OPEN_DB_FILES )
	{
	crl_cache_entry_t last_e = NULL;
	unsigned int last_lru = (unsigned int)(-1);

	for (e = cache->entries; e; e = e->next)
	if (e->cdb && !e->cdb_use_count && e->cdb_lru_count < last_lru)
	{
	last_lru = e->cdb_lru_count;
	last_e = e;
	}
	if (!last_e)
	{
	log_error (_("too many open cache files; can't open anymore\n"));
	return NULL;
	}

	/* log_debug ("CACHE: closing file at cdb=%p\n", last_e->cdb); */

	fd = cdb_fileno (last_e->cdb);
	cdb_free (last_e->cdb);
	xfree (last_e->cdb);
	last_e->cdb = NULL;
	if (close (fd))
	log_error (_("error closing cache file: %s\n"), strerror(errno));
	open_count--;
	}


	fname = make_db_file_name (entry->issuer_hash);
	if (opt.verbose)
	log_info (_("opening cache file '%s'\n"), fname );

	if (!entry->dbfile_checked)
	{
	if (!check_dbfile (fname, entry->dbfile_hash))
	entry->dbfile_checked = 1;
	/* Note, in case of an error we don't print an error here but
	let require the caller to do that check. */
	}

	entry->cdb = xtrycalloc (1, sizeof *entry->cdb);
	if (!entry->cdb)
	{
	xfree (fname);
	return NULL;
	}
	fd = gnupg_open (fname, O_RDONLY \| O_BINARY, 0);
	if (fd == -1)
	{
	log_error (_("error opening cache file '%s': %s\n"),
	fname, strerror (errno));
	xfree (entry->cdb);
	entry->cdb = NULL;
	xfree (fname);
	return NULL;
	}
	if (cdb_init (entry->cdb, fd))
	{
	log_error (_("error initializing cache file '%s' for reading: %s\n"),
	fname, strerror (errno));
	xfree (entry->cdb);
	entry->cdb = NULL;
	close (fd);
	xfree (fname);
	return NULL;
	}
	xfree (fname);

	entry->cdb_use_count = 1;
	entry->cdb_lru_count = 0;

	return entry->cdb;
	}

	/* Unlock a cache file, so that it can be reused. */
	static void
	unlock_db_file (crl_cache_t cache, crl_cache_entry_t entry)
	{
	if (!entry->cdb)
	log_error (_("calling unlock_db_file on a closed file\n"));
	else if (!entry->cdb_use_count)
	log_error (_("calling unlock_db_file on an unlocked file\n"));
	else
	{
	entry->cdb_use_count--;
	entry->cdb_lru_count++;
	}

	/* If the entry was marked for deletion in the meantime do it now.
	We do this for the sake of Pth thread safeness. */
	if (!entry->cdb_use_count && entry->deleted)
	{
	crl_cache_entry_t eprev, enext;

	enext = entry->next;
	for (eprev = cache->entries;
	eprev && eprev->next != entry; eprev = eprev->next)
	;
	assert (eprev);
	if (eprev == cache->entries)
	cache->entries = enext;
	else
	eprev->next = enext;
	/* FIXME: Do we leak ENTRY? */
	}
	}


	/* Find ISSUER_HASH in our cache FIRST. This may be used to enumerate
	the linked list we use to keep the CRLs of an issuer. */
	static crl_cache_entry_t
	find_entry (crl_cache_entry_t first, const char *issuer_hash)
	{
	while (first && (first->deleted \|\| strcmp (issuer_hash, first->issuer_hash)))
	first = first->next;
	return first;
	}


	/* Create a new CRL cache. This function is usually called only once.
	never fail. */
	void
	crl_cache_init(void)
	{
	crl_cache_t cache = NULL;
	gpg_error_t err;

	if (current_cache)
	{
	log_error ("crl cache has already been initialized - not doing twice\n");
	return;
	}

	err = open_dir (&cache);
	if (err)
	log_fatal (_("failed to create a new cache object: %s\n"),
	gpg_strerror (err));
	current_cache = cache;
	}


	/* Remove the cache information and all its resources. Note that we
	still keep the cache on disk. */
	void
	crl_cache_deinit (void)
	{
	if (current_cache)
	{
	release_cache (current_cache);
	current_cache = NULL;
	}
	}


	/* Delete the cache from disk and memory. Return 0 on success.*/
	int
	crl_cache_flush (void)
	{
	int rc;

	crl_cache_deinit ();
	rc = cleanup_cache_dir (0)? -1 : 0;
	crl_cache_init ();

	return rc;
	}


	/* Check whether the certificate identified by ISSUER_HASH and
	SN/SNLEN is valid; i.e. not listed in our cache. With
	FORCE_REFRESH set to true, a new CRL will be retrieved even if the
	cache has not yet expired. We use a 30 minutes threshold here so
	that invoking this function several times won't load the CRL over
	and over. */
	static crl_cache_result_t
	cache_isvalid (ctrl_t ctrl, const char *issuer_hash,
	const unsigned char *sn, size_t snlen,
	int force_refresh)
	{
	crl_cache_t cache = get_current_cache ();
	crl_cache_result_t retval;
	struct cdb *cdb;
	int rc;
	crl_cache_entry_t entry;
	gnupg_isotime_t current_time;
	size_t n;

	(void)ctrl;

	entry = find_entry (cache->entries, issuer_hash);
	if (!entry)
	{
	log_info (_("no CRL available for issuer id %s\n"), issuer_hash );
	return CRL_CACHE_DONTKNOW;
	}

	gnupg_get_isotime (current_time);
	if (strcmp (entry->next_update, current_time) < 0 )
	{
	log_info (_("cached CRL for issuer id %s too old; update required\n"),
	issuer_hash);
	return CRL_CACHE_DONTKNOW;
	}
	if (force_refresh)
	{
	gnupg_isotime_t tmptime;

	if (*entry->last_refresh)
	{
	gnupg_copy_time (tmptime, entry->last_refresh);
	add_seconds_to_isotime (tmptime, 30 * 60);
	if (strcmp (tmptime, current_time) < 0 )
	{
	log_info (_("force-crl-refresh active and %d minutes passed for"
	" issuer id %s; update required\n"),
	30, issuer_hash);
	return CRL_CACHE_DONTKNOW;
	}
	}
	else
	{
	log_info (_("force-crl-refresh active for"
	" issuer id %s; update required\n"),
	issuer_hash);
	return CRL_CACHE_DONTKNOW;
	}
	}

	if (entry->invalid)
	{
	log_info (_("available CRL for issuer ID %s can't be used\n"),
	issuer_hash);
	return CRL_CACHE_CANTUSE;
	}

	cdb = lock_db_file (cache, entry);
	if (!cdb)
	return CRL_CACHE_DONTKNOW; /* Hmmm, not the best error code. */

	if (!entry->dbfile_checked)
	{
	log_error (_("cached CRL for issuer id %s tampered; we need to update\n")
	, issuer_hash);
	unlock_db_file (cache, entry);
	return CRL_CACHE_DONTKNOW;
	}

	rc = cdb_find (cdb, sn, snlen);
	if (rc == 1)
	{
	n = cdb_datalen (cdb);
	if (n != 16)
	{
	log_error (_("WARNING: invalid cache record length for S/N "));
	log_printf ("0x");
	log_printhex (sn, snlen, "");
	}
	else if (opt.verbose)
	{
	unsigned char record[16];
	char *tmp = hexify_data (sn, snlen, 1);

	if (cdb_read (cdb, record, n, cdb_datapos (cdb)))
	log_error (_("problem reading cache record for S/N %s: %s\n"),
	tmp, strerror (errno));
	else
	log_info (_("S/N %s is not valid; reason=%02X date=%.15s\n"),
	tmp, *record, record+1);
	xfree (tmp);
	}
	retval = CRL_CACHE_INVALID;
	}
	else if (!rc)
	{
	if (opt.verbose)
	{
	char *serialno = hexify_data (sn, snlen, 1);
	log_info (_("S/N %s is valid, it is not listed in the CRL\n"),
	serialno );
	xfree (serialno);
	}
	retval = CRL_CACHE_VALID;
	}
	else
	{
	log_error (_("error getting data from cache file: %s\n"),
	strerror (errno));
	retval = CRL_CACHE_DONTKNOW;
	}


	if (entry->user_trust_req
	&& (retval == CRL_CACHE_VALID \|\| retval == CRL_CACHE_INVALID))
	{
	if (!entry->check_trust_anchor)
	{
	log_error ("inconsistent data on user trust check\n");
	retval = CRL_CACHE_CANTUSE;
	}
	else if (get_istrusted_from_client (ctrl, entry->check_trust_anchor))
	{
	if (opt.verbose)
	log_info ("no system trust and client does not trust either\n");
	retval = CRL_CACHE_CANTUSE;
	}
	else
	{
	/* Okay, the CRL is considered valid by the client and thus
	we can return the result as is. */
	}
	}

	unlock_db_file (cache, entry);

	return retval;
	}


	/* Check whether the certificate identified by ISSUER_HASH and
	SERIALNO is valid; i.e. not listed in our cache. With
	FORCE_REFRESH set to true, a new CRL will be retrieved even if the
	cache has not yet expired. We use a 30 minutes threshold here so
	that invoking this function several times won't load the CRL over
	and over. */
	crl_cache_result_t
	crl_cache_isvalid (ctrl_t ctrl, const char issuer_hash, const char serialno,
	int force_refresh)
	{
	crl_cache_result_t result;
	unsigned char snbuf_buffer[50];
	unsigned char *snbuf;
	size_t n;

	n = strlen (serialno)/2+1;
	if (n < sizeof snbuf_buffer - 1)
	snbuf = snbuf_buffer;
	else
	{
	snbuf = xtrymalloc (n);
	if (!snbuf)
	return CRL_CACHE_DONTKNOW;
	}

	n = unhexify (snbuf, serialno);

	result = cache_isvalid (ctrl, issuer_hash, snbuf, n, force_refresh);

	if (snbuf != snbuf_buffer)
	xfree (snbuf);

	return result;
	}


	/* Check whether the certificate CERT is valid; i.e. not listed in our
	cache. With FORCE_REFRESH set to true, a new CRL will be retrieved
	even if the cache has not yet expired. We use a 30 minutes
	threshold here so that invoking this function several times won't
	load the CRL over and over. */
	gpg_error_t
	crl_cache_cert_isvalid (ctrl_t ctrl, ksba_cert_t cert,
	int force_refresh)
	{
	gpg_error_t err;
	crl_cache_result_t result;
	unsigned char issuerhash[20];
	char issuerhash_hex[41];
	ksba_sexp_t serial;
	unsigned char *sn;
	size_t snlen;
	char endp, tmp;
	int i;

	/* Compute the hash value of the issuer name. */
	tmp = ksba_cert_get_issuer (cert, 0);
	if (!tmp)
	{
	log_error ("oops: issuer missing in certificate\n");
	return gpg_error (GPG_ERR_INV_CERT_OBJ);
	}
	gcry_md_hash_buffer (GCRY_MD_SHA1, issuerhash, tmp, strlen (tmp));
	xfree (tmp);
	for (i=0,tmp=issuerhash_hex; i < 20; i++, tmp += 2)
	sprintf (tmp, "%02X", issuerhash[i]);

	/* Get the serial number. */
	serial = ksba_cert_get_serial (cert);
	if (!serial)
	{
	log_error ("oops: S/N missing in certificate\n");
	return gpg_error (GPG_ERR_INV_CERT_OBJ);
	}
	sn = serial;
	if (*sn != '(')
	{
	log_error ("oops: invalid S/N\n");
	xfree (serial);
	return gpg_error (GPG_ERR_INV_CERT_OBJ);
	}
	sn++;
	snlen = strtoul (sn, &endp, 10);
	sn = endp;
	if (*sn != ':')
	{
	log_error ("oops: invalid S/N\n");
	xfree (serial);
	return gpg_error (GPG_ERR_INV_CERT_OBJ);
	}
	sn++;

	/* Check the cache. */
	result = cache_isvalid (ctrl, issuerhash_hex, sn, snlen, force_refresh);
	switch (result)
	{
	case CRL_CACHE_VALID:
	err = 0;
	break;
	case CRL_CACHE_INVALID:
	err = gpg_error (GPG_ERR_CERT_REVOKED);
	break;
	case CRL_CACHE_DONTKNOW:
	err = gpg_error (GPG_ERR_NO_CRL_KNOWN);
	break;
	case CRL_CACHE_CANTUSE:
	err = gpg_error (GPG_ERR_NO_CRL_KNOWN);
	break;
	default:
	log_fatal ("cache_isvalid returned invalid status code %d\n", result);
	}

	xfree (serial);
	return err;
	}


	/* Return the hash algorithm's algo id from its name given in the
	* non-null termnated string in (buffer,buflen). Returns 0 on failure
	* or if the algo is not known. */
	static int
	hash_algo_from_buffer (const void *buffer, size_t buflen)
	{
	char *string;
	int algo;

	string = xtrymalloc (buflen + 1);
	if (!string)
	{
	log_error (_("out of core\n"));
	return 0;
	}
	memcpy (string, buffer, buflen);
	string[buflen] = 0;
	algo = gcry_md_map_name (string);
	if (!algo)
	log_error ("unknown digest algorithm '%s' used in certificate\n", string);
	xfree (string);
	return algo;
	}


	/* Return an unsigned integer from the non-null termnated string
	* (buffer,buflen). Returns 0 on failure. */
	static unsigned int
	uint_from_buffer (const void *buffer, size_t buflen)
	{
	char *string;
	unsigned int val;

	string = xtrymalloc (buflen + 1);
	if (!string)
	{
	log_error (_("out of core\n"));
	return 0;
	}
	memcpy (string, buffer, buflen);
	string[buflen] = 0;
	val = strtoul (string, NULL, 10);
	xfree (string);
	return val;
	}


	/* Prepare a hash context for the signature verification. Input is
	the CRL and the output is the hash context MD as well as the uses
	algorithm identifier ALGO. */
	static gpg_error_t
	start_sig_check (ksba_crl_t crl, gcry_md_hd_t md, int algo, int *use_pss)
	{
	gpg_error_t err;
	const char *algoid;

	*use_pss = 0;
	algoid = ksba_crl_get_digest_algo (crl);
	if (algoid && !strcmp (algoid, "1.2.840.113549.1.1.10"))
	{
	/* Parse rsaPSS parameter. */
	gcry_buffer_t ioarray[1] = { {0} };
	ksba_sexp_t pssparam;
	size_t n;
	gcry_sexp_t psssexp;

	pssparam = ksba_crl_get_sig_val (crl);
	n = gcry_sexp_canon_len (pssparam, 0, NULL, NULL);
	if (!n)
	{
	ksba_free (pssparam);
	log_error (_("got an invalid S-expression from libksba\n"));
	return gpg_error (GPG_ERR_INV_SEXP);
	}
	err = gcry_sexp_sscan (&psssexp, NULL, pssparam, n);
	ksba_free (pssparam);
	if (err)
	{
	log_error (_("converting S-expression failed: %s\n"),
	gcry_strerror (err));
	return err;
	}

	err = gcry_sexp_extract_param (psssexp, "sig-val",
	"&'hash-algo'", ioarray, NULL);
	gcry_sexp_release (psssexp);
	if (err)
	{
	log_error ("extracting params from PSS failed: %s\n",
	gpg_strerror (err));
	return err;
	}
	*algo = hash_algo_from_buffer (ioarray[0].data, ioarray[0].len);
	xfree (ioarray[0].data);
	*use_pss = 1;
	}
	else
	*algo = gcry_md_map_name (algoid);
	if (!*algo && algoid)
	{
	if (!strcmp (algoid, "1.2.840.10045.4.3.1"))
	algo = GCRY_MD_SHA224; / ecdsa-with-sha224 */
	else if (!strcmp (algoid, "1.2.840.10045.4.3.2"))
	algo = GCRY_MD_SHA256; / ecdsa-with-sha256 */
	else if (!strcmp (algoid, "1.2.840.10045.4.3.3"))
	algo = GCRY_MD_SHA384; / ecdsa-with-sha384 */
	else if (!strcmp (algoid, "1.2.840.10045.4.3.4"))
	algo = GCRY_MD_SHA512; / ecdsa-with-sha512 */
	}
	if (!*algo)
	{
	log_debug ("XXXXX %s: %s <%s>\n",
	__func__, gpg_strerror (err), gpg_strsource (err));
	log_error (_("unknown hash algorithm '%s'\n"), algoid? algoid:"?");
	return gpg_error (GPG_ERR_DIGEST_ALGO);
	}

	err = gcry_md_open (md, *algo, 0);
	if (err)
	{
	log_error (_("gcry_md_open for algorithm %d failed: %s\n"),
	*algo, gcry_strerror (err));
	return err;
	}
	if (DBG_HASHING)
	gcry_md_debug (*md, "hash.cert");

	ksba_crl_set_hash_function (crl, HASH_FNC, *md);
	return 0;
	}


	/* Finish a hash context and verify the signature. This function
	should return 0 on a good signature, GPG_ERR_BAD_SIGNATURE if the
	signature does not verify or any other error code. CRL is the CRL
	object we are working on, MD the hash context and ISSUER_CERT the
	certificate of the CRL issuer. This function takes ownership of MD. */
	static gpg_error_t
	finish_sig_check (ksba_crl_t crl, gcry_md_hd_t md, int algo,
	ksba_cert_t issuer_cert, int use_pss)
	{
	gpg_error_t err;
	ksba_sexp_t sigval = NULL, pubkey = NULL;
	size_t n;
	gcry_sexp_t s_sig = NULL, s_hash = NULL, s_pkey = NULL;
	unsigned int saltlen = 0; /* (used only with use_pss) */
	int pkalgo;

	/* This also stops debugging on the MD. */
	gcry_md_final (md);

	/* Get and convert the signature value. */
	sigval = ksba_crl_get_sig_val (crl);
	n = gcry_sexp_canon_len (sigval, 0, NULL, NULL);
	if (!n)
	{
	log_error (_("got an invalid S-expression from libksba\n"));
	err = gpg_error (GPG_ERR_INV_SEXP);
	goto leave;
	}
	err = gcry_sexp_sscan (&s_sig, NULL, sigval, n);
	if (err)
	{
	log_error (_("converting S-expression failed: %s\n"),
	gcry_strerror (err));
	goto leave;
	}

	if (use_pss)
	{
	/* Parse rsaPSS parameter which we should find in S_SIG. */
	gcry_buffer_t ioarray[2] = { {0}, {0} };
	ksba_sexp_t pssparam;
	gcry_sexp_t psssexp;
	int hashalgo;

	pssparam = ksba_crl_get_sig_val (crl);
	n = gcry_sexp_canon_len (pssparam, 0, NULL, NULL);
	if (!n)
	{
	ksba_free (pssparam);
	log_error (_("got an invalid S-expression from libksba\n"));
	err = gpg_error (GPG_ERR_INV_SEXP);
	goto leave;
	}
	err = gcry_sexp_sscan (&psssexp, NULL, pssparam, n);
	ksba_free (pssparam);
	if (err)
	{
	log_error (_("converting S-expression failed: %s\n"),
	gcry_strerror (err));
	goto leave;
	}

	err = gcry_sexp_extract_param (psssexp, "sig-val",
	"&'hash-algo''salt-length'",
	ioarray+0, ioarray+1, NULL);
	gcry_sexp_release (psssexp);
	if (err)
	{
	log_error ("extracting params from PSS failed: %s\n",
	gpg_strerror (err));
	goto leave;
	}
	hashalgo = hash_algo_from_buffer (ioarray[0].data, ioarray[0].len);
	saltlen = uint_from_buffer (ioarray[1].data, ioarray[1].len);
	xfree (ioarray[0].data);
	xfree (ioarray[1].data);
	if (hashalgo != algo)
	{
	log_error ("hash algo mismatch: %d announced but %d used\n",
	algo, hashalgo);
	return gpg_error (GPG_ERR_INV_CRL);
	}
	/* Add some restrictions; see ../sm/certcheck.c for details. */
	switch (algo)
	{
	case GCRY_MD_SHA1:
	case GCRY_MD_SHA256:
	case GCRY_MD_SHA384:
	case GCRY_MD_SHA512:
	case GCRY_MD_SHA3_256:
	case GCRY_MD_SHA3_384:
	case GCRY_MD_SHA3_512:
	break;
	default:
	log_error ("PSS hash algorithm '%s' rejected\n",
	gcry_md_algo_name (algo));
	return gpg_error (GPG_ERR_DIGEST_ALGO);
	}

	if (gcry_md_get_algo_dlen (algo) != saltlen)
	{
	log_error ("PSS hash algorithm '%s' rejected due to salt length %u\n",
	gcry_md_algo_name (algo), saltlen);
	return gpg_error (GPG_ERR_DIGEST_ALGO);
	}
	}


	/* Get and convert the public key for the issuer certificate. */
	if (DBG_X509)
	dump_cert ("crl_issuer_cert", issuer_cert);
	pubkey = ksba_cert_get_public_key (issuer_cert);
	n = gcry_sexp_canon_len (pubkey, 0, NULL, NULL);
	if (!n)
	{
	log_error (_("got an invalid S-expression from libksba\n"));
	err = gpg_error (GPG_ERR_INV_SEXP);
	goto leave;
	}
	err = gcry_sexp_sscan (&s_pkey, NULL, pubkey, n);
	if (err)
	{
	log_error (_("converting S-expression failed: %s\n"),
	gcry_strerror (err));
	goto leave;
	}

	/* Create an S-expression with the actual hash value. */
	if (use_pss)
	{
	err = gcry_sexp_build (&s_hash, NULL,
	"(data (flags pss)"
	"(hash %s %b)"
	"(salt-length %u))",
	hash_algo_to_string (algo),
	(int)gcry_md_get_algo_dlen (algo),
	gcry_md_read (md, algo),
	saltlen);
	}
	else if ((pkalgo = pk_algo_from_sexp (s_pkey)) == GCRY_PK_ECC)
	{
	unsigned int qbits0, qbits;

	qbits0 = gcry_pk_get_nbits (s_pkey);
	qbits = qbits0 == 521? 512 : qbits0;

	if ((qbits%8))
	{
	log_error ("ECDSA requires the hash length to be a"
	" multiple of 8 bits\n");
	err = gpg_error (GPG_ERR_INTERNAL);
	goto leave;
	}

	/* Don't allow any Q smaller than 160 bits. */
	if (qbits < 160)
	{
	log_error (_("%s key uses an unsafe (%u bit) hash\n"),
	gcry_pk_algo_name (pkalgo), qbits0);
	err = gpg_error (GPG_ERR_INTERNAL);
	goto leave;
	}

	/* Check if we're too short. */
	n = gcry_md_get_algo_dlen (algo);
	if (n < qbits/8)
	{
	log_error (_("a %u bit hash is not valid for a %u bit %s key\n"),
	(unsigned int)n*8,
	qbits0,
	gcry_pk_algo_name (pkalgo));
	if (n < 20)
	{
	err = gpg_error (GPG_ERR_INTERNAL);
	goto leave;
	}
	}

	/* Truncate. */
	if (n > qbits/8)
	n = qbits/8;

	- err = gcry_sexp_build (&s_hash, NULL, "%b",
	+ err = gcry_sexp_build (&s_hash, NULL, "(data(flags raw)(value %b))",
	(int)n,
	gcry_md_read (md, algo));
	+
	}
	else
	{
	err = gcry_sexp_build (&s_hash, NULL,
	"(data(flags pkcs1)(hash %s %b))",
	hash_algo_to_string (algo),
	(int)gcry_md_get_algo_dlen (algo),
	gcry_md_read (md, algo));
	}
	if (err)
	{
	log_error (_("creating S-expression failed: %s\n"), gcry_strerror (err));
	goto leave;
	}

	/* Pass this on to the signature verification. */
	err = gcry_pk_verify (s_sig, s_hash, s_pkey);
	if (DBG_X509)
	- log_debug ("gcry_pk_verify: %s\n", gpg_strerror (err));
	+ log_debug ("%s: gcry_pk_verify: %s\n", __func__, gpg_strerror (err));

	leave:
	xfree (sigval);
	xfree (pubkey);
	gcry_sexp_release (s_sig);
	gcry_sexp_release (s_hash);
	gcry_sexp_release (s_pkey);
	gcry_md_close (md);

	return err;
	}


	/* Call this to match a start_sig_check that can not be completed
	normally. Takes ownership of MD if MD is not NULL. */
	static void
	abort_sig_check (ksba_crl_t crl, gcry_md_hd_t md)
	{
	(void)crl;
	if (md)
	gcry_md_close (md);
	}


	/* Workhorse of the CRL loading machinery. The CRL is read using the
	CRL object and stored in the data base file DB with the name FNAME
	(only used for printing error messages). That DB should be a
	temporary one and not the actual one. If the function fails the
	caller should delete this temporary database file. CTRL is
	required to retrieve certificates using the general dirmngr
	callback service. R_CRLISSUER returns an allocated string with the
	crl-issuer DN, THIS_UPDATE and NEXT_UPDATE are filled with the
	corresponding data from the CRL. Note that these values might get
	set even if the CRL processing fails at a later step; thus the
	caller should free *R_ISSUER even if the function returns with an
	error. R_TRUST_ANCHOR is set on exit to NULL or a string with the
	hexified fingerprint of the root certificate, if checking this
	certificate for trustiness is required.
	*/
	static int
	crl_parse_insert (ctrl_t ctrl, ksba_crl_t crl,
	struct cdb_make cdb, const char fname,
	char **r_crlissuer,
	ksba_isotime_t thisupdate, ksba_isotime_t nextupdate,
	char **r_trust_anchor)
	{
	gpg_error_t err;
	ksba_stop_reason_t stopreason;
	ksba_cert_t crlissuer_cert = NULL;
	gcry_md_hd_t md = NULL;
	int algo = 0;
	int use_pss = 0;
	size_t n;

	(void)fname;

	*r_crlissuer = NULL;
	thisupdate = nextupdate = 0;
	*r_trust_anchor = NULL;

	/* Start of the KSBA parser loop. */
	do
	{
	err = ksba_crl_parse (crl, &stopreason);
	if (err)
	{
	log_error (_("ksba_crl_parse failed: %s\n"), gpg_strerror (err) );
	goto failure;
	}

	switch (stopreason)
	{
	case KSBA_SR_BEGIN_ITEMS:
	{
	err = start_sig_check (crl, &md, &algo, &use_pss);
	if (err)
	goto failure;

	err = ksba_crl_get_update_times (crl, thisupdate, nextupdate);
	if (err)
	{
	log_error (_("error getting update times of CRL: %s\n"),
	gpg_strerror (err));
	err = gpg_error (GPG_ERR_INV_CRL);
	goto failure;
	}

	if (opt.verbose \|\| !*nextupdate)
	log_info (_("update times of this CRL: this=%s next=%s\n"),
	thisupdate, nextupdate);
	if (!*nextupdate)
	{
	log_info (_("nextUpdate not given; "
	"assuming a validity period of one day\n"));
	gnupg_copy_time (nextupdate, thisupdate);
	add_seconds_to_isotime (nextupdate, 86400);
	}
	}
	break;

	case KSBA_SR_GOT_ITEM:
	{
	ksba_sexp_t serial;
	const unsigned char *p;
	ksba_isotime_t rdate;
	ksba_crl_reason_t reason;
	int rc;
	unsigned char record[1+15];

	err = ksba_crl_get_item (crl, &serial, rdate, &reason);
	if (err)
	{
	log_error (_("error getting CRL item: %s\n"),
	gpg_strerror (err));
	err = gpg_error (GPG_ERR_INV_CRL);
	ksba_free (serial);
	goto failure;
	}
	p = serial_to_buffer (serial, &n);
	if (!p)
	BUG ();
	record[0] = (reason & 0xff);
	memcpy (record+1, rdate, 15);
	rc = cdb_make_add (cdb, p, n, record, 1+15);
	if (rc)
	{
	err = gpg_error_from_errno (errno);
	log_error (_("error inserting item into "
	"temporary cache file: %s\n"),
	strerror (errno));
	goto failure;
	}

	ksba_free (serial);
	}
	break;

	case KSBA_SR_END_ITEMS:
	break;

	case KSBA_SR_READY:
	{
	char *crlissuer;
	ksba_name_t authid;
	ksba_sexp_t authidsn;
	ksba_sexp_t keyid;

	/* We need to look for the issuer only after having read
	all items. The issuer itselfs comes before the items
	but the optional authorityKeyIdentifier comes after the
	items. */
	err = ksba_crl_get_issuer (crl, &crlissuer);
	if( err )
	{
	log_error (_("no CRL issuer found in CRL: %s\n"),
	gpg_strerror (err) );
	err = gpg_error (GPG_ERR_INV_CRL);
	goto failure;
	}
	/* Note: This should be released by ksba_free, not xfree.
	May need a memory reallocation dance. */
	r_crlissuer = crlissuer; / (Do it here so we don't need
	to free it later) */

	if (!ksba_crl_get_auth_key_id (crl, &keyid, &authid, &authidsn))
	{
	const char *s;

	if (opt.verbose)
	log_info (_("locating CRL issuer certificate by "
	"authorityKeyIdentifier\n"));

	s = ksba_name_enum (authid, 0);
	if (s && *authidsn)
	crlissuer_cert = find_cert_bysn (ctrl, s, authidsn);
	if (!crlissuer_cert && keyid)
	crlissuer_cert = find_cert_bysubject (ctrl,
	crlissuer, keyid);

	if (!crlissuer_cert)
	{
	log_info ("CRL issuer certificate ");
	if (keyid)
	{
	log_printf ("{");
	dump_serial (keyid);
	log_printf ("} ");
	}
	if (authidsn)
	{
	log_printf ("(#");
	dump_serial (authidsn);
	log_printf ("/");
	dump_string (s);
	log_printf (") ");
	}
	log_printf ("not found\n");
	}
	ksba_name_release (authid);
	xfree (authidsn);
	xfree (keyid);
	}
	else
	crlissuer_cert = find_cert_bysubject (ctrl, crlissuer, NULL);
	err = 0;
	if (!crlissuer_cert)
	{
	err = gpg_error (GPG_ERR_MISSING_CERT);
	goto failure;
	}

	err = finish_sig_check (crl, md, algo, crlissuer_cert, use_pss);
	md = NULL; /* Closed. */
	if (err)
	{
	log_error (_("CRL signature verification failed: %s\n"),
	gpg_strerror (err));
	goto failure;
	}

	err = validate_cert_chain (ctrl, crlissuer_cert, NULL,
	(VALIDATE_FLAG_TRUST_CONFIG
	\| VALIDATE_FLAG_CRL
	\| VALIDATE_FLAG_RECURSIVE),
	r_trust_anchor);
	if (err)
	{
	log_error (_("error checking validity of CRL "
	"issuer certificate: %s\n"),
	gpg_strerror (err));
	goto failure;
	}

	}
	break;

	default:
	log_debug ("crl_parse_insert: unknown stop reason\n");
	err = gpg_error (GPG_ERR_BUG);
	goto failure;
	}
	}
	while (stopreason != KSBA_SR_READY);
	assert (!err);


	failure:
	abort_sig_check (crl, md);
	ksba_cert_release (crlissuer_cert);
	return err;
	}



	/* Return the crlNumber extension as an allocated hex string or NULL
	if there is none. */
	static char *
	get_crl_number (ksba_crl_t crl)
	{
	gpg_error_t err;
	ksba_sexp_t number;
	char *string;

	err = ksba_crl_get_crl_number (crl, &number);
	if (err)
	return NULL;
	string = serial_hex (number);
	ksba_free (number);
	return string;
	}


	/* Return the authorityKeyIdentifier or NULL if it is not available.
	The issuer name may consists of several parts - they are delimted by
	0x01. */
	static char *
	get_auth_key_id (ksba_crl_t crl, char **serialno)
	{
	gpg_error_t err;
	ksba_name_t name;
	ksba_sexp_t sn;
	int idx;
	const char *s;
	char *string;
	size_t length;

	*serialno = NULL;
	err = ksba_crl_get_auth_key_id (crl, NULL, &name, &sn);
	if (err)
	return NULL;
	*serialno = serial_hex (sn);
	ksba_free (sn);

	if (!name)
	return xstrdup ("");

	length = 0;
	for (idx=0; (s = ksba_name_enum (name, idx)); idx++)
	{
	char *p = ksba_name_get_uri (name, idx);
	length += strlen (p?p:s) + 1;
	xfree (p);
	}
	string = xtrymalloc (length+1);
	if (string)
	{
	*string = 0;
	for (idx=0; (s = ksba_name_enum (name, idx)); idx++)
	{
	char *p = ksba_name_get_uri (name, idx);
	if (*string)
	strcat (string, "\x01");
	strcat (string, p?p:s);
	xfree (p);
	}
	}
	ksba_name_release (name);
	return string;
	}



	/* Insert the CRL retrieved using URL into the cache specified by
	CACHE. The CRL itself will be read from the stream FP and is
	expected in binary format.

	Called by:
	crl_cache_load
	cmd_loadcrl
	--load-crl
	crl_cache_reload_crl
	cmd_isvalid
	cmd_checkcrl
	cmd_loadcrl
	--fetch-crl

	*/
	gpg_error_t
	crl_cache_insert (ctrl_t ctrl, const char *url, ksba_reader_t reader)
	{
	crl_cache_t cache = get_current_cache ();
	gpg_error_t err, err2;
	ksba_crl_t crl;
	char *fname = NULL;
	char *newfname = NULL;
	struct cdb_make cdb;
	int fd_cdb = -1;
	char *issuer = NULL;
	char *issuer_hash = NULL;
	ksba_isotime_t thisupdate, nextupdate;
	crl_cache_entry_t entry = NULL;
	crl_cache_entry_t e;
	gnupg_isotime_t current_time;
	char *checksum = NULL;
	int invalidate_crl = 0;
	int idx;
	const char *oid;
	int critical;
	char *trust_anchor = NULL;

	/* FIXME: We should acquire a mutex for the URL, so that we don't
	simultaneously enter the same CRL twice. However this needs to be
	interweaved with the checking function.*/

	err2 = 0;

	err = ksba_crl_new (&crl);
	if (err)
	{
	log_error (_("ksba_crl_new failed: %s\n"), gpg_strerror (err));
	goto leave;
	}

	err = ksba_crl_set_reader (crl, reader);
	if ( err )
	{
	log_error (_("ksba_crl_set_reader failed: %s\n"), gpg_strerror (err));
	goto leave;
	}

	/* Create a temporary cache file to load the CRL into. */
	{
	char tmpfname, p;
	const char *nodename;
	#ifndef HAVE_W32_SYSTEM
	struct utsname utsbuf;
	#endif

	#ifdef HAVE_W32_SYSTEM
	nodename = "unknown";
	#else
	if (uname (&utsbuf))
	nodename = "unknown";
	else
	nodename = utsbuf.nodename;
	#endif

	gpgrt_asprintf (&tmpfname, "crl-tmp-%s-%u-%p.db.tmp",
	nodename, (unsigned int)getpid (), &tmpfname);
	if (!tmpfname)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	for (p=tmpfname; *p; p++)
	if (*p == '/')
	*p = '.';
	fname = make_filename (opt.homedir_cache, DBDIR_D, tmpfname, NULL);
	xfree (tmpfname);
	if (!gnupg_remove (fname))
	log_info (_("removed stale temporary cache file '%s'\n"), fname);
	else if (errno != ENOENT)
	{
	err = gpg_error_from_syserror ();
	log_error (_("problem removing stale temporary cache file '%s': %s\n"),
	fname, gpg_strerror (err));
	goto leave;
	}
	}

	fd_cdb = gnupg_open (fname, O_WRONLY \| O_CREAT \| O_TRUNC \| O_BINARY, 0644);
	if (fd_cdb == -1)
	{
	err = gpg_error_from_errno (errno);
	log_error (_("error creating temporary cache file '%s': %s\n"),
	fname, strerror (errno));
	goto leave;
	}
	cdb_make_start(&cdb, fd_cdb);

	err = crl_parse_insert (ctrl, crl, &cdb, fname,
	&issuer, thisupdate, nextupdate, &trust_anchor);
	if (err)
	{
	log_error (_("crl_parse_insert failed: %s\n"), gpg_strerror (err));
	/* Error in cleanup ignored. */
	cdb_make_finish (&cdb);
	goto leave;
	}

	/* Finish the database. */
	if (cdb_make_finish (&cdb))
	{
	err = gpg_error_from_errno (errno);
	log_error (_("error finishing temporary cache file '%s': %s\n"),
	fname, strerror (errno));
	goto leave;
	}
	if (close (fd_cdb))
	{
	err = gpg_error_from_errno (errno);
	log_error (_("error closing temporary cache file '%s': %s\n"),
	fname, strerror (errno));
	goto leave;
	}
	fd_cdb = -1;


	/* Create a checksum. */
	{
	unsigned char md5buf[16];

	if (hash_dbfile (fname, md5buf))
	{
	err = gpg_error (GPG_ERR_CHECKSUM);
	goto leave;
	}
	checksum = hexify_data (md5buf, 16, 0);
	}


	/* Check whether that new CRL is still not expired. */
	gnupg_get_isotime (current_time);
	if (strcmp (nextupdate, current_time) < 0 )
	{
	if (opt.force)
	log_info (_("WARNING: new CRL still too old; it expired on %s "
	"- loading anyway\n"), nextupdate);
	else
	{
	log_error (_("new CRL still too old; it expired on %s\n"),
	nextupdate);
	if (!err2)
	err2 = gpg_error (GPG_ERR_CRL_TOO_OLD);
	invalidate_crl \|= 1;
	}
	}

	/* Check for unknown critical extensions. */
	for (idx=0; !(err=ksba_crl_get_extension (crl, idx, &oid, &critical,
	NULL, NULL)); idx++)
	{
	if (!critical
	\|\| !strcmp (oid, oidstr_authorityKeyIdentifier)
	\|\| !strcmp (oid, oidstr_crlNumber) )
	continue;
	log_error (_("unknown critical CRL extension %s\n"), oid);
	if (!err2)
	err2 = gpg_error (GPG_ERR_INV_CRL);
	invalidate_crl \|= 2;
	}
	if (gpg_err_code (err) == GPG_ERR_EOF
	\|\| gpg_err_code (err) == GPG_ERR_NO_DATA )
	err = 0;
	if (err)
	{
	log_error (_("error reading CRL extensions: %s\n"), gpg_strerror (err));
	err = gpg_error (GPG_ERR_INV_CRL);
	}


	/* Create an hex encoded SHA-1 hash of the issuer DN to be
	used as the key for the cache. */
	issuer_hash = hashify_data (issuer, strlen (issuer));

	/* Create an ENTRY. */
	entry = xtrycalloc (1, sizeof *entry);
	if (!entry)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	entry->release_ptr = xtrymalloc (strlen (issuer_hash) + 1
	+ strlen (issuer) + 1
	+ strlen (url) + 1
	+ strlen (checksum) + 1);
	if (!entry->release_ptr)
	{
	err = gpg_error_from_syserror ();
	xfree (entry);
	entry = NULL;
	goto leave;
	}
	entry->issuer_hash = entry->release_ptr;
	entry->issuer = stpcpy (entry->issuer_hash, issuer_hash) + 1;
	entry->url = stpcpy (entry->issuer, issuer) + 1;
	entry->dbfile_hash = stpcpy (entry->url, url) + 1;
	strcpy (entry->dbfile_hash, checksum);
	gnupg_copy_time (entry->this_update, thisupdate);
	gnupg_copy_time (entry->next_update, nextupdate);
	gnupg_copy_time (entry->last_refresh, current_time);
	entry->crl_number = get_crl_number (crl);
	entry->authority_issuer = get_auth_key_id (crl, &entry->authority_serialno);
	entry->invalid = invalidate_crl;
	entry->user_trust_req = !!trust_anchor;
	entry->check_trust_anchor = trust_anchor;
	trust_anchor = NULL;

	/* Check whether we already have an entry for this issuer and mark
	it as deleted. We better use a loop, just in case duplicates got
	somehow into the list. */
	for (e = cache->entries; (e=find_entry (e, entry->issuer_hash)); e = e->next)
	e->deleted = 1;

	/* Rename the temporary DB to the real name. */
	newfname = make_db_file_name (entry->issuer_hash);
	if (opt.verbose)
	log_info (_("creating cache file '%s'\n"), newfname);

	/* Just in case close unused matching files. Actually we need this
	only under Windows but saving file descriptors is never bad. */
	{
	int any;
	do
	{
	any = 0;
	for (e = cache->entries; e; e = e->next)
	if (!e->cdb_use_count && e->cdb
	&& !strcmp (e->issuer_hash, entry->issuer_hash))
	{
	int fd = cdb_fileno (e->cdb);
	cdb_free (e->cdb);
	xfree (e->cdb);
	e->cdb = NULL;
	if (close (fd))
	log_error (_("error closing cache file: %s\n"),
	strerror(errno));
	any = 1;
	break;
	}
	}
	while (any);
	}
	#ifdef HAVE_W32_SYSTEM
	gnupg_remove (newfname);
	#endif
	if (rename (fname, newfname))
	{
	err = gpg_error_from_syserror ();
	log_error (_("problem renaming '%s' to '%s': %s\n"),
	fname, newfname, gpg_strerror (err));
	goto leave;
	}
	xfree (fname); fname = NULL; /(let the cleanup code not try to remove it)/

	/* Link the new entry in. */
	entry->next = cache->entries;
	cache->entries = entry;
	entry = NULL;

	err = update_dir (cache);
	if (err)
	{
	log_error (_("updating the DIR file failed - "
	"cache entry will get lost with the next program start\n"));
	err = 0; /* Keep on running. */
	}


	leave:
	release_one_cache_entry (entry);
	if (fd_cdb != -1)
	close (fd_cdb);
	if (fname)
	{
	gnupg_remove (fname);
	xfree (fname);
	}
	xfree (newfname);
	ksba_crl_release (crl);
	xfree (issuer);
	xfree (issuer_hash);
	xfree (checksum);
	xfree (trust_anchor);
	return err ? err : err2;
	}


	/* Print one cached entry E in a human readable format to stream
	FP. Return 0 on success. */
	static gpg_error_t
	list_one_crl_entry (crl_cache_t cache, crl_cache_entry_t e, estream_t fp)
	{
	struct cdb_find cdbfp;
	struct cdb *cdb;
	int rc;
	int warn = 0;
	const unsigned char *s;

	es_fputs ("--------------------------------------------------------\n", fp );
	es_fprintf (fp, _("Begin CRL dump (retrieved via %s)\n"), e->url );
	es_fprintf (fp, " Issuer:\t%s\n", e->issuer );
	es_fprintf (fp, " Issuer Hash:\t%s\n", e->issuer_hash );
	es_fprintf (fp, " This Update:\t%s\n", e->this_update );
	es_fprintf (fp, " Next Update:\t%s\n", e->next_update );
	es_fprintf (fp, " CRL Number :\t%s\n", e->crl_number? e->crl_number: "none");
	es_fprintf (fp, " AuthKeyId :\t%s\n",
	e->authority_serialno? e->authority_serialno:"none");
	if (e->authority_serialno && e->authority_issuer)
	{
	es_fputs (" \t", fp);
	for (s=e->authority_issuer; *s; s++)
	if (*s == '\x01')
	es_fputs ("\n \t", fp);
	else
	es_putc (*s, fp);
	es_putc ('\n', fp);
	}
	es_fprintf (fp, " Trust Check:\t%s\n",
	!e->user_trust_req? "[system]" :
	e->check_trust_anchor? e->check_trust_anchor:"[missing]");

	if ((e->invalid & 1))
	es_fprintf (fp, _(" ERROR: The CRL will not be used "
	"because it was still too old after an update!\n"));
	if ((e->invalid & 2))
	es_fprintf (fp, _(" ERROR: The CRL will not be used "
	"due to an unknown critical extension!\n"));
	if ((e->invalid & ~3))
	es_fprintf (fp, _(" ERROR: The CRL will not be used\n"));

	cdb = lock_db_file (cache, e);
	if (!cdb)
	return gpg_error (GPG_ERR_GENERAL);

	if (!e->dbfile_checked)
	es_fprintf (fp, _(" ERROR: This cached CRL may have been tampered with!\n"));

	es_putc ('\n', fp);

	rc = cdb_findinit (&cdbfp, cdb, NULL, 0);
	while (!rc && (rc=cdb_findnext (&cdbfp)) > 0 )
	{
	unsigned char keyrecord[256];
	unsigned char record[16];
	int reason;
	int any = 0;
	cdbi_t n;
	cdbi_t i;

	rc = 0;
	n = cdb_datalen (cdb);
	if (n != 16)
	{
	log_error (_(" WARNING: invalid cache record length\n"));
	warn = 1;
	continue;
	}

	if (cdb_read (cdb, record, n, cdb_datapos (cdb)))
	{
	log_error (_("problem reading cache record: %s\n"),
	strerror (errno));
	warn = 1;
	continue;
	}

	n = cdb_keylen (cdb);
	if (n > sizeof keyrecord)
	n = sizeof keyrecord;
	if (cdb_read (cdb, keyrecord, n, cdb_keypos (cdb)))
	{
	log_error (_("problem reading cache key: %s\n"), strerror (errno));
	warn = 1;
	continue;
	}

	reason = *record;
	es_fputs (" ", fp);
	for (i = 0; i < n; i++)
	es_fprintf (fp, "%02X", keyrecord[i]);
	es_fputs (":\t reasons( ", fp);

	if (reason & KSBA_CRLREASON_UNSPECIFIED)
	es_fputs( "unspecified ", fp ), any = 1;
	if (reason & KSBA_CRLREASON_KEY_COMPROMISE )
	es_fputs( "key_compromise ", fp ), any = 1;
	if (reason & KSBA_CRLREASON_CA_COMPROMISE )
	es_fputs( "ca_compromise ", fp ), any = 1;
	if (reason & KSBA_CRLREASON_AFFILIATION_CHANGED )
	es_fputs( "affiliation_changed ", fp ), any = 1;
	if (reason & KSBA_CRLREASON_SUPERSEDED )
	es_fputs( "superseded", fp ), any = 1;
	if (reason & KSBA_CRLREASON_CESSATION_OF_OPERATION )
	es_fputs( "cessation_of_operation", fp ), any = 1;
	if (reason & KSBA_CRLREASON_CERTIFICATE_HOLD )
	es_fputs( "certificate_hold", fp ), any = 1;
	if (reason && !any)
	es_fputs( "other", fp );

	es_fprintf (fp, ") rdate: %.15s\n", record+1);
	}
	if (rc)
	log_error (_("error reading cache entry from db: %s\n"), strerror (rc));

	unlock_db_file (cache, e);
	es_fprintf (fp, _("End CRL dump\n") );
	es_putc ('\n', fp);

	return (rc\|\|warn)? gpg_error (GPG_ERR_GENERAL) : 0;
	}


	/* Print the contents of the CRL CACHE in a human readable format to
	stream FP. */
	gpg_error_t
	crl_cache_list (estream_t fp)
	{
	crl_cache_t cache = get_current_cache ();
	crl_cache_entry_t entry;
	gpg_error_t err = 0;

	for (entry = cache->entries;
	entry && !entry->deleted && !err;
	entry = entry->next )
	err = list_one_crl_entry (cache, entry, fp);

	return err;
	}


	/* Load the CRL containing the file named FILENAME into our CRL cache. */
	gpg_error_t
	crl_cache_load (ctrl_t ctrl, const char *filename)
	{
	gpg_error_t err;
	estream_t fp;
	ksba_reader_t reader;

	fp = es_fopen (filename, "rb");
	if (!fp)
	{
	err = gpg_error_from_errno (errno);
	log_error (_("can't open '%s': %s\n"), filename, strerror (errno));
	return err;
	}

	err = create_estream_ksba_reader (&reader, fp);
	if (!err)
	{
	err = crl_cache_insert (ctrl, filename, reader);
	ksba_reader_release (reader);
	}
	es_fclose (fp);
	return err;
	}


	/* Locate the corresponding CRL for the certificate CERT, read and
	verify the CRL and store it in the cache. */
	gpg_error_t
	crl_cache_reload_crl (ctrl_t ctrl, ksba_cert_t cert)
	{
	gpg_error_t err;
	ksba_reader_t reader = NULL;
	char *issuer = NULL;
	ksba_name_t distpoint = NULL;
	ksba_name_t issuername = NULL;
	char *distpoint_uri = NULL;
	int any_dist_point = 0;
	int seq;
	gpg_error_t last_err = 0;

	/* Loop over all distribution points, get the CRLs and put them into
	the cache. */
	if (opt.verbose)
	log_info ("checking distribution points\n");
	seq = 0;
	while (xfree (distpoint), xfree (issuername),
	!(err = ksba_cert_get_crl_dist_point (cert, seq++,
	&distpoint,
	&issuername, NULL )))
	{
	int name_seq;

	if (!distpoint && !issuername)
	{
	if (opt.verbose)
	log_info ("no issuer name and no distribution point\n");
	break; /* Not allowed; i.e. an invalid certificate. We give
	up here and hope that the default method returns a
	suitable CRL. */
	}

	/* Get the URIs. We do this in a loop to iterate over all names
	in the crlDP. */
	for (name_seq=0; ksba_name_enum (distpoint, name_seq); name_seq++)
	{
	xfree (distpoint_uri);
	distpoint_uri = ksba_name_get_uri (distpoint, name_seq);
	if (!distpoint_uri)
	continue;

	if (!strncmp (distpoint_uri, "ldap:", 5)
	\|\| !strncmp (distpoint_uri, "ldaps:", 6))
	{
	if (opt.ignore_ldap_dp)
	continue;
	}
	else if (!strncmp (distpoint_uri, "http:", 5)
	\|\| !strncmp (distpoint_uri, "https:", 6))
	{
	if (opt.ignore_http_dp)
	continue;
	}
	else
	continue; /* Skip unknown schemes. */

	any_dist_point = 1;

	if (opt.verbose)
	log_info ("fetching CRL from '%s'\n", distpoint_uri);
	crl_close_reader (reader);
	err = crl_fetch (ctrl, distpoint_uri, &reader);
	if (err)
	{
	log_error (_("crl_fetch via DP failed: %s\n"),
	gpg_strerror (err));
	last_err = err;
	continue; /* with the next name. */
	}

	if (opt.verbose)
	log_info ("inserting CRL (reader %p)\n", reader);
	err = crl_cache_insert (ctrl, distpoint_uri, reader);
	if (err)
	{
	log_error (_("crl_cache_insert via DP failed: %s\n"),
	gpg_strerror (err));
	last_err = err;
	continue; /* with the next name. */
	}
	goto leave; /* Ready - we got the CRL. */
	}
	}
	if (gpg_err_code (err) == GPG_ERR_EOF)
	err = 0;
	if (!err && last_err)
	{
	err = last_err;
	goto leave;
	}

	/* If we did not found any distpoint, try something reasonable. */
	if (!any_dist_point )
	{
	if (opt.verbose)
	log_info ("no distribution point - trying issuer name\n");

	issuer = ksba_cert_get_issuer (cert, 0);
	if (!issuer)
	{
	log_error ("oops: issuer missing in certificate\n");
	err = gpg_error (GPG_ERR_INV_CERT_OBJ);
	goto leave;
	}

	if (opt.verbose)
	log_info ("fetching CRL from default location\n");
	crl_close_reader (reader);
	err = crl_fetch_default (ctrl, issuer, &reader);
	if (err)
	{
	log_error ("crl_fetch via issuer failed: %s\n",
	gpg_strerror (err));
	goto leave;
	}

	if (opt.verbose)
	log_info ("inserting CRL (reader %p)\n", reader);
	err = crl_cache_insert (ctrl, "default location(s)", reader);
	if (err)
	{
	log_error (_("crl_cache_insert via issuer failed: %s\n"),
	gpg_strerror (err));
	goto leave;
	}
	}

	leave:
	crl_close_reader (reader);
	xfree (distpoint_uri);
	ksba_name_release (distpoint);
	ksba_name_release (issuername);
	ksba_free (issuer);
	return err;
	}
	diff --git a/dirmngr/validate.c b/dirmngr/validate.c
	index afd9b304d..b3a1c14a1 100644
	--- a/dirmngr/validate.c
	+++ b/dirmngr/validate.c
	@@ -1,1348 +1,1348 @@
	/* validate.c - Validate a certificate chain.
	* Copyright (C) 2001, 2003, 2004, 2008 Free Software Foundation, Inc.
	* Copyright (C) 2004, 2006, 2008, 2017 g10 Code GmbH
	*
	* This file is part of DirMngr.
	*
	* DirMngr is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* DirMngr is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
	*/

	#include <config.h>

	#include <stdio.h>
	#include <stdlib.h>
	#include <errno.h>
	#include <assert.h>
	#include <ctype.h>

	#include "dirmngr.h"
	#include "certcache.h"
	#include "crlcache.h"
	#include "validate.h"
	#include "misc.h"


	/* Mode parameters for cert_check_usage(). */
	enum cert_usage_modes
	{
	CERT_USAGE_MODE_SIGN, /* Usable for encryption. */
	CERT_USAGE_MODE_ENCR, /* Usable for signing. */
	CERT_USAGE_MODE_VRFY, /* Usable for verification. */
	CERT_USAGE_MODE_DECR, /* Usable for decryption. */
	CERT_USAGE_MODE_CERT, /* Usable for cert signing. */
	CERT_USAGE_MODE_OCSP, /* Usable for OCSP respone signing. */
	CERT_USAGE_MODE_CRL /* Usable for CRL signing. */
	};


	/* While running the validation function we need to keep track of the
	certificates and the validation outcome of each. We use this type
	for it. */
	struct chain_item_s
	{
	struct chain_item_s *next;
	ksba_cert_t cert; /* The certificate. */
	unsigned char fpr[20]; /* Fingerprint of the certificate. */
	int is_self_signed; /* This certificate is self-signed. */
	int is_valid; /* The certifiate is valid except for revocations. */
	};
	typedef struct chain_item_s *chain_item_t;


	/* A couple of constants with Object Identifiers. */
	static const char oid_kp_serverAuth[] = "1.3.6.1.5.5.7.3.1";
	static const char oid_kp_clientAuth[] = "1.3.6.1.5.5.7.3.2";
	static const char oid_kp_codeSigning[] = "1.3.6.1.5.5.7.3.3";
	static const char oid_kp_emailProtection[]= "1.3.6.1.5.5.7.3.4";
	static const char oid_kp_timeStamping[] = "1.3.6.1.5.5.7.3.8";
	static const char oid_kp_ocspSigning[] = "1.3.6.1.5.5.7.3.9";


	/* Prototypes. */
	static gpg_error_t check_cert_sig (ksba_cert_t issuer_cert, ksba_cert_t cert);


	/* Make sure that the values defined in the headers are correct. We
	* can't use the preprocessor due to the use of enums. */
	static void
	check_header_constants (void)
	{
	log_assert (CERTTRUST_CLASS_SYSTEM == VALIDATE_FLAG_TRUST_SYSTEM);
	log_assert (CERTTRUST_CLASS_CONFIG == VALIDATE_FLAG_TRUST_CONFIG);
	log_assert (CERTTRUST_CLASS_HKP == VALIDATE_FLAG_TRUST_HKP);
	log_assert (CERTTRUST_CLASS_HKPSPOOL == VALIDATE_FLAG_TRUST_HKPSPOOL);

	#undef X
	#define X (VALIDATE_FLAG_TRUST_SYSTEM \| VALIDATE_FLAG_TRUST_CONFIG \
	\| VALIDATE_FLAG_TRUST_HKP \| VALIDATE_FLAG_TRUST_HKPSPOOL)

	#if ( X & VALIDATE_FLAG_MASK_TRUST ) != X
	# error VALIDATE_FLAG_MASK_TRUST is bad
	#endif
	#if ( ~X & VALIDATE_FLAG_MASK_TRUST )
	# error VALIDATE_FLAG_MASK_TRUST is bad
	#endif

	#undef X
	}


	/* Check whether CERT contains critical extensions we don't know
	about. */
	static gpg_error_t
	unknown_criticals (ksba_cert_t cert)
	{
	static const char *known[] = {
	"2.5.29.15", /* keyUsage */
	"2.5.29.19", /* basic Constraints */
	"2.5.29.32", /* certificatePolicies */
	"2.5.29.37", /* extendedKeyUsage */
	NULL
	};
	int i, idx, crit;
	const char *oid;
	int unsupported;
	strlist_t sl;
	gpg_error_t err, rc;

	rc = 0;
	for (idx=0; !(err=ksba_cert_get_extension (cert, idx,
	&oid, &crit, NULL, NULL));idx++)
	{
	if (!crit)
	continue;
	for (i=0; known[i] && strcmp (known[i],oid); i++)
	;
	unsupported = !known[i];

	/* If this critical extension is not supported, check the list
	of to be ignored extensions to see whether we claim that it
	is supported. */
	if (unsupported && opt.ignored_cert_extensions)
	{
	for (sl=opt.ignored_cert_extensions;
	sl && strcmp (sl->d, oid); sl = sl->next)
	;
	if (sl)
	unsupported = 0;
	}

	if (unsupported)
	{
	log_error (_("critical certificate extension %s is not supported"),
	oid);
	rc = gpg_error (GPG_ERR_UNSUPPORTED_CERT);
	}
	}
	if (err && gpg_err_code (err) != GPG_ERR_EOF)
	rc = err; /* Such an error takes precedence. */

	return rc;
	}


	/* Basic check for supported policies. */
	static gpg_error_t
	check_cert_policy (ksba_cert_t cert)
	{
	static const char *allowed[] = {
	"2.289.9.9",
	NULL
	};
	gpg_error_t err;
	int idx;
	char p, haystack;
	char *policies;
	int any_critical;

	err = ksba_cert_get_cert_policies (cert, &policies);
	if (gpg_err_code (err) == GPG_ERR_NO_DATA)
	return 0; /* No policy given. */
	if (err)
	return err;

	/* STRING is a line delimited list of certifiate policies as stored
	in the certificate. The line itself is colon delimited where the
	first field is the OID of the policy and the second field either
	N or C for normal or critical extension */
	if (opt.verbose > 1)
	log_info ("certificate's policy list: %s\n", policies);

	/* The check is very minimal but won't give false positives */
	any_critical = !!strstr (policies, ":C");

	/* See whether we find ALLOWED (which is an OID) in POLICIES */
	for (idx=0; allowed[idx]; idx++)
	{
	for (haystack=policies; (p=strstr (haystack, allowed[idx]));
	haystack = p+1)
	{
	if ( !(p == policies \|\| p[-1] == '\n') )
	continue; /* Does not match the begin of a line. */
	if (p[strlen (allowed[idx])] != ':')
	continue; /* The length does not match. */
	/* Yep - it does match: Return okay. */
	ksba_free (policies);
	return 0;
	}
	}

	if (!any_critical)
	{
	log_info (_("Note: non-critical certificate policy not allowed"));
	err = 0;
	}
	else
	{
	log_info (_("certificate policy not allowed"));
	err = gpg_error (GPG_ERR_NO_POLICY_MATCH);
	}

	ksba_free (policies);
	return err;
	}


	static gpg_error_t
	allowed_ca (ksba_cert_t cert, int *chainlen)
	{
	gpg_error_t err;
	int flag;

	err = ksba_cert_is_ca (cert, &flag, chainlen);
	if (err)
	return err;
	if (!flag)
	{
	if (!is_trusted_cert (cert, CERTTRUST_CLASS_CONFIG))
	{
	/* The German SigG Root CA's certificate does not flag
	itself as a CA; thus we relax this requirement if we
	trust a root CA. I think this is reasonable. Note, that
	gpgsm implements a far stricter scheme here but also
	features a "relax" flag in the trustlist.txt. */
	if (chainlen)
	chainlen = 3; / That is what the SigG implements. */
	if (opt.verbose)
	log_info (_("accepting root CA not marked as a CA"));
	}
	else
	{
	log_error (_("issuer certificate is not marked as a CA"));
	return gpg_error (GPG_ERR_BAD_CA_CERT);
	}
	}
	return 0;
	}

	/* Helper for validate_cert_chain. */
	static gpg_error_t
	check_revocations (ctrl_t ctrl, chain_item_t chain)
	{
	gpg_error_t err = 0;
	int any_revoked = 0;
	int any_no_crl = 0;
	int any_crl_too_old = 0;
	chain_item_t ci;

	log_assert (ctrl->check_revocations_nest_level >= 0);
	log_assert (chain);

	if (ctrl->check_revocations_nest_level > 10)
	{
	log_error (_("CRL checking too deeply nested\n"));
	return gpg_error(GPG_ERR_BAD_CERT_CHAIN);
	}
	ctrl->check_revocations_nest_level++;


	for (ci=chain; ci; ci = ci->next)
	{
	assert (ci->cert);
	if (ci == chain)
	{
	/* It does not make sense to check the root certificate for
	revocations. In almost all cases this will lead to a
	catch-22 as the root certificate is the final trust
	anchor for the certificates and the CRLs. We expect the
	user to remove root certificates from the list of trusted
	certificates in case they have been revoked. */
	if (opt.verbose)
	cert_log_name (_("not checking CRL for"), ci->cert);
	continue;
	}

	if (opt.verbose)
	cert_log_name (_("checking CRL for"), ci->cert);
	err = crl_cache_cert_isvalid (ctrl, ci->cert, 0);
	if (gpg_err_code (err) == GPG_ERR_NO_CRL_KNOWN)
	{
	err = crl_cache_reload_crl (ctrl, ci->cert);
	if (!err)
	err = crl_cache_cert_isvalid (ctrl, ci->cert, 0);
	}
	switch (gpg_err_code (err))
	{
	case 0: err = 0; break;
	case GPG_ERR_CERT_REVOKED: any_revoked = 1; err = 0; break;
	case GPG_ERR_NO_CRL_KNOWN: any_no_crl = 1; err = 0; break;
	case GPG_ERR_CRL_TOO_OLD: any_crl_too_old = 1; err = 0; break;
	default: break;
	}
	}
	ctrl->check_revocations_nest_level--;


	if (err)
	;
	else if (any_revoked)
	err = gpg_error (GPG_ERR_CERT_REVOKED);
	else if (any_no_crl)
	err = gpg_error (GPG_ERR_NO_CRL_KNOWN);
	else if (any_crl_too_old)
	err = gpg_error (GPG_ERR_CRL_TOO_OLD);
	else
	err = 0;
	return err;
	}


	/* Check whether CERT is a root certificate. ISSUERDN and SUBJECTDN
	are the DNs already extracted by the caller from CERT. Returns
	True if this is the case. */
	static int
	is_root_cert (ksba_cert_t cert, const char issuerdn, const char subjectdn)
	{
	gpg_error_t err;
	int result = 0;
	ksba_sexp_t serialno;
	ksba_sexp_t ak_keyid;
	ksba_name_t ak_name;
	ksba_sexp_t ak_sn;
	const char *ak_name_str;
	ksba_sexp_t subj_keyid = NULL;

	if (!issuerdn \|\| !subjectdn)
	return 0; /* No. */

	if (strcmp (issuerdn, subjectdn))
	return 0; /* No. */

	err = ksba_cert_get_auth_key_id (cert, &ak_keyid, &ak_name, &ak_sn);
	if (err)
	{
	if (gpg_err_code (err) == GPG_ERR_NO_DATA)
	return 1; /* Yes. Without a authorityKeyIdentifier this needs
	to be the Root certificate (our trust anchor). */
	log_error ("error getting authorityKeyIdentifier: %s\n",
	gpg_strerror (err));
	return 0; /* Well, it is broken anyway. Return No. */
	}

	serialno = ksba_cert_get_serial (cert);
	if (!serialno)
	{
	log_error ("error getting serialno: %s\n", gpg_strerror (err));
	goto leave;
	}

	/* Check whether the auth name's matches the issuer name+sn. If
	that is the case this is a root certificate. */
	ak_name_str = ksba_name_enum (ak_name, 0);
	if (ak_name_str
	&& !strcmp (ak_name_str, issuerdn)
	&& !cmp_simple_canon_sexp (ak_sn, serialno))
	{
	result = 1; /* Right, CERT is self-signed. */
	goto leave;
	}

	/* Similar for the ak_keyid. */
	if (ak_keyid && !ksba_cert_get_subj_key_id (cert, NULL, &subj_keyid)
	&& !cmp_simple_canon_sexp (ak_keyid, subj_keyid))
	{
	result = 1; /* Right, CERT is self-signed. */
	goto leave;
	}


	leave:
	ksba_free (subj_keyid);
	ksba_free (ak_keyid);
	ksba_name_release (ak_name);
	ksba_free (ak_sn);
	ksba_free (serialno);
	return result;
	}


	/* Validate the certificate CHAIN up to the trust anchor. Optionally
	return the closest expiration time in R_EXPTIME (this is useful for
	caching issues). MODE is one of the VALIDATE_MODE_* constants.

	Note that VALIDATE_MODE_OCSP is not used due to the removal of the
	system service in 2.1.15. Instead only the callback to gpgsm to
	validate a certificate is used.

	If R_TRUST_ANCHOR is not NULL and the validation would fail only
	because the root certificate is not trusted, the hexified
	fingerprint of that root certificate is stored at R_TRUST_ANCHOR
	and success is returned. The caller needs to free the value at
	R_TRUST_ANCHOR; in all other cases NULL is stored there. */
	gpg_error_t
	validate_cert_chain (ctrl_t ctrl, ksba_cert_t cert, ksba_isotime_t r_exptime,
	unsigned int flags, char **r_trust_anchor)
	{
	gpg_error_t err = 0;
	int depth, maxdepth;
	char *issuer = NULL;
	char *subject = NULL;
	ksba_cert_t subject_cert = NULL;
	ksba_cert_t issuer_cert = NULL;
	ksba_isotime_t current_time;
	ksba_isotime_t exptime;
	int any_expired = 0;
	int any_no_policy_match = 0;
	chain_item_t chain;

	check_header_constants ();

	if (r_exptime)
	*r_exptime = 0;
	*exptime = 0;

	if (r_trust_anchor)
	*r_trust_anchor = NULL;

	if (DBG_X509)
	dump_cert ("subject", cert);

	/* May the target certificate be used for this purpose? */
	if ((flags & VALIDATE_FLAG_OCSP) && (err = check_cert_use_ocsp (cert)))
	return err;
	if ((flags & VALIDATE_FLAG_CRL) && (err = check_cert_use_crl (cert)))
	return err;

	/* If we already validated the certificate not too long ago, we can
	avoid the excessive computations and lookups unless the caller
	asked for the expiration time. */
	if (!r_exptime)
	{
	size_t buflen;
	time_t validated_at;

	err = ksba_cert_get_user_data (cert, "validated_at",
	&validated_at, sizeof (validated_at),
	&buflen);
	if (err \|\| buflen != sizeof (validated_at) \|\| !validated_at)
	err = 0; /* Not available or other error. */
	else
	{
	/* If the validation is not older than 30 minutes we are ready. */
	if (validated_at < gnupg_get_time () + (30*60))
	{
	if (opt.verbose)
	log_info ("certificate is good (cached)\n");
	/* Note, that we can't jump to leave here as this would
	falsely updated the validation timestamp. */
	return 0;
	}
	}
	}

	/* Get the current time. */
	gnupg_get_isotime (current_time);

	/* We walk up the chain until we find a trust anchor. */
	subject_cert = cert;
	maxdepth = 10; /* Sensible limit on the length of the chain. */
	chain = NULL;
	depth = 0;
	for (;;)
	{
	/* Get the subject and issuer name from the current
	certificate. */
	ksba_free (issuer);
	ksba_free (subject);
	issuer = ksba_cert_get_issuer (subject_cert, 0);
	subject = ksba_cert_get_subject (subject_cert, 0);

	if (!issuer)
	{
	log_error (_("no issuer found in certificate\n"));
	err = gpg_error (GPG_ERR_BAD_CERT);
	goto leave;
	}

	/* Handle the notBefore and notAfter timestamps. */
	{
	ksba_isotime_t not_before, not_after;

	err = ksba_cert_get_validity (subject_cert, 0, not_before);
	if (!err)
	err = ksba_cert_get_validity (subject_cert, 1, not_after);
	if (err)
	{
	log_error (_("certificate with invalid validity: %s"),
	gpg_strerror (err));
	err = gpg_error (GPG_ERR_BAD_CERT);
	goto leave;
	}

	/* Keep track of the nearest expiration time in EXPTIME. */
	if (*not_after)
	{
	if (!*exptime)
	gnupg_copy_time (exptime, not_after);
	else if (strcmp (not_after, exptime) < 0 )
	gnupg_copy_time (exptime, not_after);
	}

	/* Check whether the certificate is already valid. */
	if (*not_before && strcmp (current_time, not_before) < 0 )
	{
	log_error (_("certificate not yet valid"));
	log_info ("(valid from ");
	dump_isotime (not_before);
	log_printf (")\n");
	err = gpg_error (GPG_ERR_CERT_TOO_YOUNG);
	goto leave;
	}

	/* Now check whether the certificate has expired. */
	if (*not_after && strcmp (current_time, not_after) > 0 )
	{
	log_error (_("certificate has expired"));
	log_info ("(expired at ");
	dump_isotime (not_after);
	log_printf (")\n");
	any_expired = 1;
	}
	}

	/* Do we have any critical extensions in the certificate we
	can't handle? */
	err = unknown_criticals (subject_cert);
	if (err)
	goto leave; /* yes. */

	/* Check that given policies are allowed. */
	err = check_cert_policy (subject_cert);
	if (gpg_err_code (err) == GPG_ERR_NO_POLICY_MATCH)
	{
	any_no_policy_match = 1;
	err = 0;
	}
	else if (err)
	goto leave;

	/* Is this a self-signed certificate? */
	if (is_root_cert (subject_cert, issuer, subject))
	{
	/* Yes, this is our trust anchor. */
	if (check_cert_sig (subject_cert, subject_cert) )
	{
	log_error (_("selfsigned certificate has a BAD signature"));
	err = gpg_error (depth? GPG_ERR_BAD_CERT_CHAIN
	: GPG_ERR_BAD_CERT);
	goto leave;
	}

	/* Is this certificate allowed to act as a CA. */
	err = allowed_ca (subject_cert, NULL);
	if (err)
	goto leave; /* No. */

	err = is_trusted_cert (subject_cert,
	(flags & VALIDATE_FLAG_MASK_TRUST));
	if (!err)
	; /* Yes we trust this cert. */
	else if (gpg_err_code (err) == GPG_ERR_NOT_TRUSTED)
	{
	char *fpr;

	log_error (_("root certificate is not marked trusted"));
	fpr = get_fingerprint_hexstring (subject_cert);
	log_info (_("fingerprint=%s\n"), fpr? fpr : "?");
	dump_cert ("issuer", subject_cert);
	if (r_trust_anchor)
	{
	/* Caller wants to do another trustiness check. */
	*r_trust_anchor = fpr;
	err = 0;
	}
	else
	xfree (fpr);
	}
	else
	{
	log_error (_("checking trustworthiness of "
	"root certificate failed: %s\n"),
	gpg_strerror (err));
	}
	if (err)
	goto leave;

	/* Prepend the certificate to our list. */
	{
	chain_item_t ci;

	ci = xtrycalloc (1, sizeof *ci);
	if (!ci)
	{
	err = gpg_error_from_errno (errno);
	goto leave;
	}
	ksba_cert_ref (subject_cert);
	ci->cert = subject_cert;
	cert_compute_fpr (subject_cert, ci->fpr);
	ci->next = chain;
	chain = ci;
	}

	if (opt.verbose)
	{
	if (r_trust_anchor && *r_trust_anchor)
	log_info ("root certificate is good but not trusted\n");
	else
	log_info ("root certificate is good and trusted\n");
	}

	break; /* Okay: a self-signed certificate is an end-point. */
	}

	/* To avoid loops, we use an arbitrary limit on the length of
	the chain. */
	depth++;
	if (depth > maxdepth)
	{
	log_error (_("certificate chain too long\n"));
	err = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
	goto leave;
	}

	/* Find the next cert up the tree. */
	ksba_cert_release (issuer_cert); issuer_cert = NULL;
	err = find_issuing_cert (ctrl, subject_cert, &issuer_cert);
	if (err)
	{
	if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
	{
	log_error (_("issuer certificate not found"));
	log_info ("issuer certificate: #/");
	dump_string (issuer);
	log_printf ("\n");
	}
	else
	log_error (_("issuer certificate not found: %s\n"),
	gpg_strerror (err));
	/* Use a better understandable error code. */
	err = gpg_error (GPG_ERR_MISSING_ISSUER_CERT);
	goto leave;
	}

	/* try_another_cert: */
	if (DBG_X509)
	{
	log_debug ("got issuer's certificate:\n");
	dump_cert ("issuer", issuer_cert);
	}

	/* Now check the signature of the certificate. FIXME: we should
	* delay this until later so that faked certificates can't be
	* turned into a DoS easily. */
	err = check_cert_sig (issuer_cert, subject_cert);
	if (err)
	{
	log_error (_("certificate has a BAD signature"));
	#if 0
	if (gpg_err_code (err) == GPG_ERR_BAD_SIGNATURE)
	{
	/* We now try to find other issuer certificates which
	might have been used. This is required because some
	CAs are reusing the issuer and subject DN for new
	root certificates without using a authorityKeyIdentifier. */
	rc = find_up (kh, subject_cert, issuer, 1);
	if (!rc)
	{
	ksba_cert_t tmp_cert;

	rc = keydb_get_cert (kh, &tmp_cert);
	if (rc \|\| !compare_certs (issuer_cert, tmp_cert))
	{
	/* The find next did not work or returned an
	identical certificate. We better stop here
	to avoid infinite checks. */
	rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
	ksba_cert_release (tmp_cert);
	}
	else
	{
	do_list (0, lm, fp, _("found another possible matching "
	"CA certificate - trying again"));
	ksba_cert_release (issuer_cert);
	issuer_cert = tmp_cert;
	goto try_another_cert;
	}
	}
	}
	#endif
	/* Return a more descriptive error code than the one
	* returned from the signature checking. */
	err = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
	goto leave;
	}

	/* Check that the length of the chain is not longer than allowed
	* by the CA. */
	{
	int chainlen;

	err = allowed_ca (issuer_cert, &chainlen);
	if (err)
	goto leave;
	if (chainlen >= 0 && (depth - 1) > chainlen)
	{
	log_error (_("certificate chain longer than allowed by CA (%d)"),
	chainlen);
	err = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
	goto leave;
	}
	}

	/* May that certificate be used for certification? */
	err = check_cert_use_cert (issuer_cert);
	if (err)
	goto leave; /* No. */

	/* Prepend the certificate to our list. */
	{
	chain_item_t ci;

	ci = xtrycalloc (1, sizeof *ci);
	if (!ci)
	{
	err = gpg_error_from_errno (errno);
	goto leave;
	}
	ksba_cert_ref (subject_cert);
	ci->cert = subject_cert;
	cert_compute_fpr (subject_cert, ci->fpr);
	ci->next = chain;
	chain = ci;
	}

	if (opt.verbose)
	log_info (_("certificate is good\n"));

	/* Now to the next level up. */
	subject_cert = issuer_cert;
	issuer_cert = NULL;
	}

	/* Even if we have no error here we need to check whether we
	* encountered an error somewhere during the checks. Set the error
	* code to the most critical one. */
	if (!err)
	{
	if (any_expired)
	err = gpg_error (GPG_ERR_CERT_EXPIRED);
	else if (any_no_policy_match)
	err = gpg_error (GPG_ERR_NO_POLICY_MATCH);
	}

	if (!err && opt.verbose)
	{
	chain_item_t citem;

	log_info (_("certificate chain is good\n"));
	for (citem = chain; citem; citem = citem->next)
	cert_log_name (" certificate", citem->cert);
	}

	/* Now check for revocations unless CRL checks are disabled or we
	* are non-recursive CRL mode. */
	if (!err
	&& !(flags & VALIDATE_FLAG_NOCRLCHECK)
	&& !((flags & VALIDATE_FLAG_CRL)
	&& !(flags & VALIDATE_FLAG_RECURSIVE)))
	{ /* Now that everything is fine, walk the chain and check each
	* certificate for revocations.
	*
	* 1. item in the chain - The root certificate.
	* 2. item - the CA below the root
	* last item - the target certificate.
	*
	* Now for each certificate in the chain check whether it has
	* been included in a CRL and thus be revoked. We don't do OCSP
	* here because this does not seem to make much sense. This
	* might become a recursive process and we should better cache
	* our validity results to avoid double work. Far worse a
	* catch-22 may happen for an improper setup hierarchy and we
	* need a way to break up such a deadlock. */
	err = check_revocations (ctrl, chain);
	}

	if (!err && opt.verbose)
	{
	if (r_trust_anchor && *r_trust_anchor)
	log_info ("target certificate may be valid\n");
	else
	log_info ("target certificate is valid\n");
	}
	else if (err && opt.verbose)
	log_info ("target certificate is NOT valid\n");


	leave:
	if (!err && !(r_trust_anchor && *r_trust_anchor))
	{
	/* With no error we can update the validation cache. We do this
	* for all certificates in the chain. Note that we can't use
	* the cache if the caller requested to check the trustiness of
	* the root certificate himself. Adding such a feature would
	* require us to also store the fingerprint of root
	* certificate. */
	chain_item_t citem;
	time_t validated_at = gnupg_get_time ();

	for (citem = chain; citem; citem = citem->next)
	{
	err = ksba_cert_set_user_data (citem->cert, "validated_at",
	&validated_at, sizeof (validated_at));
	if (err)
	{
	log_error ("set_user_data(validated_at) failed: %s\n",
	gpg_strerror (err));
	err = 0;
	}
	}
	}

	if (r_exptime)
	gnupg_copy_time (r_exptime, exptime);
	ksba_free (issuer);
	ksba_free (subject);
	ksba_cert_release (issuer_cert);
	if (subject_cert != cert)
	ksba_cert_release (subject_cert);
	while (chain)
	{
	chain_item_t ci_next = chain->next;
	if (chain->cert)
	ksba_cert_release (chain->cert);
	xfree (chain);
	chain = ci_next;
	}
	if (err && r_trust_anchor && *r_trust_anchor)
	{
	xfree (*r_trust_anchor);
	*r_trust_anchor = NULL;
	}
	return err;
	}



	/* Return the public key algorithm id from the S-expression PKEY.
	FIXME: libgcrypt should provide such a function. Note that this
	implementation uses the names as used by libksba. */
	int
	pk_algo_from_sexp (gcry_sexp_t pkey)
	{
	gcry_sexp_t l1, l2;
	const char *name;
	size_t n;
	int algo;

	l1 = gcry_sexp_find_token (pkey, "public-key", 0);
	if (!l1)
	return 0; /* Not found. */
	l2 = gcry_sexp_cadr (l1);
	gcry_sexp_release (l1);

	name = gcry_sexp_nth_data (l2, 0, &n);
	if (!name)
	algo = 0; /* Not found. */
	else if (n==3 && !memcmp (name, "rsa", 3))
	algo = GCRY_PK_RSA;
	else if (n==3 && !memcmp (name, "dsa", 3))
	algo = GCRY_PK_DSA;
	else if (n==3 && !memcmp (name, "ecc", 3))
	algo = GCRY_PK_ECC;
	else if (n==13 && !memcmp (name, "ambiguous-rsa", 13))
	algo = GCRY_PK_RSA;
	else
	algo = 0;
	gcry_sexp_release (l2);
	return algo;
	}


	/* Return the hash algorithm's algo id from its name given in the
	* non-null termnated string in (buffer,buflen). Returns 0 on failure
	* or if the algo is not known. */
	static int
	hash_algo_from_buffer (const void *buffer, size_t buflen)
	{
	char *string;
	int algo;

	string = xtrymalloc (buflen + 1);
	if (!string)
	{
	log_error (_("out of core\n"));
	return 0;
	}
	memcpy (string, buffer, buflen);
	string[buflen] = 0;
	algo = gcry_md_map_name (string);
	if (!algo)
	log_error ("unknown digest algorithm '%s' used in certificate\n", string);
	xfree (string);
	return algo;
	}


	/* Return an unsigned integer from the non-null termnated string
	* (buffer,buflen). Returns 0 on failure. */
	static unsigned int
	uint_from_buffer (const void *buffer, size_t buflen)
	{
	char *string;
	unsigned int val;

	string = xtrymalloc (buflen + 1);
	if (!string)
	{
	log_error (_("out of core\n"));
	return 0;
	}
	memcpy (string, buffer, buflen);
	string[buflen] = 0;
	val = strtoul (string, NULL, 10);
	xfree (string);
	return val;
	}


	/* Check the signature on CERT using the ISSUER_CERT. This function
	* does only test the cryptographic signature and nothing else. It is
	* assumed that the ISSUER_CERT is valid. */
	static gpg_error_t
	check_cert_sig (ksba_cert_t issuer_cert, ksba_cert_t cert)
	{
	gpg_error_t err;
	const char *algoid;
	gcry_md_hd_t md;
	int algo;
	ksba_sexp_t p;
	size_t n;
	gcry_sexp_t s_sig, s_hash, s_pkey;
	const char algo_name; / hash algorithm name converted to lower case. */
	int digestlen;
	unsigned char *digest;
	int use_pss = 0;
	unsigned int saltlen; /* (use is controlled by use_pss) */

	/* Hash the target certificate using the algorithm from that certificate. */
	algoid = ksba_cert_get_digest_algo (cert);
	algo = gcry_md_map_name (algoid);
	if (!algo && algoid && !strcmp (algoid, "1.2.840.113549.1.1.10"))
	use_pss = 1;
	else if (!algo && algoid && !strcmp (algoid, "1.2.840.10045.4.3.1"))
	algo = GCRY_MD_SHA224; /* ecdsa-with-sha224 */
	else if (!algo && algoid && !strcmp (algoid, "1.2.840.10045.4.3.2"))
	algo = GCRY_MD_SHA256; /* ecdsa-with-sha256 */
	else if (!algo && algoid && !strcmp (algoid, "1.2.840.10045.4.3.3"))
	algo = GCRY_MD_SHA384; /* ecdsa-with-sha384 */
	else if (!algo && algoid && !strcmp (algoid, "1.2.840.10045.4.3.4"))
	algo = GCRY_MD_SHA512; /* ecdsa-with-sha512 */
	else if (!algo)
	{
	log_debug ("XXXXX %s\n", __func__);
	log_error (_("unknown hash algorithm '%s'\n"), algoid? algoid:"?");
	return gpg_error (GPG_ERR_GENERAL);
	}

	/* Get the signature value out of the target certificate. */
	p = ksba_cert_get_sig_val (cert);
	n = gcry_sexp_canon_len (p, 0, NULL, NULL);
	if (!n)
	{
	log_error ("libksba did not return a proper S-Exp\n");
	ksba_free (p);
	return gpg_error (GPG_ERR_BUG);
	}
	err = gcry_sexp_sscan ( &s_sig, NULL, p, n);
	ksba_free (p);
	if (err)
	{
	log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (err));
	return err;
	}
	if (DBG_CRYPTO)
	gcry_log_debugsxp ("sigval", s_sig);

	if (use_pss)
	{
	/* Extract the hash algorithm and the salt length from the sigval. */
	gcry_buffer_t ioarray[2] = { {0}, {0} };

	err = gcry_sexp_extract_param (s_sig, "sig-val",
	"&'hash-algo''salt-length'",
	ioarray+0, ioarray+1, NULL);
	if (err)
	{
	gcry_sexp_release (s_sig);
	log_error ("extracting params from PSS failed: %s\n",
	gpg_strerror (err));
	return err;
	}
	algo = hash_algo_from_buffer (ioarray[0].data, ioarray[0].len);
	saltlen = uint_from_buffer (ioarray[1].data, ioarray[1].len);
	xfree (ioarray[0].data);
	xfree (ioarray[1].data);
	if (saltlen < 20)
	{
	log_error ("length of PSS salt too short\n");
	gcry_sexp_release (s_sig);
	return gpg_error (GPG_ERR_DIGEST_ALGO);
	}
	if (!algo)
	{
	gcry_sexp_release (s_sig);
	return gpg_error (GPG_ERR_DIGEST_ALGO);
	}
	/* Add some restrictions; see ../sm/certcheck.c for details. */
	switch (algo)
	{
	case GCRY_MD_SHA1:
	case GCRY_MD_SHA256:
	case GCRY_MD_SHA384:
	case GCRY_MD_SHA512:
	case GCRY_MD_SHA3_256:
	case GCRY_MD_SHA3_384:
	case GCRY_MD_SHA3_512:
	break;
	default:
	log_error ("PSS hash algorithm '%s' rejected\n",
	gcry_md_algo_name (algo));
	gcry_sexp_release (s_sig);
	return gpg_error (GPG_ERR_DIGEST_ALGO);
	}

	if (gcry_md_get_algo_dlen (algo) != saltlen)
	{
	log_error ("PSS hash algorithm '%s' rejected due to salt length %u\n",
	gcry_md_algo_name (algo), saltlen);
	gcry_sexp_release (s_sig);
	return gpg_error (GPG_ERR_DIGEST_ALGO);
	}
	}

	algo_name = hash_algo_to_string (algo);
	err = gcry_md_open (&md, algo, 0);
	if (err)
	{
	log_error ("md_open failed: %s\n", gpg_strerror (err));
	gcry_sexp_release (s_sig);
	return err;
	}
	if (DBG_HASHING)
	gcry_md_debug (md, "hash.cert");

	err = ksba_cert_hash (cert, 1, HASH_FNC, md);
	if (err)
	{
	log_error ("ksba_cert_hash failed: %s\n", gpg_strerror (err));
	gcry_md_close (md);
	gcry_sexp_release (s_sig);
	return err;
	}
	gcry_md_final (md);

	/* Get the public key from the issuer certificate. */
	p = ksba_cert_get_public_key (issuer_cert);
	n = gcry_sexp_canon_len (p, 0, NULL, NULL);
	if (!n)
	{
	log_error ("libksba did not return a proper S-Exp\n");
	gcry_md_close (md);
	ksba_free (p);
	gcry_sexp_release (s_sig);
	return gpg_error (GPG_ERR_BUG);
	}
	err = gcry_sexp_sscan ( &s_pkey, NULL, p, n);
	ksba_free (p);
	if (err)
	{
	log_error ("gcry_sexp_scan failed: %s\n", gpg_strerror (err));
	gcry_md_close (md);
	gcry_sexp_release (s_sig);
	return err;
	}


	/* Prepare the values for signature verification. At this point we
	* have these values:
	*
	* S_PKEY - S-expression with the issuer's public key.
	* S_SIG - Signature value as given in the certificate.
	* MD - Finalized hash context with hash of the certificate.
	* ALGO_NAME - Lowercase hash algorithm name
	* SALTLEN - Salt length for rsaPSS.
	*/
	digestlen = gcry_md_get_algo_dlen (algo);
	digest = gcry_md_read (md, algo);
	if (use_pss)
	{
	err = gcry_sexp_build (&s_hash, NULL,
	"(data (flags pss)"
	"(hash %s %b)"
	"(salt-length %u))",
	algo_name,
	(int)digestlen,
	digest,
	saltlen);
	}
	else if (pk_algo_from_sexp (s_pkey) == GCRY_PK_ECC)
	{
	unsigned int qbits0, qbits;

	qbits0 = gcry_pk_get_nbits (s_pkey);
	qbits = qbits0 == 521? 512 : qbits0;

	if ((qbits%8))
	{
	log_error ("ECDSA requires the hash length to be a"
	" multiple of 8 bits\n");
	err = gpg_error (GPG_ERR_INTERNAL);
	goto leave;
	}

	/* Don't allow any Q smaller than 160 bits. */
	if (qbits < 160)
	{
	log_error (_("%s key uses an unsafe (%u bit) hash\n"),
	"ECDSA", qbits0);
	err = gpg_error (GPG_ERR_INTERNAL);
	goto leave;
	}

	/* Check if we're too short. */
	if (digestlen < qbits/8)
	{
	log_error (_("a %u bit hash is not valid for a %u bit %s key\n"),
	(unsigned int)digestlen*8,
	qbits0,
	"ECDSA");
	if (digestlen < 20)
	{
	err = gpg_error (GPG_ERR_INTERNAL);
	goto leave;
	}
	}

	/* Truncate. */
	if (digestlen > qbits/8)
	digestlen = qbits/8;

	err = gcry_sexp_build (&s_hash, NULL, "(data(flags raw)(value %b))",
	(int)digestlen, digest);
	}
	else /* Not DSA - we assume RSA */
	{
	err = gcry_sexp_build (&s_hash, NULL, "(data(flags pkcs1)(hash %s %b))",
	algo_name, (int)digestlen, digest);
	}

	if (!err)
	err = gcry_pk_verify (s_sig, s_hash, s_pkey);
	if (DBG_X509)
	- log_debug ("gcry_pk_verify: %s\n", gpg_strerror (err));
	+ log_debug ("%s: gcry_pk_verify: %s\n", __func__, gpg_strerror (err));

	leave:
	gcry_md_close (md);
	gcry_sexp_release (s_sig);
	gcry_sexp_release (s_hash);
	gcry_sexp_release (s_pkey);
	return err;
	}



	/* Return 0 if CERT is usable for MODE. */
	static gpg_error_t
	check_cert_usage (ksba_cert_t cert, enum cert_usage_modes mode)
	{
	gpg_error_t err;
	unsigned int use;
	char *extkeyusages;
	int have_ocsp_signing = 0;

	err = ksba_cert_get_ext_key_usages (cert, &extkeyusages);
	if (gpg_err_code (err) == GPG_ERR_NO_DATA)
	err = 0; /* No policy given. */
	if (!err)
	{
	unsigned int extusemask = ~0; /* Allow all. */

	if (extkeyusages)
	{
	char p, pend;
	int any_critical = 0;

	extusemask = 0;

	p = extkeyusages;
	while (p && (pend=strchr (p, ':')))
	{
	*pend++ = 0;
	/* Only care about critical flagged usages. */
	if ( *pend == 'C' )
	{
	any_critical = 1;
	if ( !strcmp (p, oid_kp_serverAuth))
	extusemask \|= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
	\| KSBA_KEYUSAGE_KEY_ENCIPHERMENT
	\| KSBA_KEYUSAGE_KEY_AGREEMENT);
	else if ( !strcmp (p, oid_kp_clientAuth))
	extusemask \|= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
	\| KSBA_KEYUSAGE_KEY_AGREEMENT);
	else if ( !strcmp (p, oid_kp_codeSigning))
	extusemask \|= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE);
	else if ( !strcmp (p, oid_kp_emailProtection))
	extusemask \|= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
	\| KSBA_KEYUSAGE_NON_REPUDIATION
	\| KSBA_KEYUSAGE_KEY_ENCIPHERMENT
	\| KSBA_KEYUSAGE_KEY_AGREEMENT);
	else if ( !strcmp (p, oid_kp_timeStamping))
	extusemask \|= (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
	\| KSBA_KEYUSAGE_NON_REPUDIATION);
	}

	/* This is a hack to cope with OCSP. Note that we do
	not yet fully comply with the requirements and that
	the entire CRL/OCSP checking thing should undergo a
	thorough review and probably redesign. */
	if ( !strcmp (p, oid_kp_ocspSigning))
	have_ocsp_signing = 1;

	if ((p = strchr (pend, '\n')))
	p++;
	}
	ksba_free (extkeyusages);
	extkeyusages = NULL;

	if (!any_critical)
	extusemask = ~0; /* Reset to the don't care mask. */
	}


	err = ksba_cert_get_key_usage (cert, &use);
	if (gpg_err_code (err) == GPG_ERR_NO_DATA)
	{
	err = 0;
	if (opt.verbose && (mode == CERT_USAGE_MODE_SIGN
	\|\| mode == CERT_USAGE_MODE_ENCR))
	log_info (_("no key usage specified - assuming all usages\n"));
	use = ~0;
	}

	/* Apply extKeyUsage. */
	use &= extusemask;

	}
	if (err)
	{
	log_error (_("error getting key usage information: %s\n"),
	gpg_strerror (err));
	ksba_free (extkeyusages);
	return err;
	}

	switch (mode)
	{
	case CERT_USAGE_MODE_SIGN:
	case CERT_USAGE_MODE_VRFY:
	if ((use & (KSBA_KEYUSAGE_DIGITAL_SIGNATURE
	\| KSBA_KEYUSAGE_NON_REPUDIATION)))
	return 0;
	log_info (mode == CERT_USAGE_MODE_VRFY
	? _("certificate should not have been used for signing\n")
	: _("certificate is not usable for signing\n"));
	break;

	case CERT_USAGE_MODE_ENCR:
	case CERT_USAGE_MODE_DECR:
	if ((use & (KSBA_KEYUSAGE_KEY_ENCIPHERMENT
	\| KSBA_KEYUSAGE_DATA_ENCIPHERMENT)))
	return 0;
	log_info (mode == CERT_USAGE_MODE_DECR
	? _("certificate should not have been used for encryption\n")
	: _("certificate is not usable for encryption\n"));
	break;

	case CERT_USAGE_MODE_CERT:
	if ((use & (KSBA_KEYUSAGE_KEY_CERT_SIGN)))
	return 0;
	log_info (_("certificate should not have "
	"been used for certification\n"));
	break;

	case CERT_USAGE_MODE_OCSP:
	if (use != ~0
	&& (have_ocsp_signing
	\|\| (use & (KSBA_KEYUSAGE_KEY_CERT_SIGN
	\|KSBA_KEYUSAGE_CRL_SIGN))))
	return 0;
	log_info (_("certificate should not have "
	"been used for OCSP response signing\n"));
	break;

	case CERT_USAGE_MODE_CRL:
	if ((use & (KSBA_KEYUSAGE_CRL_SIGN)))
	return 0;
	log_info (_("certificate should not have "
	"been used for CRL signing\n"));
	break;
	}

	return gpg_error (GPG_ERR_WRONG_KEY_USAGE);
	}


	/* Return 0 if the certificate CERT is usable for certification. */
	gpg_error_t
	check_cert_use_cert (ksba_cert_t cert)
	{
	return check_cert_usage (cert, CERT_USAGE_MODE_CERT);
	}

	/* Return 0 if the certificate CERT is usable for signing OCSP
	responses. */
	gpg_error_t
	check_cert_use_ocsp (ksba_cert_t cert)
	{
	return check_cert_usage (cert, CERT_USAGE_MODE_OCSP);
	}

	/* Return 0 if the certificate CERT is usable for signing CRLs. */
	gpg_error_t
	check_cert_use_crl (ksba_cert_t cert)
	{
	return check_cert_usage (cert, CERT_USAGE_MODE_CRL);
	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 23, 4:37 PM (9 h, 57 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: de/bf/cc8a58d03618a22746c05c69ef9c

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions