No OneTemporary
Actions

Size

63 KB

Subscribers

None

View Options

	diff --git a/agent/findkey.c b/agent/findkey.c
	index 87289eced..2612383b5 100644
	--- a/agent/findkey.c
	+++ b/agent/findkey.c
	@@ -1,1581 +1,1620 @@
	/* findkey.c - Locate the secret key
	* Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007,
	* 2010, 2011 Free Software Foundation, Inc.
	* Copyright (C) 2014, 2019 Werner Koch
	*
	* This file is part of GnuPG.
	*
	* GnuPG 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 3 of the License, or
	* (at your option) any later version.
	*
	* GnuPG 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/>.
	*/

	#include <config.h>
	#include <errno.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <ctype.h>
	#include <fcntl.h>
	#include <unistd.h>
	#include <sys/stat.h>
	#include <npth.h> /* (we use pth_sleep) */

	#include "agent.h"
	#include "../common/i18n.h"
	#include "../common/ssh-utils.h"
	#include "../common/name-value.h"

	#ifndef O_BINARY
	#define O_BINARY 0
	#endif

	/* Helper to pass data to the check callback of the unprotect function. */
	struct try_unprotect_arg_s
	{
	ctrl_t ctrl;
	const unsigned char *protected_key;
	unsigned char *unprotected_key;
	int change_required; /* Set by the callback to indicate that the
	user should change the passphrase. */
	};


	/* Repalce all linefeeds in STRING by "%0A" and return a new malloced
	* string. May return NULL on memory error. */
	static char *
	linefeed_to_percent0A (const char *string)
	{
	const char *s;
	size_t n;
	char buf, p;

	for (n=0, s=string; *s; s++)
	if (*s == '\n')
	n += 3;
	else
	n++;
	p = buf = xtrymalloc (n+1);
	if (!buf)
	return NULL;
	for (s=string; *s; s++)
	if (*s == '\n')
	{
	memcpy (p, "%0A", 3);
	p += 3;
	}
	else
	p++ = s;
	*p = 0;
	return buf;
	}


	/* Note: Ownership of FNAME and FP are moved to this function. */
	static gpg_error_t
	write_extended_private_key (char *fname, estream_t fp, int update, int newkey,
	const void *buf, size_t len,
	const char serialno, const char keyref,
	time_t timestamp)
	{
	gpg_error_t err;
	nvc_t pk = NULL;
	gcry_sexp_t key = NULL;
	int remove = 0;
	char *token = NULL;

	if (update)
	{
	int line;

	err = nvc_parse_private_key (&pk, &line, fp);
	if (err && gpg_err_code (err) != GPG_ERR_ENOENT)
	{
	log_error ("error parsing '%s' line %d: %s\n",
	fname, line, gpg_strerror (err));
	goto leave;
	}
	}
	else
	{
	pk = nvc_new_private_key ();
	if (!pk)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}
	}
	es_clearerr (fp);

	err = gcry_sexp_sscan (&key, NULL, buf, len);
	if (err)
	goto leave;

	err = nvc_set_private_key (pk, key);
	if (err)
	goto leave;

	/* If requested write a Token line. */
	if (serialno && keyref)
	{
	nve_t item;
	const char *s;

	token = strconcat (serialno, " ", keyref, NULL);
	if (!token)
	{
	err = gpg_error_from_syserror ();
	goto leave;
	}

	/* fixme: the strcmp should compare only the first two strings. */
	for (item = nvc_lookup (pk, "Token:");
	item;
	item = nve_next_value (item, "Token:"))
	if ((s = nve_value (item)) && !strcmp (s, token))
	break;
	if (!item)
	{
	/* No token or no token with that value exists. Add a new
	* one so that keys which have been stored on several cards
	* are well supported. */
	err = nvc_add (pk, "Token:", token);
	if (err)
	goto leave;
	}
	}

	/* If a timestamp has been supplied and the key is new write a
	* creation timestamp. (We douple check that there is no Created
	* item yet.)*/
	if (timestamp && newkey && !nvc_lookup (pk, "Created:"))
	{
	gnupg_isotime_t timebuf;

	epoch2isotime (timebuf, timestamp);
	err = nvc_add (pk, "Created:", timebuf);
	if (err)
	goto leave;
	}


	err = es_fseek (fp, 0, SEEK_SET);
	if (err)
	goto leave;

	err = nvc_write (pk, fp);
	if (err)
	{
	log_error ("error writing '%s': %s\n", fname, gpg_strerror (err));
	remove = 1;
	goto leave;
	}

	if (ftruncate (es_fileno (fp), es_ftello (fp)))
	{
	err = gpg_error_from_syserror ();
	log_error ("error truncating '%s': %s\n", fname, gpg_strerror (err));
	remove = 1;
	goto leave;
	}

	if (es_fclose (fp))
	{
	err = gpg_error_from_syserror ();
	log_error ("error closing '%s': %s\n", fname, gpg_strerror (err));
	remove = 1;
	goto leave;
	}
	else
	fp = NULL;

	bump_key_eventcounter ();

	leave:
	es_fclose (fp);
	if (remove)
	gnupg_remove (fname);
	xfree (fname);
	gcry_sexp_release (key);
	nvc_release (pk);
	xfree (token);
	return err;
	}

	/* Write an S-expression formatted key to our key storage. With FORCE
	* passed as true an existing key with the given GRIP will get
	* overwritten. If SERIALNO and KEYREF are given a Token line is
	* added to the key if the extended format is used. If TIMESTAMP is
	* not zero and the key doies not yet exists it will be recorded as
	* creation date. */
	int
	agent_write_private_key (const unsigned char *grip,
	const void *buffer, size_t length, int force,
	const char serialno, const char keyref,
	time_t timestamp)
	{
	char *fname;
	estream_t fp;
	char hexgrip[40+4+1];

	bin2hex (grip, 20, hexgrip);
	strcpy (hexgrip+40, ".key");

	fname = make_filename (gnupg_homedir (), GNUPG_PRIVATE_KEYS_DIR,
	hexgrip, NULL);

	/* FIXME: Write to a temp file first so that write failures during
	key updates won't lead to a key loss. */

	if (!force && !gnupg_access (fname, F_OK))
	{
	log_error ("secret key file '%s' already exists\n", fname);
	xfree (fname);
	return gpg_error (GPG_ERR_EEXIST);
	}

	fp = es_fopen (fname, force? "rb+,mode=-rw" : "wbx,mode=-rw");
	if (!fp)
	{
	gpg_error_t tmperr = gpg_error_from_syserror ();

	if (force && gpg_err_code (tmperr) == GPG_ERR_ENOENT)
	{
	fp = es_fopen (fname, "wbx,mode=-rw");
	if (!fp)
	tmperr = gpg_error_from_syserror ();
	}
	if (!fp)
	{
	log_error ("can't create '%s': %s\n", fname, gpg_strerror (tmperr));
	xfree (fname);
	return tmperr;
	}
	}
	else if (force)
	{
	gpg_error_t rc;
	char first;

	/* See if an existing key is in extended format. */
	if (es_fread (&first, 1, 1, fp) != 1)
	{
	rc = gpg_error_from_syserror ();
	log_error ("error reading first byte from '%s': %s\n",
	fname, strerror (errno));
	xfree (fname);
	es_fclose (fp);
	return rc;
	}

	rc = es_fseek (fp, 0, SEEK_SET);
	if (rc)
	{
	log_error ("error seeking in '%s': %s\n", fname, strerror (errno));
	xfree (fname);
	es_fclose (fp);
	return rc;
	}

	if (first != '(')
	{
	/* Key is already in the extended format. */
	return write_extended_private_key (fname, fp, 1, 0, buffer, length,
	serialno, keyref, timestamp);
	}
	if (first == '(' && opt.enable_extended_key_format)
	{
	/* Key is in the old format - but we want the extended format. */
	return write_extended_private_key (fname, fp, 0, 0, buffer, length,
	serialno, keyref, timestamp);
	}
	}

	if (opt.enable_extended_key_format)
	return write_extended_private_key (fname, fp, 0, 1, buffer, length,
	serialno, keyref, timestamp);

	if (es_fwrite (buffer, length, 1, fp) != 1)
	{
	gpg_error_t tmperr = gpg_error_from_syserror ();
	log_error ("error writing '%s': %s\n", fname, gpg_strerror (tmperr));
	es_fclose (fp);
	gnupg_remove (fname);
	xfree (fname);
	return tmperr;
	}

	/* When force is given, the file might have to be truncated. */
	if (force && ftruncate (es_fileno (fp), es_ftello (fp)))
	{
	gpg_error_t tmperr = gpg_error_from_syserror ();
	log_error ("error truncating '%s': %s\n", fname, gpg_strerror (tmperr));
	es_fclose (fp);
	gnupg_remove (fname);
	xfree (fname);
	return tmperr;
	}

	if (es_fclose (fp))
	{
	gpg_error_t tmperr = gpg_error_from_syserror ();
	log_error ("error closing '%s': %s\n", fname, gpg_strerror (tmperr));
	gnupg_remove (fname);
	xfree (fname);
	return tmperr;
	}
	bump_key_eventcounter ();
	xfree (fname);
	return 0;
	}


	/* Callback function to try the unprotection from the passphrase query
	code. */
	static gpg_error_t
	try_unprotect_cb (struct pin_entry_info_s *pi)
	{
	struct try_unprotect_arg_s *arg = pi->check_cb_arg;
	ctrl_t ctrl = arg->ctrl;
	size_t dummy;
	gpg_error_t err;
	gnupg_isotime_t now, protected_at, tmptime;
	char *desc = NULL;

	log_assert (!arg->unprotected_key);

	arg->change_required = 0;
	err = agent_unprotect (ctrl, arg->protected_key, pi->pin, protected_at,
	&arg->unprotected_key, &dummy);
	if (err)
	return err;
	if (!opt.max_passphrase_days \|\| ctrl->in_passwd)
	return 0; /* No regular passphrase change required. */

	if (!*protected_at)
	{
	/* No protection date known - must force passphrase change. */
	desc = xtrystrdup (L_("Note: This passphrase has never been changed.%0A"
	"Please change it now."));
	if (!desc)
	return gpg_error_from_syserror ();
	}
	else
	{
	gnupg_get_isotime (now);
	gnupg_copy_time (tmptime, protected_at);
	err = add_days_to_isotime (tmptime, opt.max_passphrase_days);
	if (err)
	return err;
	if (strcmp (now, tmptime) > 0 )
	{
	/* Passphrase "expired". */
	desc = xtryasprintf
	(L_("This passphrase has not been changed%%0A"
	"since %.4s-%.2s-%.2s. Please change it now."),
	protected_at, protected_at+4, protected_at+6);
	if (!desc)
	return gpg_error_from_syserror ();
	}
	}

	if (desc)
	{
	/* Change required. */
	if (opt.enforce_passphrase_constraints)
	{
	err = agent_get_confirmation (ctrl, desc,
	L_("Change passphrase"), NULL, 0);
	if (!err)
	arg->change_required = 1;
	}
	else
	{
	err = agent_get_confirmation (ctrl, desc,
	L_("Change passphrase"),
	L_("I'll change it later"), 0);
	if (!err)
	arg->change_required = 1;
	else if (gpg_err_code (err) == GPG_ERR_CANCELED
	\|\| gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
	err = 0;
	}
	xfree (desc);
	}

	return err;
	}


	/* Return true if the STRING has an %C or %c expando. */
	static int
	has_comment_expando (const char *string)
	{
	const char *s;
	int percent = 0;

	if (!string)
	return 0;

	for (s = string; *s; s++)
	{
	if (percent)
	{
	if (s == 'c' \|\| s == 'C')
	return 1;
	percent = 0;
	}
	else if (*s == '%')
	percent = 1;
	}
	return 0;
	}




	/* Modify a Key description, replacing certain special format
	characters. List of currently supported replacements:

	%% - Replaced by a single %
	%c - Replaced by the content of COMMENT.
	%C - Same as %c but put into parentheses.
	%F - Replaced by an ssh style fingerprint computed from KEY.

	The functions returns 0 on success or an error code. On success a
	newly allocated string is stored at the address of RESULT.
	*/
	gpg_error_t
	agent_modify_description (const char in, const char comment,
	const gcry_sexp_t key, char **result)
	{
	size_t comment_length;
	size_t in_len;
	size_t out_len;
	char *out;
	size_t i;
	int special, pass;
	char *ssh_fpr = NULL;
	char *p;

	*result = NULL;

	if (!comment)
	comment = "";

	comment_length = strlen (comment);
	in_len = strlen (in);

	/* First pass calculates the length, second pass does the actual
	copying. */
	/* FIXME: This can be simplified by using es_fopenmem. */
	out = NULL;
	out_len = 0;
	for (pass=0; pass < 2; pass++)
	{
	special = 0;
	for (i = 0; i < in_len; i++)
	{
	if (special)
	{
	special = 0;
	switch (in[i])
	{
	case '%':
	if (out)
	*out++ = '%';
	else
	out_len++;
	break;

	case 'c': /* Comment. */
	if (out)
	{
	memcpy (out, comment, comment_length);
	out += comment_length;
	}
	else
	out_len += comment_length;
	break;

	case 'C': /* Comment. */
	if (!comment_length)
	;
	else if (out)
	{
	*out++ = '(';
	memcpy (out, comment, comment_length);
	out += comment_length;
	*out++ = ')';
	}
	else
	out_len += comment_length + 2;
	break;

	case 'F': /* SSH style fingerprint. */
	if (!ssh_fpr && key)
	ssh_get_fingerprint_string (key, opt.ssh_fingerprint_digest,
	&ssh_fpr);
	if (ssh_fpr)
	{
	if (out)
	out = stpcpy (out, ssh_fpr);
	else
	out_len += strlen (ssh_fpr);
	}
	break;

	default: /* Invalid special sequences are kept as they are. */
	if (out)
	{
	*out++ = '%';
	*out++ = in[i];
	}
	else
	out_len+=2;
	break;
	}
	}
	else if (in[i] == '%')
	special = 1;
	else
	{
	if (out)
	*out++ = in[i];
	else
	out_len++;
	}
	}

	if (!pass)
	{
	*result = out = xtrymalloc (out_len + 1);
	if (!out)
	{
	xfree (ssh_fpr);
	return gpg_error_from_syserror ();
	}
	}
	}

	*out = 0;
	log_assert (*result + out_len == out);
	xfree (ssh_fpr);

	/* The ssh prompt may sometimes end in
	* "...%0A ()"
	* The empty parentheses doesn't look very good. We use this hack
	* here to remove them as well as the indentation spaces. */
	p = *result;
	i = strlen (p);
	if (i > 2 && !strcmp (p + i - 2, "()"))
	{
	p += i - 2;
	*p-- = 0;
	while (p > *result && spacep (p))
	*p-- = 0;
	}

	return 0;
	}



	/* Unprotect the canconical encoded S-expression key in KEYBUF. GRIP
	should be the hex encoded keygrip of that key to be used with the
	caching mechanism. DESC_TEXT may be set to override the default
	description used for the pinentry. If LOOKUP_TTL is given this
	function is used to lookup the default ttl. If R_PASSPHRASE is not
	NULL, the function succeeded and the key was protected the used
	passphrase (entered or from the cache) is stored there; if not NULL
	will be stored. The caller needs to free the returned
	passphrase. */
	static gpg_error_t
	unprotect (ctrl_t ctrl, const char cache_nonce, const char desc_text,
	unsigned char *keybuf, const unsigned char grip,
	cache_mode_t cache_mode, lookup_ttl_t lookup_ttl,
	char **r_passphrase)
	{
	struct pin_entry_info_s *pi;
	struct try_unprotect_arg_s arg;
	int rc;
	unsigned char *result;
	size_t resultlen;
	char hexgrip[40+1];

	if (r_passphrase)
	*r_passphrase = NULL;

	bin2hex (grip, 20, hexgrip);

	/* Initially try to get it using a cache nonce. */
	if (cache_nonce)
	{
	char *pw;

	pw = agent_get_cache (ctrl, cache_nonce, CACHE_MODE_NONCE);
	if (pw)
	{
	rc = agent_unprotect (ctrl, *keybuf, pw, NULL, &result, &resultlen);
	if (!rc)
	{
	if (r_passphrase)
	*r_passphrase = pw;
	else
	xfree (pw);
	xfree (*keybuf);
	*keybuf = result;
	return 0;
	}
	xfree (pw);
	}
	}

	/* First try to get it from the cache - if there is none or we can't
	unprotect it, we fall back to ask the user */
	if (cache_mode != CACHE_MODE_IGNORE)
	{
	char *pw;

	retry:
	pw = agent_get_cache (ctrl, hexgrip, cache_mode);
	if (pw)
	{
	rc = agent_unprotect (ctrl, *keybuf, pw, NULL, &result, &resultlen);
	if (!rc)
	{
	if (cache_mode == CACHE_MODE_NORMAL)
	agent_store_cache_hit (hexgrip);
	if (r_passphrase)
	*r_passphrase = pw;
	else
	xfree (pw);
	xfree (*keybuf);
	*keybuf = result;
	return 0;
	}
	xfree (pw);
	}
	else if (cache_mode == CACHE_MODE_NORMAL)
	{
	/* The standard use of GPG keys is to have a signing and an
	encryption subkey. Commonly both use the same
	passphrase. We try to help the user to enter the
	passphrase only once by silently trying the last
	correctly entered passphrase. Checking one additional
	passphrase should be acceptable; despite the S2K
	introduced delays. The assumed workflow is:

	1. Read encrypted message in a MUA and thus enter a
	passphrase for the encryption subkey.

	2. Reply to that mail with an encrypted and signed
	mail, thus entering the passphrase for the signing
	subkey.

	We can often avoid the passphrase entry in the second
	step. We do this only in normal mode, so not to
	interfere with unrelated cache entries. */
	pw = agent_get_cache (ctrl, NULL, cache_mode);
	if (pw)
	{
	rc = agent_unprotect (ctrl, *keybuf, pw, NULL,
	&result, &resultlen);
	if (!rc)
	{
	if (r_passphrase)
	*r_passphrase = pw;
	else
	xfree (pw);
	xfree (*keybuf);
	*keybuf = result;
	return 0;
	}
	xfree (pw);
	}
	}

	/* If the pinentry is currently in use, we wait up to 60 seconds
	for it to close and check the cache again. This solves a common
	situation where several requests for unprotecting a key have
	been made but the user is still entering the passphrase for
	the first request. Because all requests to agent_askpin are
	serialized they would then pop up one after the other to
	request the passphrase - despite that the user has already
	entered it and is then available in the cache. This
	implementation is not race free but in the worst case the
	user has to enter the passphrase only once more. */
	if (pinentry_active_p (ctrl, 0))
	{
	/* Active - wait */
	if (!pinentry_active_p (ctrl, 60))
	{
	/* We need to give the other thread a chance to actually put
	it into the cache. */
	gnupg_sleep (1);
	goto retry;
	}
	/* Timeout - better call pinentry now the plain way. */
	}
	}

	pi = gcry_calloc_secure (1, sizeof (*pi) + MAX_PASSPHRASE_LEN + 1);
	if (!pi)
	return gpg_error_from_syserror ();
	pi->max_length = MAX_PASSPHRASE_LEN + 1;
	pi->min_digits = 0; /* we want a real passphrase */
	pi->max_digits = 16;
	pi->max_tries = 3;
	pi->check_cb = try_unprotect_cb;
	arg.ctrl = ctrl;
	arg.protected_key = *keybuf;
	arg.unprotected_key = NULL;
	arg.change_required = 0;
	pi->check_cb_arg = &arg;

	rc = agent_askpin (ctrl, desc_text, NULL, NULL, pi, hexgrip, cache_mode);
	if (rc)
	{
	if ((pi->status & PINENTRY_STATUS_PASSWORD_FROM_CACHE))
	{
	log_error ("Clearing pinentry cache which caused error %s\n",
	gpg_strerror (rc));

	agent_clear_passphrase (ctrl, hexgrip, cache_mode);
	}
	}
	else
	{
	log_assert (arg.unprotected_key);
	if (arg.change_required)
	{
	/* The callback told as that the user should change their
	passphrase. Present the dialog to do. */
	size_t canlen, erroff;
	gcry_sexp_t s_skey;

	log_assert (arg.unprotected_key);
	canlen = gcry_sexp_canon_len (arg.unprotected_key, 0, NULL, NULL);
	rc = gcry_sexp_sscan (&s_skey, &erroff,
	(char*)arg.unprotected_key, canlen);
	if (rc)
	{
	log_error ("failed to build S-Exp (off=%u): %s\n",
	(unsigned int)erroff, gpg_strerror (rc));
	wipememory (arg.unprotected_key, canlen);
	xfree (arg.unprotected_key);
	xfree (pi);
	return rc;
	}
	rc = agent_protect_and_store (ctrl, s_skey, NULL);
	gcry_sexp_release (s_skey);
	if (rc)
	{
	log_error ("changing the passphrase failed: %s\n",
	gpg_strerror (rc));
	wipememory (arg.unprotected_key, canlen);
	xfree (arg.unprotected_key);
	xfree (pi);
	return rc;
	}
	}
	else
	{
	/* Passphrase is fine. */
	agent_put_cache (ctrl, hexgrip, cache_mode, pi->pin,
	lookup_ttl? lookup_ttl (hexgrip) : 0);
	agent_store_cache_hit (hexgrip);
	if (r_passphrase && *pi->pin)
	*r_passphrase = xtrystrdup (pi->pin);
	}
	xfree (*keybuf);
	*keybuf = arg.unprotected_key;
	}
	xfree (pi);
	return rc;
	}


	/* Read the key identified by GRIP from the private key directory and
	* return it as an gcrypt S-expression object in RESULT. If R_KEYMETA
	* is not NULl and the extended key format is used, the meta data
	* items are stored there. However the "Key:" item is removed from
	* it. On failure returns an error code and stores NULL at RESULT and
	* R_KEYMETA. */
	static gpg_error_t
	read_key_file (const unsigned char grip, gcry_sexp_t result, nvc_t *r_keymeta)
	{
	gpg_error_t err;
	char *fname;
	estream_t fp;
	struct stat st;
	unsigned char *buf;
	size_t buflen, erroff;
	gcry_sexp_t s_skey;
	char hexgrip[40+4+1];
	char first;

	*result = NULL;
	if (r_keymeta)
	*r_keymeta = NULL;

	bin2hex (grip, 20, hexgrip);
	strcpy (hexgrip+40, ".key");

	fname = make_filename (gnupg_homedir (), GNUPG_PRIVATE_KEYS_DIR,
	hexgrip, NULL);
	fp = es_fopen (fname, "rb");
	if (!fp)
	{
	err = gpg_error_from_syserror ();
	if (gpg_err_code (err) != GPG_ERR_ENOENT)
	log_error ("can't open '%s': %s\n", fname, gpg_strerror (err));
	xfree (fname);
	return err;
	}

	if (es_fread (&first, 1, 1, fp) != 1)
	{
	err = gpg_error_from_syserror ();
	log_error ("error reading first byte from '%s': %s\n",
	fname, gpg_strerror (err));
	xfree (fname);
	es_fclose (fp);
	return err;
	}

	if (es_fseek (fp, 0, SEEK_SET))
	{
	err = gpg_error_from_syserror ();
	log_error ("error seeking in '%s': %s\n", fname, gpg_strerror (err));
	xfree (fname);
	es_fclose (fp);
	return err;
	}

	if (first != '(')
	{
	/* Key is in extended format. */
	nvc_t pk = NULL;
	int line;

	err = nvc_parse_private_key (&pk, &line, fp);
	es_fclose (fp);

	if (err)
	log_error ("error parsing '%s' line %d: %s\n",
	fname, line, gpg_strerror (err));
	else
	{
	err = nvc_get_private_key (pk, result);
	if (err)
	log_error ("error getting private key from '%s': %s\n",
	fname, gpg_strerror (err));
	else
	nvc_delete_named (pk, "Key:");
	}

	if (!err && r_keymeta)
	*r_keymeta = pk;
	else
	nvc_release (pk);
	xfree (fname);
	return err;
	}

	if (fstat (es_fileno (fp), &st))
	{
	err = gpg_error_from_syserror ();
	log_error ("can't stat '%s': %s\n", fname, gpg_strerror (err));
	xfree (fname);
	es_fclose (fp);
	return err;
	}

	buflen = st.st_size;
	buf = xtrymalloc (buflen+1);
	if (!buf)
	{
	err = gpg_error_from_syserror ();
	log_error ("error allocating %zu bytes for '%s': %s\n",
	buflen, fname, gpg_strerror (err));
	xfree (fname);
	es_fclose (fp);
	xfree (buf);
	return err;

	}

	if (es_fread (buf, buflen, 1, fp) != 1)
	{
	err = gpg_error_from_syserror ();
	log_error ("error reading %zu bytes from '%s': %s\n",
	buflen, fname, gpg_strerror (err));
	xfree (fname);
	es_fclose (fp);
	xfree (buf);
	return err;
	}

	/* Convert the file into a gcrypt S-expression object. */
	err = gcry_sexp_sscan (&s_skey, &erroff, (char*)buf, buflen);
	xfree (fname);
	es_fclose (fp);
	xfree (buf);
	if (err)
	{
	log_error ("failed to build S-Exp (off=%u): %s\n",
	(unsigned int)erroff, gpg_strerror (err));
	return err;
	}
	*result = s_skey;
	return 0;
	}


	/* Remove the key identified by GRIP from the private key directory. */
	static gpg_error_t
	remove_key_file (const unsigned char *grip)
	{
	gpg_error_t err = 0;
	char *fname;
	char hexgrip[40+4+1];

	bin2hex (grip, 20, hexgrip);
	strcpy (hexgrip+40, ".key");
	fname = make_filename (gnupg_homedir (), GNUPG_PRIVATE_KEYS_DIR,
	hexgrip, NULL);
	if (gnupg_remove (fname))
	err = gpg_error_from_syserror ();
	xfree (fname);
	return err;
	}


	/* Return the secret key as an S-Exp in RESULT after locating it using
	the GRIP. Caller should set GRIP=NULL, when a key in a file is
	intended to be used for cryptographic operation. In this case,
	CTRL->keygrip is used to locate the file, and it may ask a user for
	confirmation. If the operation shall be diverted to a token, an
	allocated S-expression with the shadow_info part from the file is
	stored at SHADOW_INFO; if not NULL will be stored at SHADOW_INFO.
	CACHE_MODE defines now the cache shall be used. DESC_TEXT may be
	set to present a custom description for the pinentry. LOOKUP_TTL
	is an optional function to convey a TTL to the cache manager; we do
	not simply pass the TTL value because the value is only needed if
	an unprotect action was needed and looking up the TTL may have some
	overhead (e.g. scanning the sshcontrol file). If a CACHE_NONCE is
	given that cache item is first tried to get a passphrase. If
	R_PASSPHRASE is not NULL, the function succeeded and the key was
	protected the used passphrase (entered or from the cache) is stored
	there; if not NULL will be stored. The caller needs to free the
	returned passphrase. */
	gpg_error_t
	agent_key_from_file (ctrl_t ctrl, const char *cache_nonce,
	const char *desc_text,
	const unsigned char grip, unsigned char *shadow_info,
	cache_mode_t cache_mode, lookup_ttl_t lookup_ttl,
	gcry_sexp_t result, char *r_passphrase,
	time_t *r_timestamp)
	{
	gpg_error_t err;
	unsigned char *buf;
	size_t len, erroff;
	gcry_sexp_t s_skey;
	nvc_t keymeta = NULL;
	char desc_text_buffer = NULL; / Used in case we extend DESC_TEXT. */

	*result = NULL;
	if (shadow_info)
	*shadow_info = NULL;
	if (r_passphrase)
	*r_passphrase = NULL;
	if (r_timestamp)
	*r_timestamp = (time_t)(-1);

	if (!grip && !ctrl->have_keygrip)
	return gpg_error (GPG_ERR_NO_SECKEY);

	err = read_key_file (grip? grip : ctrl->keygrip, &s_skey, &keymeta);

	/* For use with the protection functions we also need the key as an
	canonical encoded S-expression in a buffer. Create this buffer
	now. */
	err = make_canon_sexp (s_skey, &buf, &len);
	if (err)
	{
	nvc_release (keymeta);
	xfree (desc_text_buffer);
	return err;
	}

	if (r_timestamp && keymeta)
	{
	const char *created = nvc_get_string (keymeta, "Created:");

	if (created)
	*r_timestamp = isotime2epoch (created);
	}

	+ if (!grip && keymeta)
	+ {
	+ const char *ask_confirmation = nvc_get_string (keymeta, "Confirm:");
	+
	+ if (ask_confirmation
	+ && ((!strcmp (ask_confirmation, "restricted") && ctrl->restricted)
	+ \|\| !strcmp (ask_confirmation, "yes")))
	+ {
	+ char hexgrip[40+4+1];
	+ char *prompt;
	+ char *comment_buffer = NULL;
	+ const char *comment = NULL;
	+
	+ bin2hex (ctrl->keygrip, 20, hexgrip);
	+
	+ if ((comment = nvc_get_string (keymeta, "Label:")))
	+ {
	+ if (strchr (comment, '\n')
	+ && (comment_buffer = linefeed_to_percent0A (comment)))
	+ comment = comment_buffer;
	+ }
	+
	+ prompt = xtryasprintf (L_("Requested the use of key%%0A"
	+ " %s%%0A"
	+ " %s%%0A"
	+ "Do you want to allow this?"),
	+ hexgrip, comment? comment:"");
	+
	+ gcry_free (comment_buffer);
	+
	+ err = agent_get_confirmation (ctrl, prompt,
	+ L_("Allow"), L_("Deny"), 0);
	+ xfree (prompt);
	+
	+ if (err)
	+ return err;
	+ }
	+ }
	+
	switch (agent_private_key_type (buf))
	{
	case PRIVATE_KEY_CLEAR:
	break; /* no unprotection needed */
	case PRIVATE_KEY_OPENPGP_NONE:
	{
	unsigned char *buf_new;
	size_t buf_newlen;

	err = agent_unprotect (ctrl, buf, "", NULL, &buf_new, &buf_newlen);
	if (err)
	log_error ("failed to convert unprotected openpgp key: %s\n",
	gpg_strerror (err));
	else
	{
	xfree (buf);
	buf = buf_new;
	}
	}
	break;
	case PRIVATE_KEY_PROTECTED:
	{
	char *desc_text_final;
	char *comment_buffer = NULL;
	const char *comment = NULL;

	/* Note, that we will take the comment as a C string for
	* display purposes; i.e. all stuff beyond a Nul character is
	* ignored. If a "Label" entry is available in the meta data
	* this is used instead of the s-expression comment. */
	if (keymeta && (comment = nvc_get_string (keymeta, "Label:")))
	{
	if (strchr (comment, '\n')
	&& (comment_buffer = linefeed_to_percent0A (comment)))
	comment = comment_buffer;
	/* In case DESC_TEXT has no escape pattern for a comment
	* we append one. */
	if (desc_text && !has_comment_expando (desc_text))
	{
	desc_text_buffer = strconcat (desc_text, "%0A%C", NULL);
	if (desc_text_buffer)
	desc_text = desc_text_buffer;
	}
	}
	else
	{
	gcry_sexp_t comment_sexp;

	comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
	if (comment_sexp)
	comment_buffer = gcry_sexp_nth_string (comment_sexp, 1);
	gcry_sexp_release (comment_sexp);
	comment = comment_buffer;
	}

	desc_text_final = NULL;
	if (desc_text)
	err = agent_modify_description (desc_text, comment, s_skey,
	&desc_text_final);
	gcry_free (comment_buffer);

	if (!err)
	{
	err = unprotect (ctrl, cache_nonce, desc_text_final, &buf,
	grip? grip : ctrl->keygrip,
	cache_mode, lookup_ttl, r_passphrase);
	if (err)
	log_error ("failed to unprotect the secret key: %s\n",
	gpg_strerror (err));
	}

	xfree (desc_text_final);
	}
	break;
	case PRIVATE_KEY_SHADOWED:
	if (shadow_info)
	{
	const unsigned char *s;
	size_t n;

	err = agent_get_shadow_info (buf, &s);
	if (!err)
	{
	n = gcry_sexp_canon_len (s, 0, NULL,NULL);
	log_assert (n);
	*shadow_info = xtrymalloc (n);
	if (!*shadow_info)
	err = out_of_core ();
	else
	{
	memcpy (*shadow_info, s, n);
	err = 0;
	}
	}
	if (err)
	log_error ("get_shadow_info failed: %s\n", gpg_strerror (err));
	}
	else
	err = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
	break;
	default:
	log_error ("invalid private key format\n");
	err = gpg_error (GPG_ERR_BAD_SECKEY);
	break;
	}
	gcry_sexp_release (s_skey);
	s_skey = NULL;
	if (err)
	{
	xfree (buf);
	if (r_passphrase)
	{
	xfree (*r_passphrase);
	*r_passphrase = NULL;
	}
	nvc_release (keymeta);
	xfree (desc_text_buffer);
	return err;
	}

	err = sexp_sscan_private_key (result, &erroff, buf);
	xfree (buf);
	nvc_release (keymeta);
	xfree (desc_text_buffer);
	if (err)
	{
	log_error ("failed to build S-Exp (off=%u): %s\n",
	(unsigned int)erroff, gpg_strerror (err));
	if (r_passphrase)
	{
	xfree (*r_passphrase);
	*r_passphrase = NULL;
	}
	}

	return err;
	}


	/* Return the key for the keygrip GRIP. The result is stored at
	RESULT. This function extracts the key from the private key
	database and returns it as an S-expression object as it is. On
	failure an error code is returned and NULL stored at RESULT. */
	gpg_error_t
	agent_raw_key_from_file (ctrl_t ctrl, const unsigned char *grip,
	gcry_sexp_t *result)
	{
	gpg_error_t err;
	gcry_sexp_t s_skey;

	(void)ctrl;

	*result = NULL;

	err = read_key_file (grip, &s_skey, NULL);
	if (!err)
	*result = s_skey;
	return err;
	}


	/* Return the public key for the keygrip GRIP. The result is stored
	at RESULT. This function extracts the public key from the private
	key database. On failure an error code is returned and NULL stored
	at RESULT. */
	gpg_error_t
	agent_public_key_from_file (ctrl_t ctrl,
	const unsigned char *grip,
	gcry_sexp_t *result)
	{
	gpg_error_t err;
	int i, idx;
	gcry_sexp_t s_skey;
	const char algoname, elems;
	int npkey;
	gcry_mpi_t array[10];
	gcry_sexp_t curve = NULL;
	gcry_sexp_t flags = NULL;
	gcry_sexp_t uri_sexp, comment_sexp;
	const char uri, comment;
	size_t uri_length, comment_length;
	int uri_intlen, comment_intlen;
	membuf_t format_mb;
	char *format;
	void args[2+7+2+2+1]; / Size is 2 + max. # of elements + 2 for uri + 2
	for comment + end-of-list. */
	int argidx;
	gcry_sexp_t list = NULL;
	const char *s;

	(void)ctrl;

	*result = NULL;

	err = read_key_file (grip, &s_skey, NULL);
	if (err)
	return err;

	for (i=0; i < DIM (array); i++)
	array[i] = NULL;

	err = extract_private_key (s_skey, 0, &algoname, &npkey, NULL, &elems,
	array, DIM (array), &curve, &flags);
	if (err)
	{
	gcry_sexp_release (s_skey);
	return err;
	}

	uri = NULL;
	uri_length = 0;
	uri_sexp = gcry_sexp_find_token (s_skey, "uri", 0);
	if (uri_sexp)
	uri = gcry_sexp_nth_data (uri_sexp, 1, &uri_length);

	comment = NULL;
	comment_length = 0;
	comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
	if (comment_sexp)
	comment = gcry_sexp_nth_data (comment_sexp, 1, &comment_length);

	gcry_sexp_release (s_skey);
	s_skey = NULL;


	log_assert (sizeof (size_t) <= sizeof (void*));

	init_membuf (&format_mb, 256);
	argidx = 0;
	put_membuf_printf (&format_mb, "(public-key(%s%%S%%S", algoname);
	args[argidx++] = &curve;
	args[argidx++] = &flags;
	for (idx=0, s=elems; idx < npkey; idx++)
	{
	put_membuf_printf (&format_mb, "(%c %%m)", *s++);
	log_assert (argidx < DIM (args));
	args[argidx++] = &array[idx];
	}
	put_membuf_str (&format_mb, ")");
	if (uri)
	{
	put_membuf_str (&format_mb, "(uri %b)");
	log_assert (argidx+1 < DIM (args));
	uri_intlen = (int)uri_length;
	args[argidx++] = (void *)&uri_intlen;
	args[argidx++] = (void *)&uri;
	}
	if (comment)
	{
	put_membuf_str (&format_mb, "(comment %b)");
	log_assert (argidx+1 < DIM (args));
	comment_intlen = (int)comment_length;
	args[argidx++] = (void *)&comment_intlen;
	args[argidx++] = (void *)&comment;
	}
	put_membuf (&format_mb, ")", 2);
	log_assert (argidx < DIM (args));
	args[argidx] = NULL;

	format = get_membuf (&format_mb, NULL);
	if (!format)
	{
	err = gpg_error_from_syserror ();
	for (i=0; array[i]; i++)
	gcry_mpi_release (array[i]);
	gcry_sexp_release (curve);
	gcry_sexp_release (flags);
	gcry_sexp_release (uri_sexp);
	gcry_sexp_release (comment_sexp);
	return err;
	}

	err = gcry_sexp_build_array (&list, NULL, format, args);
	xfree (format);
	for (i=0; array[i]; i++)
	gcry_mpi_release (array[i]);
	gcry_sexp_release (curve);
	gcry_sexp_release (flags);
	gcry_sexp_release (uri_sexp);
	gcry_sexp_release (comment_sexp);

	if (!err)
	*result = list;
	return err;
	}


	/* Check whether the secret key identified by GRIP is available.
	Returns 0 is the key is available. */
	int
	agent_key_available (const unsigned char *grip)
	{
	int result;
	char *fname;
	char hexgrip[40+4+1];

	bin2hex (grip, 20, hexgrip);
	strcpy (hexgrip+40, ".key");

	fname = make_filename (gnupg_homedir (), GNUPG_PRIVATE_KEYS_DIR,
	hexgrip, NULL);
	result = !gnupg_access (fname, R_OK)? 0 : -1;
	xfree (fname);
	return result;
	}



	/* Return the information about the secret key specified by the binary
	keygrip GRIP. If the key is a shadowed one the shadow information
	will be stored at the address R_SHADOW_INFO as an allocated
	S-expression. */
	gpg_error_t
	agent_key_info_from_file (ctrl_t ctrl, const unsigned char *grip,
	int r_keytype, unsigned char *r_shadow_info,
	unsigned char **r_shadow_info_type)
	{
	gpg_error_t err;
	unsigned char *buf;
	size_t len;
	int keytype;

	(void)ctrl;

	if (r_keytype)
	*r_keytype = PRIVATE_KEY_UNKNOWN;
	if (r_shadow_info)
	*r_shadow_info = NULL;

	{
	gcry_sexp_t sexp;

	err = read_key_file (grip, &sexp, NULL);
	if (err)
	{
	if (gpg_err_code (err) == GPG_ERR_ENOENT)
	return gpg_error (GPG_ERR_NOT_FOUND);
	else
	return err;
	}
	err = make_canon_sexp (sexp, &buf, &len);
	gcry_sexp_release (sexp);
	if (err)
	return err;
	}

	keytype = agent_private_key_type (buf);
	switch (keytype)
	{
	case PRIVATE_KEY_CLEAR:
	case PRIVATE_KEY_OPENPGP_NONE:
	break;
	case PRIVATE_KEY_PROTECTED:
	/* If we ever require it we could retrieve the comment fields
	from such a key. */
	break;
	case PRIVATE_KEY_SHADOWED:
	if (r_shadow_info)
	{
	const unsigned char *s;
	size_t n;

	err = agent_get_shadow_info_type (buf, &s, r_shadow_info_type);
	if (!err)
	{
	n = gcry_sexp_canon_len (s, 0, NULL, NULL);
	log_assert (n);
	*r_shadow_info = xtrymalloc (n);
	if (!*r_shadow_info)
	err = gpg_error_from_syserror ();
	else
	memcpy (*r_shadow_info, s, n);
	}
	}
	break;
	default:
	err = gpg_error (GPG_ERR_BAD_SECKEY);
	break;
	}

	if (!err && r_keytype)
	*r_keytype = keytype;

	xfree (buf);
	return err;
	}



	/* Delete the key with GRIP from the disk after having asked for
	* confirmation using DESC_TEXT. If FORCE is set the function won't
	* require a confirmation via Pinentry or warns if the key is also
	* used by ssh. If ONLY_STUBS is set only stub keys (references to
	* smartcards) will be affected.
	*
	* Common error codes are:
	* GPG_ERR_NO_SECKEY
	* GPG_ERR_KEY_ON_CARD
	* GPG_ERR_NOT_CONFIRMED
	* GPG_ERR_FORBIDDEN - Not a stub key and ONLY_STUBS requested.
	*/
	gpg_error_t
	agent_delete_key (ctrl_t ctrl, const char *desc_text,
	const unsigned char *grip, int force, int only_stubs)
	{
	gpg_error_t err;
	gcry_sexp_t s_skey = NULL;
	unsigned char *buf = NULL;
	size_t len;
	char *desc_text_final = NULL;
	char *comment = NULL;
	ssh_control_file_t cf = NULL;
	char hexgrip[40+4+1];
	char *default_desc = NULL;
	int key_type;

	err = read_key_file (grip, &s_skey, NULL);
	if (gpg_err_code (err) == GPG_ERR_ENOENT)
	err = gpg_error (GPG_ERR_NO_SECKEY);
	if (err)
	goto leave;

	err = make_canon_sexp (s_skey, &buf, &len);
	if (err)
	goto leave;

	key_type = agent_private_key_type (buf);
	if (only_stubs && key_type != PRIVATE_KEY_SHADOWED)
	{
	err = gpg_error (GPG_ERR_FORBIDDEN);
	goto leave;
	}

	switch (key_type)
	{
	case PRIVATE_KEY_CLEAR:
	case PRIVATE_KEY_OPENPGP_NONE:
	case PRIVATE_KEY_PROTECTED:
	bin2hex (grip, 20, hexgrip);
	if (!force)
	{
	if (!desc_text)
	{
	default_desc = xtryasprintf
	(L_("Do you really want to delete the key identified by keygrip%%0A"
	" %s%%0A %%C%%0A?"), hexgrip);
	desc_text = default_desc;
	}

	/* Note, that we will take the comment as a C string for
	display purposes; i.e. all stuff beyond a Nul character is
	ignored. */
	{
	gcry_sexp_t comment_sexp;

	comment_sexp = gcry_sexp_find_token (s_skey, "comment", 0);
	if (comment_sexp)
	comment = gcry_sexp_nth_string (comment_sexp, 1);
	gcry_sexp_release (comment_sexp);
	}

	if (desc_text)
	err = agent_modify_description (desc_text, comment, s_skey,
	&desc_text_final);
	if (err)
	goto leave;

	err = agent_get_confirmation (ctrl, desc_text_final,
	L_("Delete key"), L_("No"), 0);
	if (err)
	goto leave;

	cf = ssh_open_control_file ();
	if (cf)
	{
	if (!ssh_search_control_file (cf, hexgrip, NULL, NULL, NULL))
	{
	err = agent_get_confirmation
	(ctrl,
	L_("Warning: This key is also listed for use with SSH!\n"
	"Deleting the key might remove your ability to "
	"access remote machines."),
	L_("Delete key"), L_("No"), 0);
	if (err)
	goto leave;
	}
	}
	}
	err = remove_key_file (grip);
	break;

	case PRIVATE_KEY_SHADOWED:
	err = remove_key_file (grip);
	break;

	default:
	log_error ("invalid private key format\n");
	err = gpg_error (GPG_ERR_BAD_SECKEY);
	break;
	}

	leave:
	ssh_close_control_file (cf);
	gcry_free (comment);
	xfree (desc_text_final);
	xfree (default_desc);
	xfree (buf);
	gcry_sexp_release (s_skey);
	return err;
	}


	/* Write an S-expression formatted shadow key to our key storage.
	Shadow key is created by an S-expression public key in PKBUF and
	card's SERIALNO and the IDSTRING. With FORCE passed as true an
	existing key with the given GRIP will get overwritten. */
	gpg_error_t
	agent_write_shadow_key (const unsigned char *grip,
	const char serialno, const char keyid,
	const unsigned char *pkbuf, int force)
	{
	gpg_error_t err;
	unsigned char *shadow_info;
	unsigned char *shdkey;
	size_t len;

	/* Just in case some caller did not parse the stuff correctly, skip
	* leading spaces. */
	while (spacep (serialno))
	serialno++;
	while (spacep (keyid))
	keyid++;

	shadow_info = make_shadow_info (serialno, keyid);
	if (!shadow_info)
	return gpg_error_from_syserror ();

	err = agent_shadow_key (pkbuf, shadow_info, &shdkey);
	xfree (shadow_info);
	if (err)
	{
	log_error ("shadowing the key failed: %s\n", gpg_strerror (err));
	return err;
	}

	len = gcry_sexp_canon_len (shdkey, 0, NULL, NULL);
	err = agent_write_private_key (grip, shdkey, len, force, serialno, keyid, 0);
	xfree (shdkey);
	if (err)
	log_error ("error writing key: %s\n", gpg_strerror (err));

	return err;
	}
	diff --git a/agent/keyformat.txt b/agent/keyformat.txt
	index 511eb1047..96e69fc00 100644
	--- a/agent/keyformat.txt
	+++ b/agent/keyformat.txt
	@@ -1,473 +1,480 @@
	keyformat.txt emacs, please switch to -- org -- mode
	-------------


	Some notes on the format of the secret keys used with gpg-agent.

	* Location of keys

	The secret keys[1] are stored on a per file basis in a directory below
	the ~/.gnupg home directory. This directory is named

	private-keys-v1.d

	and should have permissions 700.

	The secret keys are stored in files with a name matching the
	hexadecimal representation of the keygrip[2] and suffixed with ".key".

	* Extended Private Key Format

	** Overview
	GnuPG 2.3+ uses a new format to store private keys that is both
	more flexible and easier to read and edit by human beings. The new
	format stores name,value-pairs using the common mail and http header
	convention. Example (here indented with two spaces):

	Description: Key to sign all GnuPG released tarballs.
	The key is actually stored on a smart card.
	Use-for-ssh: yes
	OpenSSH-cert: long base64 encoded string wrapped so that this
	key file can be easily edited with a standard editor.
	Token: D2760001240102000005000011730000 OPENPGP.1
	Token: FF020001008A77C1 PIV.9C
	Key: (shadowed-private-key
	(rsa
	(n #00AA1AD2A55FD8C8FDE9E1941772D9CC903FA43B268CB1B5A1BAFDC900
	2961D8AEA153424DC851EF13B83AC64FBE365C59DC1BD3E83017C90D4365B4
	83E02859FC13DB5842A00E969480DB96CE6F7D1C03600392B8E08EF0C01FC7
	19F9F9086B25AD39B4F1C2A2DF3E2BE317110CFFF21D4A11455508FE407997
	601260816C8422297C0637BB291C3A079B9CB38A92CE9E551F80AA0EBF4F0E
	72C3F250461E4D31F23A7087857FC8438324A013634563D34EFDDCBF2EA80D
	F9662C9CCD4BEF2522D8BDFED24CEF78DC6B309317407EAC576D889F88ADA0
	8C4FFB480981FB68C5C6CA27503381D41018E6CDC52AAAE46B166BDC10637A
	E186A02BA2497FDC5D1221#)
	(e #00010001#)
	(shadowed t1-v1
	(#D2760001240102000005000011730000# OPENPGP.1)
	)))

	GnuPG 2.2 is also able to read and write keys using the new format
	However, it only makes use of the value stored under the name 'Key:'.

	Keys in the extended format can be recognized by looking at the first
	byte of the file. If it starts with a '(' it is a naked S-expression,
	otherwise it is a key in extended format.

	*** Names
	A name must start with a letter and end with a colon. Valid
	characters are all ASCII letters, numbers and the hyphen. Comparison
	of names is done case insensitively. Names may be used several times
	to represent an array of values. Note that the name "Key" is special
	in that it is madandory must occur only once.

	*** Values
	Values are UTF-8 encoded strings. Values can be wrapped at any point,
	and continued in the next line indicated by leading whitespace. A
	continuation line with one leading space does not introduce a blank so
	that the lines can be effectively concatenated. A blank line as part
	of a continuation line encodes a newline.

	*** Comments
	Lines containing only whitespace, and lines starting with whitespace
	followed by '#' are considered to be comments and are ignored.

	** Well defined names

	*** Description
	This is a human readable string describing the key.

	*** Key
	The name "Key" is special in that it is mandatory and must occur only
	once. The associated value holds the actual S-expression with the
	cryptographic key. The S-expression is formatted using the 'Advanced
	Format' (GCRYSEXP_FMT_ADVANCED) that avoids non-printable characters
	so that the file can be easily inspected and edited. See section
	'Private Key Format' below for details.

	*** Created
	The UTC time the key was created in ISO compressed format
	(yyyymmddThhmmss). This information can be used to re-create an
	OpenPGP key.

	*** Label
	This is a short human readable description for the key which can be
	used by the software to describe the key in a user interface. For
	example as part of the description in a prompt for a PIN or
	passphrase. It is often used instead of a comment element as present
	in the S-expression of the "Key" item.

	*** OpenSSH-cert
	This takes a base64 encoded string wrapped so that this
	key file can be easily edited with a standard editor. Several of such
	items can be used.

	*** Token
	If such an item exists it overrides the info given by the "shadow"
	parameter in the S-expression. Using this item makes it possible to
	describe a key which is stored on several tokens and also makes it
	easy to update this info using a standard editor. The syntax is the
	same as with the "shadow" parameter:

	- Serialnumber of the token
	- Key reference from the token in full format (e.g. "OpenPGP.2")
	- An optional fixed length of the PIN.

	*** Use-for-ssh
	If given and the value is "yes" or "1" the key is allowed for use by
	gpg-agent's ssh-agent implementation. This is thus the same as
	putting the keygrip into the 'sshcontrol' file. Only one such item
	should exist.

	+*** Confirm
	+If given and the value is "yes", a user will be asked confirmation by
	+a dialog window when the key is about to be used for
	+PKSIGN/PKAUTH/PKDECRYPT operation. If the value is "restricted", it
	+is only asked for the access through extra/browser socket.
	+
	+
	* Private Key Format
	** Unprotected Private Key Format

	The content of the file is an S-Expression like the ones used with
	Libgcrypt. Here is an example of an unprotected file:

	(private-key
	(rsa
	(n #00e0ce9..[some bytes not shown]..51#)
	(e #010001#)
	(d #046129F..[some bytes not shown]..81#)
	(p #00e861b..[some bytes not shown]..f1#)
	(q #00f7a7c..[some bytes not shown]..61#)
	(u #304559a..[some bytes not shown]..9b#)
	)
	(created-at timestamp)
	(uri http://foo.bar x-foo:whatever_you_want)
	(comment whatever)
	)

	"comment", "created-at" and "uri" are optional. "comment" is
	currently used to keep track of ssh key comments. "created-at" is used
	to keep track of the creation time stamp used with OpenPGP keys; it is
	optional but required for some operations to calculate the fingerprint
	of the key. This timestamp should be a string with the number of
	seconds since Epoch or an ISO time string (yyyymmddThhmmss).

	** Protected Private Key Format

	A protected key is like this:

	(protected-private-key
	(rsa
	(n #00e0ce9..[some bytes not shown]..51#)
	(e #010001#)
	(protected mode (parms) encrypted_octet_string)
	(protected-at <isotimestamp>)
	)
	(uri http://foo.bar x-foo:whatever_you_want)
	(comment whatever)
	)


	In this scheme the encrypted_octet_string is encrypted according to
	the algorithm described after the keyword protected; most protection
	algorithms need some parameters, which are given in a list before the
	encrypted_octet_string. The result of the decryption process is a
	list of the secret key parameters. The protected-at expression is
	optional; the isotimestamp is 15 bytes long (e.g. "19610711T172000").

	The currently defined protection modes are:

	*** openpgp-s2k3-sha1-aes-cbc

	This describes an algorithm using AES in CBC mode for
	encryption, SHA-1 for integrity protection and the String to Key
	algorithm 3 from OpenPGP (rfc4880).

	Example:

	(protected openpgp-s2k3-sha1-aes-cbc
	((sha1 16byte_salt no_of_iterations) 16byte_iv)
	encrypted_octet_string
	)

	The encrypted_octet string should yield this S-Exp (in canonical
	representation) after decryption:

	(
	(
	(d #046129F..[some bytes not shown]..81#)
	(p #00e861b..[some bytes not shown]..f1#)
	(q #00f7a7c..[some bytes not shown]..61#)
	(u #304559a..[some bytes not shown]..9b#)
	)
	(hash sha1 #...[hashvalue]...#)
	)

	For padding reasons, random bytes are appended to this list - they can
	easily be stripped by looking for the end of the list.

	The hash is calculated on the concatenation of the public key and
	secret key parameter lists: i.e. it is required to hash the
	concatenation of these 6 canonical encoded lists for RSA, including
	the parenthesis, the algorithm keyword and (if used) the protected-at
	list.

	(rsa
	(n #00e0ce9..[some bytes not shown]..51#)
	(e #010001#)
	(d #046129F..[some bytes not shown]..81#)
	(p #00e861b..[some bytes not shown]..f1#)
	(q #00f7a7c..[some bytes not shown]..61#)
	(u #304559a..[some bytes not shown]..9b#)
	(protected-at "18950523T000000")
	)

	After decryption the hash must be recalculated and compared against
	the stored one - If they don't match the integrity of the key is not
	given.

	*** openpgp-s2k3-ocb-aes

	This describes an algorithm using AES-128 in OCB mode, a nonce
	of 96 bit, a taglen of 128 bit, and the String to Key algorithm 3
	from OpenPGP (rfc4880).

	Example:

	(protected openpgp-s2k3-ocb-aes
	((sha1 16byte_salt no_of_iterations) 12byte_nonce)
	encrypted_octet_string
	)

	The encrypted_octet string should yield this S-Exp (in canonical
	representation) after decryption:

	(
	(
	(d #046129F..[some bytes not shown]..81#)
	(p #00e861b..[some bytes not shown]..f1#)
	(q #00f7a7c..[some bytes not shown]..61#)
	(u #304559a..[some bytes not shown]..9b#)
	)
	)

	For padding reasons, random bytes may be appended to this list -
	they can easily be stripped by looking for the end of the list.

	The associated data required for this protection mode is the list
	forming the public key parameters. For the above example this is
	is this canonical encoded S-expression:

	(rsa
	(n #00e0ce9..[some bytes not shown]..51#)
	(e #010001#)
	(protected-at "18950523T000000")
	)

	*** openpgp-native

	This is a wrapper around the OpenPGP Private Key Transport format
	which resembles the standard OpenPGP format and allows the use of an
	existing key without re-encrypting to the default protection format.

	Example:

	(protected openpgp-native
	(openpgp-private-key
	(version V)
	(algo PUBKEYALGO)
	(skey _ P1 _ P2 _ P3 ... e PN)
	(csum n)
	(protection PROTTYPE PROTALGO IV S2KMODE S2KHASH S2KSALT S2KCOUNT)))

	Note that the public key parameters in SKEY are duplicated and
	should be identical to their copies in the standard parameter
	elements. Here is an example of an entire protected private key
	using this format:

	(protected-private-key
	(rsa
	(n #00e0ce9..[some bytes not shown]..51#)
	(e #010001#)
	(protected openpgp-native
	(openpgp-private-key
	(version 4)
	(algo rsa)
	(skey _ #00e0ce9..[some bytes not shown]..51#
	_ #010001#
	e #.........................#)
	(protection sha1 aes #aabbccddeeff00112233445566778899#
	3 sha1 #2596f93e85f41e53# 3:190))))
	(uri http://foo.bar x-foo:whatever_you_want)
	(comment whatever))

	** Shadowed Private Key Format

	To keep track of keys stored on IC cards we use a third format for
	private kyes which are called shadow keys as they are only a reference
	to keys stored on a token:

	(shadowed-private-key
	(rsa
	(n #00e0ce9..[some bytes not shown]..51#)
	(e #010001#)
	(shadowed protocol (info))
	)
	(uri http://foo.bar x-foo:whatever_you_want)
	(comment whatever)
	)

	The currently used protocols are "t1-v1" (token info version 1) and
	"tpm2-v1" (TPM format key information). The second list with the
	information has this layout for "t1-v1":

	(card_serial_number id_string_of_key fixed_pin_length)

	FIXED_PIN_LENGTH is optional. It can be used to store the length of
	the PIN; a value of 0 indicates that this information is not
	available. The rationale for this field is that some pinpad equipped
	readers don't allow passing a variable length PIN.

	This is the (info) layout for "tpm2-v1":

	(parent tpm_private_string tpm_public_string)

	Although this precise format is encapsulated inside the tpm2daemon
	itself and nothing in gpg ever uses this.

	More items may be added to the list.

	** OpenPGP Private Key Transfer Format

	This format is used to transfer keys between gpg and gpg-agent.

	(openpgp-private-key
	(version V)
	(algo PUBKEYALGO)
	(curve CURVENAME)
	(skey _ P1 _ P2 _ P3 ... e PN)
	(csum n)
	(protection PROTTYPE PROTALGO IV S2KMODE S2KHASH S2KSALT S2KCOUNT))


	* V is the packet version number (3 or 4).
	* PUBKEYALGO is a Libgcrypt algo name
	* CURVENAME is the name of the curve - only used with ECC.
	* P1 .. PN are the parameters; the public parameters are never encrypted
	the secrect key parameters are encrypted if the "protection" list is
	given. To make this more explicit each parameter is preceded by a
	flag "_" for cleartext or "e" for encrypted text.
	* CSUM is the deprecated 16 bit checksum as defined by OpenPGP. This
	is an optional element.
	* If PROTTYPE is "sha1" the new style SHA1 checksum is used if it is "sum"
	the old 16 bit checksum (above) is used and if it is "none" no
	protection at all is used.
	* PROTALGO is a Libgcrypt style cipher algorithm name
	* IV is the initialization verctor.
	* S2KMODE is the value from RFC-4880.
	* S2KHASH is a libgcrypt style hash algorithm identifier.
	* S2KSALT is the 8 byte salt
	* S2KCOUNT is the count value from RFC-4880.

	** Persistent Passphrase Format

	Note: That this has not yet been implemented.

	To allow persistent storage of cached passphrases we use a scheme
	similar to the private-key storage format. This is a master
	passphrase format where each file may protect several secrets under
	one master passphrase. It is possible to have several of those files
	each protected by a dedicated master passphrase. Clear text keywords
	allow listing the available protected passphrases.

	The name of the files with these protected secrets have this form:
	pw-<string>.dat. STRING may be an arbitrary string, as a default name
	for the passphrase storage the name "pw-default.dat" is suggested.


	(protected-shared-secret
	((desc descriptive_text)
	(key [key_1] (keyword_1 keyword_2 keyword_n))
	(key [key_2] (keyword_21 keyword_22 keyword_2n))
	(key [key_n] (keyword_n1 keyword_n2 keyword_nn))
	(protected mode (parms) encrypted_octet_string)
	(protected-at <isotimestamp>)
	)
	)

	After decryption the encrypted_octet_string yields this S-expression:

	(
	(
	(value key_1 value_1)
	(value key_2 value_2)
	(value key_n value_n)
	)
	(hash sha1 #...[hashvalue]...#)
	)

	The "descriptive_text" is displayed with the prompt to enter the
	unprotection passphrase.

	KEY_1 to KEY_N are unique identifiers for the shared secret, for
	example an URI. In case this information should be kept confidential
	as well, they may not appear in the unprotected part; however they are
	mandatory in the encrypted_octet_string. The list of keywords is
	optional. The order of the "key" lists and the order of the "value"
	lists must match, that is the first "key"-list is associated with the
	first "value" list in the encrypted_octet_string.

	The protection mode etc. is identical to the protection mode as
	described for the private key format.

	list of the secret key parameters. The protected-at expression is
	optional; the isotimestamp is 15 bytes long (e.g. "19610711T172000").

	The "hash" in the encrypted_octet_string is calculated on the
	concatenation of the key list and value lists: i.e it is required to
	hash the concatenation of all these lists, including the
	parenthesis and (if used) the protected-at list.

	Example:

	(protected-shared-secret
	((desc "List of system passphrases")
	(key "uid-1002" ("Knuth" "Donald Ervin Knuth"))
	(key "uid-1001" ("Dijkstra" "Edsger Wybe Dijkstra"))
	(key)
	(protected mode (parms) encrypted_octet_string)
	(protected-at "20100915T111722")
	)
	)

	with "encrypted_octet_string" decoding to:

	(
	(
	(value 4:1002 "signal flags at the lock")
	(value 4:1001 "taocp")
	(value 1:0 "premature optimization is the root of all evil")
	)
	(hash sha1 #0102030405060708091011121314151617181920#)
	)

	To compute the hash this S-expression (in canoncical format) was
	hashed:

	((desc "List of system passphrases")
	(key "uid-1002" ("Knuth" "Donald Ervin Knuth"))
	(key "uid-1001" ("Dijkstra" "Edsger Wybe Dijkstra"))
	(key)
	(value 4:1002 "signal flags at the lock")
	(value 4:1001 "taocp")
	(value 1:0 "premature optimization is the root of all evil")
	(protected-at "20100915T111722")
	)

	* Notes

	[1] I usually use the terms private and secret key exchangeable but prefer the
	term secret key because it can be visually be better distinguished
	from the term public key.

	[2] The keygrip is a unique identifier for a key pair, it is
	independent of any protocol, so that the same key can be used with
	different protocols. PKCS-15 calls this a subjectKeyHash; it can be
	calculated using Libgcrypt's gcry_pk_get_keygrip ().

	[3] Even when canonical representation are required we will show the
	S-expression here in a more readable representation.

File Metadata

Mime Type: text/x-diff
Expires: Mon, Dec 23, 2:10 PM (21 h, 58 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 3e/81/a87c82218859e1b2f53715d722a2

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions