2007-08-28 19:48:13 +02:00
|
|
|
|
/* findkey.c - Locate the secret key
|
2010-04-21 18:26:17 +02:00
|
|
|
|
* Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007,
|
2011-07-20 20:49:41 +02:00
|
|
|
|
* 2010, 2011 Free Software Foundation, Inc.
|
2023-03-13 08:49:49 +01:00
|
|
|
|
* Copyright (C) 2014, 2019 Werner Koch
|
|
|
|
|
* Copyright (C) 2023 g10 Code GmbH
|
2003-08-05 19:11:04 +02:00
|
|
|
|
*
|
|
|
|
|
* 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
|
2007-07-04 21:49:40 +02:00
|
|
|
|
* the Free Software Foundation; either version 3 of the License, or
|
2003-08-05 19:11:04 +02:00
|
|
|
|
* (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
|
2016-11-05 12:02:19 +01:00
|
|
|
|
* along with this program; if not, see <https://www.gnu.org/licenses/>.
|
2003-08-05 19:11:04 +02:00
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#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>
|
Port to npth.
* configure.ac: Don't check for PTH but for NPTH.
(AH_BOTTOM): Remove PTH_SYSCALL_SOFT.
(have_pth): Rename to ...
(have_npth): ... this.
(USE_GNU_NPTH): Rename to ...
(USE_GNU_PTH): ... this.
* m4/npth.m4: New file.
* agent/Makefile.am, agent/cache.c, agent/call-pinentry.c,
agent/call-scd.c, agent/findkey.c, agent/gpg-agent.c,
agent/trustlist.c, common/Makefile.am, common/estream.c,
common/exechelp-posix.c, common/exechelp-w32.c,
common/exechelp-w32ce.c, common/http.c, common/init.c,
common/sysutils.c, dirmngr/Makefile.am, dirmngr/crlfetch.c,
dirmngr/dirmngr.c, dirmngr/dirmngr_ldap.c, dirmngr/ldap-wrapper-ce.c,
dirmngr/ldap-wrapper.c, dirmngr/ldap.c, g13/Makefile.am,
g13/call-gpg.c, g13/g13.c, g13/runner.c, scd/Makefile.am,
scd/apdu.c, scd/app.c, scd/ccid-driver.c, scd/command.c,
scd/scdaemon.c, tools/Makefile.am: Port to npth.
2012-01-03 22:12:37 +01:00
|
|
|
|
#include <npth.h> /* (we use pth_sleep) */
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
#include "agent.h"
|
agent: Resolve conflict of util.h.
* agent/Makefile.am (AM_CPPFLAGS): Remove -I$(top_srcdir)/common.
* agent/call-pinentry.c, agent/call-scd.c: Follow the change.
* agent/command-ssh.c, agent/command.c, agent/cvt-openpgp.c: Ditto.
* agent/divert-scd.c, agent/findkey.c, agent/genkey.c: Ditto.
* agent/gpg-agent.c, agent/pksign.c, agent/preset-passphrase.c: Ditto.
* agent/protect-tool.c, agent/protect.c, agent/trustlist.c: Ditto.
* agent/w32main.c: Ditto.
--
For openpty function, we need to include util.h on some OS.
We also have util.h in common/, so this change is needed.
Signed-off-by: NIIBE Yutaka <gniibe@fsij.org>
2017-03-07 11:22:48 +01:00
|
|
|
|
#include "../common/i18n.h"
|
2011-07-20 20:49:41 +02:00
|
|
|
|
#include "../common/ssh-utils.h"
|
2016-06-23 11:55:46 +02:00
|
|
|
|
#include "../common/name-value.h"
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2007-08-22 22:36:33 +02:00
|
|
|
|
#ifndef O_BINARY
|
|
|
|
|
#define O_BINARY 0
|
|
|
|
|
#endif
|
|
|
|
|
|
2023-03-14 10:09:41 +01:00
|
|
|
|
|
|
|
|
|
static gpg_error_t read_key_file (const unsigned char *grip,
|
2023-11-21 12:13:50 +01:00
|
|
|
|
gcry_sexp_t *result, nvc_t *r_keymeta,
|
|
|
|
|
char **r_orig_key_value);
|
2023-03-14 10:09:41 +01:00
|
|
|
|
static gpg_error_t is_shadowed_key (gcry_sexp_t s_skey);
|
|
|
|
|
|
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
/* Helper to pass data to the check callback of the unprotect function. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
struct try_unprotect_arg_s
|
2007-08-28 19:48:13 +02:00
|
|
|
|
{
|
|
|
|
|
ctrl_t ctrl;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
const unsigned char *protected_key;
|
|
|
|
|
unsigned char *unprotected_key;
|
2007-08-28 19:48:13 +02:00
|
|
|
|
int change_required; /* Set by the callback to indicate that the
|
2015-05-08 08:55:57 +02:00
|
|
|
|
user should change the passphrase. */
|
2003-08-05 19:11:04 +02:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2023-03-14 10:09:41 +01:00
|
|
|
|
/* Return the file name for the 20 byte keygrip GRIP. With FOR_NEW
|
|
|
|
|
* create a file name for later renaming to the actual name. Return
|
|
|
|
|
* NULL on error. */
|
2022-08-16 12:02:51 +02:00
|
|
|
|
static char *
|
2023-03-14 10:09:41 +01:00
|
|
|
|
fname_from_keygrip (const unsigned char *grip, int for_new)
|
2022-08-16 12:02:51 +02:00
|
|
|
|
{
|
2023-03-14 10:09:41 +01:00
|
|
|
|
char hexgrip[40+4+4+1];
|
2022-08-16 12:02:51 +02:00
|
|
|
|
|
|
|
|
|
bin2hex (grip, 20, hexgrip);
|
2023-03-14 10:09:41 +01:00
|
|
|
|
strcpy (hexgrip+40, for_new? ".key.tmp" : ".key");
|
2022-08-16 12:02:51 +02:00
|
|
|
|
|
|
|
|
|
return make_filename_try (gnupg_homedir (), GNUPG_PRIVATE_KEYS_DIR,
|
|
|
|
|
hexgrip, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2023-03-13 08:49:49 +01:00
|
|
|
|
/* Write the S-expression formatted key (BUFFER,LENGTH) to our key
|
|
|
|
|
* storage. With FORCE passed as true an existing key with the given
|
2023-03-14 10:09:41 +01:00
|
|
|
|
* GRIP will be overwritten. If SERIALNO and KEYREF are given a Token
|
|
|
|
|
* line is added to the key if the extended format is used. If
|
2023-03-13 08:49:49 +01:00
|
|
|
|
* 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,
|
2024-01-24 11:29:24 +01:00
|
|
|
|
const void *buffer, size_t length,
|
|
|
|
|
int force, int reallyforce,
|
2023-03-13 08:49:49 +01:00
|
|
|
|
const char *serialno, const char *keyref,
|
|
|
|
|
const char *dispserialno,
|
|
|
|
|
time_t timestamp)
|
2016-04-08 19:21:12 +02:00
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
2023-03-14 10:09:41 +01:00
|
|
|
|
char *oldfname = NULL;
|
|
|
|
|
char *fname = NULL;
|
2024-08-08 17:13:47 +02:00
|
|
|
|
estream_t fp = NULL;
|
2023-03-14 10:09:41 +01:00
|
|
|
|
int newkey = 0;
|
2016-06-23 12:12:50 +02:00
|
|
|
|
nvc_t pk = NULL;
|
2016-04-08 19:21:12 +02:00
|
|
|
|
gcry_sexp_t key = NULL;
|
2023-03-14 10:09:41 +01:00
|
|
|
|
int is_regular;
|
2016-04-08 19:21:12 +02:00
|
|
|
|
int remove = 0;
|
2022-08-15 12:49:56 +02:00
|
|
|
|
char *token0 = NULL;
|
|
|
|
|
char *token = NULL;
|
2022-08-16 12:02:51 +02:00
|
|
|
|
char *dispserialno_buffer = NULL;
|
|
|
|
|
char **tokenfields = NULL;
|
2023-03-14 10:09:41 +01:00
|
|
|
|
int blocksigs = 0;
|
2023-11-21 12:13:50 +01:00
|
|
|
|
char *orig_key_value = NULL;
|
|
|
|
|
const char *s;
|
|
|
|
|
int force_modify = 0;
|
2016-04-08 19:21:12 +02:00
|
|
|
|
|
2023-03-14 10:09:41 +01:00
|
|
|
|
oldfname = fname_from_keygrip (grip, 0);
|
|
|
|
|
if (!oldfname)
|
2023-03-13 08:49:49 +01:00
|
|
|
|
return out_of_core ();
|
|
|
|
|
|
2023-11-21 12:13:50 +01:00
|
|
|
|
err = read_key_file (grip, &key, &pk, &orig_key_value);
|
2023-03-14 10:09:41 +01:00
|
|
|
|
if (err)
|
2023-03-13 08:49:49 +01:00
|
|
|
|
{
|
2023-03-14 10:09:41 +01:00
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_ENOENT)
|
|
|
|
|
newkey = 1;
|
2023-03-13 08:49:49 +01:00
|
|
|
|
else
|
|
|
|
|
{
|
2023-03-14 10:09:41 +01:00
|
|
|
|
log_error ("can't open '%s': %s\n", oldfname, gpg_strerror (err));
|
2017-03-24 10:30:17 +01:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-03-14 10:09:41 +01:00
|
|
|
|
|
2023-11-21 08:34:04 +01:00
|
|
|
|
nvc_modified (pk, 1); /* Clear that flag after a read. */
|
|
|
|
|
|
2023-03-14 10:09:41 +01:00
|
|
|
|
if (!pk)
|
2023-03-13 08:49:49 +01:00
|
|
|
|
{
|
2023-03-14 10:09:41 +01:00
|
|
|
|
/* Key is still in the old format or does not exist - create a
|
|
|
|
|
* new container. */
|
2023-03-13 08:49:49 +01:00
|
|
|
|
pk = nvc_new_private_key ();
|
|
|
|
|
if (!pk)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2023-11-21 12:13:50 +01:00
|
|
|
|
force_modify = 1;
|
2023-03-13 08:49:49 +01:00
|
|
|
|
}
|
2023-03-14 10:09:41 +01:00
|
|
|
|
|
|
|
|
|
/* Check whether we already have a regular key. */
|
|
|
|
|
is_regular = (key && gpg_err_code (is_shadowed_key (key)) != GPG_ERR_TRUE);
|
2016-04-08 19:21:12 +02:00
|
|
|
|
|
2023-03-13 08:49:49 +01:00
|
|
|
|
/* Turn (BUFFER,LENGTH) into a gcrypt s-expression and set it into
|
|
|
|
|
* our name value container. */
|
2023-03-14 10:09:41 +01:00
|
|
|
|
gcry_sexp_release (key);
|
2023-03-13 08:49:49 +01:00
|
|
|
|
err = gcry_sexp_sscan (&key, NULL, buffer, length);
|
2016-04-08 19:21:12 +02:00
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
2016-06-23 12:12:50 +02:00
|
|
|
|
err = nvc_set_private_key (pk, key);
|
2016-04-08 19:21:12 +02:00
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
2023-11-21 12:13:50 +01:00
|
|
|
|
/* Detect whether the key value actually changed and if not clear
|
|
|
|
|
* the modified flag. This extra check is required because
|
|
|
|
|
* read_key_file removes the Key entry from the container and we
|
|
|
|
|
* then create a new Key entry which might be the same, though. */
|
|
|
|
|
if (!force_modify
|
|
|
|
|
&& orig_key_value && (s = nvc_get_string (pk, "Key:"))
|
|
|
|
|
&& !strcmp (orig_key_value, s))
|
|
|
|
|
{
|
|
|
|
|
nvc_modified (pk, 1); /* Clear that flag. */
|
|
|
|
|
}
|
|
|
|
|
xfree (orig_key_value);
|
|
|
|
|
orig_key_value = NULL;
|
|
|
|
|
|
2023-03-14 10:09:41 +01:00
|
|
|
|
/* Check that we do not update a regular key with a shadow key. */
|
|
|
|
|
if (is_regular && gpg_err_code (is_shadowed_key (key)) == GPG_ERR_TRUE)
|
|
|
|
|
{
|
2024-01-24 11:29:24 +01:00
|
|
|
|
if (!reallyforce)
|
|
|
|
|
{
|
|
|
|
|
log_info ("updating regular key file '%s'"
|
|
|
|
|
" by a shadow key inhibited\n", oldfname);
|
|
|
|
|
err = 0; /* Simply ignore the error. */
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2023-03-14 10:09:41 +01:00
|
|
|
|
}
|
|
|
|
|
/* Check that we update a regular key only in force mode. */
|
|
|
|
|
if (is_regular && !force)
|
|
|
|
|
{
|
|
|
|
|
log_error ("secret key file '%s' already exists\n", oldfname);
|
|
|
|
|
err = gpg_error (GPG_ERR_EEXIST);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-15 12:49:56 +02:00
|
|
|
|
/* If requested write a Token line. */
|
|
|
|
|
if (serialno && keyref)
|
|
|
|
|
{
|
|
|
|
|
nve_t item;
|
|
|
|
|
size_t token0len;
|
|
|
|
|
|
|
|
|
|
if (dispserialno)
|
|
|
|
|
{
|
2022-08-16 12:02:51 +02:00
|
|
|
|
/* Escape the DISPSERIALNO. */
|
|
|
|
|
dispserialno_buffer = percent_plus_escape (dispserialno);
|
|
|
|
|
if (!dispserialno_buffer)
|
2022-08-15 12:49:56 +02:00
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2022-08-16 12:02:51 +02:00
|
|
|
|
dispserialno = dispserialno_buffer;
|
2022-08-15 12:49:56 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
token0 = strconcat (serialno, " ", keyref, NULL);
|
|
|
|
|
if (token0)
|
2022-08-16 12:02:51 +02:00
|
|
|
|
token = strconcat (token0, " - ", dispserialno? dispserialno:"-", NULL);
|
2022-08-15 12:49:56 +02:00
|
|
|
|
if (!token0 || !token)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
token0len = strlen (token0);
|
|
|
|
|
for (item = nvc_lookup (pk, "Token:");
|
|
|
|
|
item;
|
|
|
|
|
item = nve_next_value (item, "Token:"))
|
|
|
|
|
if ((s = nve_value (item)) && !strncmp (s, token0, token0len))
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Token exists: Update the display s/n. It may have
|
|
|
|
|
* changed due to changes in a newer software version. */
|
2023-03-13 08:49:49 +01:00
|
|
|
|
if (s && (tokenfields = strtokenize (s, " \t\n"))
|
2022-08-16 12:02:51 +02:00
|
|
|
|
&& tokenfields[0] && tokenfields[1] && tokenfields[2]
|
|
|
|
|
&& tokenfields[3]
|
|
|
|
|
&& !strcmp (tokenfields[3], dispserialno))
|
|
|
|
|
; /* No need to update Token entry. */
|
|
|
|
|
else
|
|
|
|
|
{
|
2023-11-21 08:34:04 +01:00
|
|
|
|
err = nve_set (pk, item, token);
|
2022-08-16 12:02:51 +02:00
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2022-08-15 12:49:56 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-13 08:49:49 +01:00
|
|
|
|
/* 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;
|
|
|
|
|
}
|
|
|
|
|
|
2023-11-21 08:34:04 +01:00
|
|
|
|
/* Check whether we need to write the file at all. */
|
|
|
|
|
if (!nvc_modified (pk, 0))
|
|
|
|
|
{
|
|
|
|
|
err = 0;
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-14 10:09:41 +01:00
|
|
|
|
/* Create a temporary file for writing. */
|
|
|
|
|
fname = fname_from_keygrip (grip, 1);
|
|
|
|
|
fp = fname ? es_fopen (fname, "wbx,mode=-rw") : NULL;
|
|
|
|
|
if (!fp)
|
|
|
|
|
{
|
2023-05-26 14:19:27 +02:00
|
|
|
|
err = gpg_error_from_syserror ();
|
2023-03-14 10:09:41 +01:00
|
|
|
|
log_error ("can't create '%s': %s\n", fname, gpg_strerror (err));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2016-04-08 19:21:12 +02:00
|
|
|
|
|
2023-03-13 08:49:49 +01:00
|
|
|
|
err = nvc_write (pk, fp);
|
2023-05-26 14:19:27 +02:00
|
|
|
|
if (!err && es_fflush (fp))
|
|
|
|
|
err = gpg_error_from_syserror ();
|
2023-03-13 08:49:49 +01:00
|
|
|
|
if (err)
|
2016-04-08 19:21:12 +02:00
|
|
|
|
{
|
2023-03-13 08:49:49 +01:00
|
|
|
|
log_error ("error writing '%s': %s\n", fname, gpg_strerror (err));
|
|
|
|
|
remove = 1;
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2016-04-08 19:21:12 +02:00
|
|
|
|
|
2023-03-14 10:09:41 +01:00
|
|
|
|
if (es_fclose (fp))
|
2023-03-13 08:49:49 +01:00
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
2023-03-14 10:09:41 +01:00
|
|
|
|
log_error ("error closing '%s': %s\n", fname, gpg_strerror (err));
|
2023-03-13 08:49:49 +01:00
|
|
|
|
remove = 1;
|
|
|
|
|
goto leave;
|
2016-04-08 19:21:12 +02:00
|
|
|
|
}
|
2023-03-14 10:09:41 +01:00
|
|
|
|
fp = NULL;
|
2016-04-08 19:21:12 +02:00
|
|
|
|
|
2023-03-14 10:09:41 +01:00
|
|
|
|
err = gnupg_rename_file (fname, oldfname, &blocksigs);
|
|
|
|
|
if (err)
|
2016-04-08 19:21:12 +02:00
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
2023-03-14 10:09:41 +01:00
|
|
|
|
log_error ("error renaming '%s': %s\n", fname, gpg_strerror (err));
|
2016-04-08 19:21:12 +02:00
|
|
|
|
remove = 1;
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-13 08:49:49 +01:00
|
|
|
|
bump_key_eventcounter ();
|
2016-04-08 19:21:12 +02:00
|
|
|
|
|
|
|
|
|
leave:
|
2023-03-14 10:09:41 +01:00
|
|
|
|
if (blocksigs)
|
|
|
|
|
gnupg_unblock_all_signals ();
|
2017-03-24 10:30:17 +01:00
|
|
|
|
es_fclose (fp);
|
2023-03-14 10:09:41 +01:00
|
|
|
|
if (remove && fname)
|
2016-04-08 19:21:12 +02:00
|
|
|
|
gnupg_remove (fname);
|
2023-11-21 12:13:50 +01:00
|
|
|
|
xfree (orig_key_value);
|
2016-04-08 19:21:12 +02:00
|
|
|
|
xfree (fname);
|
2023-03-14 10:09:41 +01:00
|
|
|
|
xfree (oldfname);
|
2022-08-15 12:49:56 +02:00
|
|
|
|
xfree (token);
|
|
|
|
|
xfree (token0);
|
2022-08-16 12:02:51 +02:00
|
|
|
|
xfree (dispserialno_buffer);
|
|
|
|
|
xfree (tokenfields);
|
2016-04-08 19:21:12 +02:00
|
|
|
|
gcry_sexp_release (key);
|
2016-06-23 12:12:50 +02:00
|
|
|
|
nvc_release (pk);
|
2016-04-08 19:21:12 +02:00
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2010-10-01 22:33:53 +02:00
|
|
|
|
/* Callback function to try the unprotection from the passphrase query
|
2003-08-05 19:11:04 +02:00
|
|
|
|
code. */
|
2015-10-09 04:33:13 +02:00
|
|
|
|
static gpg_error_t
|
2003-08-05 19:11:04 +02:00
|
|
|
|
try_unprotect_cb (struct pin_entry_info_s *pi)
|
|
|
|
|
{
|
|
|
|
|
struct try_unprotect_arg_s *arg = pi->check_cb_arg;
|
2015-06-30 21:58:02 +02:00
|
|
|
|
ctrl_t ctrl = arg->ctrl;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
size_t dummy;
|
2007-08-28 19:48:13 +02:00
|
|
|
|
gpg_error_t err;
|
|
|
|
|
gnupg_isotime_t now, protected_at, tmptime;
|
|
|
|
|
char *desc = NULL;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2023-03-14 10:09:41 +01:00
|
|
|
|
log_assert (!arg->unprotected_key);
|
2007-08-28 19:48:13 +02:00
|
|
|
|
|
|
|
|
|
arg->change_required = 0;
|
2015-06-30 21:58:02 +02:00
|
|
|
|
err = agent_unprotect (ctrl, arg->protected_key, pi->pin, protected_at,
|
2007-08-28 19:48:13 +02:00
|
|
|
|
&arg->unprotected_key, &dummy);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2015-06-30 21:58:02 +02:00
|
|
|
|
if (!opt.max_passphrase_days || ctrl->in_passwd)
|
2007-08-28 19:48:13 +02:00
|
|
|
|
return 0; /* No regular passphrase change required. */
|
|
|
|
|
|
|
|
|
|
if (!*protected_at)
|
|
|
|
|
{
|
|
|
|
|
/* No protection date known - must force passphrase change. */
|
2015-06-30 21:58:02 +02:00
|
|
|
|
desc = xtrystrdup (L_("Note: This passphrase has never been changed.%0A"
|
|
|
|
|
"Please change it now."));
|
2007-08-28 19:48:13 +02:00
|
|
|
|
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". */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
desc = xtryasprintf
|
2015-06-30 21:58:02 +02:00
|
|
|
|
(L_("This passphrase has not been changed%%0A"
|
|
|
|
|
"since %.4s-%.2s-%.2s. Please change it now."),
|
2007-08-28 19:48:13 +02:00
|
|
|
|
protected_at, protected_at+4, protected_at+6);
|
|
|
|
|
if (!desc)
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (desc)
|
|
|
|
|
{
|
|
|
|
|
/* Change required. */
|
|
|
|
|
if (opt.enforce_passphrase_constraints)
|
|
|
|
|
{
|
2015-06-30 21:58:02 +02:00
|
|
|
|
err = agent_get_confirmation (ctrl, desc,
|
|
|
|
|
L_("Change passphrase"), NULL, 0);
|
2007-08-28 19:48:13 +02:00
|
|
|
|
if (!err)
|
|
|
|
|
arg->change_required = 1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2015-06-30 21:58:02 +02:00
|
|
|
|
err = agent_get_confirmation (ctrl, desc,
|
|
|
|
|
L_("Change passphrase"),
|
|
|
|
|
L_("I'll change it later"), 0);
|
2007-08-28 19:48:13 +02:00
|
|
|
|
if (!err)
|
|
|
|
|
arg->change_required = 1;
|
2010-10-13 17:57:08 +02:00
|
|
|
|
else if (gpg_err_code (err) == GPG_ERR_CANCELED
|
|
|
|
|
|| gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
|
2007-08-28 19:48:13 +02:00
|
|
|
|
err = 0;
|
|
|
|
|
}
|
|
|
|
|
xfree (desc);
|
|
|
|
|
}
|
|
|
|
|
|
2017-04-14 05:54:06 +02:00
|
|
|
|
return err;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-01-26 23:20:21 +01:00
|
|
|
|
/* Modify a Key description, replacing certain special format
|
|
|
|
|
characters. List of currently supported replacements:
|
|
|
|
|
|
2005-02-03 18:40:02 +01:00
|
|
|
|
%% - Replaced by a single %
|
|
|
|
|
%c - Replaced by the content of COMMENT.
|
2014-04-15 16:40:48 +02:00
|
|
|
|
%C - Same as %c but put into parentheses.
|
2011-07-20 20:49:41 +02:00
|
|
|
|
%F - Replaced by an ssh style fingerprint computed from KEY.
|
2005-01-26 23:20:21 +01:00
|
|
|
|
|
2005-02-03 18:40:02 +01:00
|
|
|
|
The functions returns 0 on success or an error code. On success a
|
|
|
|
|
newly allocated string is stored at the address of RESULT.
|
|
|
|
|
*/
|
2017-02-22 11:04:55 +01:00
|
|
|
|
gpg_error_t
|
|
|
|
|
agent_modify_description (const char *in, const char *comment,
|
|
|
|
|
const gcry_sexp_t key, char **result)
|
2005-02-03 18:40:02 +01:00
|
|
|
|
{
|
|
|
|
|
size_t comment_length;
|
|
|
|
|
size_t in_len;
|
|
|
|
|
size_t out_len;
|
|
|
|
|
char *out;
|
|
|
|
|
size_t i;
|
|
|
|
|
int special, pass;
|
2011-07-20 20:49:41 +02:00
|
|
|
|
char *ssh_fpr = NULL;
|
2017-02-22 11:04:55 +01:00
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
|
|
*result = NULL;
|
|
|
|
|
|
|
|
|
|
if (!comment)
|
|
|
|
|
comment = "";
|
2005-02-03 18:40:02 +01:00
|
|
|
|
|
|
|
|
|
comment_length = strlen (comment);
|
|
|
|
|
in_len = strlen (in);
|
|
|
|
|
|
|
|
|
|
/* First pass calculates the length, second pass does the actual
|
|
|
|
|
copying. */
|
2017-02-22 11:04:55 +01:00
|
|
|
|
/* FIXME: This can be simplified by using es_fopenmem. */
|
2005-02-03 18:40:02 +01:00
|
|
|
|
out = NULL;
|
|
|
|
|
out_len = 0;
|
|
|
|
|
for (pass=0; pass < 2; pass++)
|
2005-01-26 23:20:21 +01:00
|
|
|
|
{
|
2005-02-03 18:40:02 +01:00
|
|
|
|
special = 0;
|
|
|
|
|
for (i = 0; i < in_len; i++)
|
|
|
|
|
{
|
2005-02-25 17:14:55 +01:00
|
|
|
|
if (special)
|
2005-02-03 18:40:02 +01:00
|
|
|
|
{
|
|
|
|
|
special = 0;
|
|
|
|
|
switch (in[i])
|
|
|
|
|
{
|
|
|
|
|
case '%':
|
|
|
|
|
if (out)
|
|
|
|
|
*out++ = '%';
|
2005-02-15 17:23:45 +01:00
|
|
|
|
else
|
|
|
|
|
out_len++;
|
2005-02-03 18:40:02 +01:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'c': /* Comment. */
|
2005-02-15 17:23:45 +01:00
|
|
|
|
if (out)
|
2005-02-03 18:40:02 +01:00
|
|
|
|
{
|
|
|
|
|
memcpy (out, comment, comment_length);
|
|
|
|
|
out += comment_length;
|
|
|
|
|
}
|
2005-02-15 17:23:45 +01:00
|
|
|
|
else
|
|
|
|
|
out_len += comment_length;
|
2005-02-03 18:40:02 +01:00
|
|
|
|
break;
|
|
|
|
|
|
2014-04-15 16:40:48 +02:00
|
|
|
|
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;
|
|
|
|
|
|
2011-07-20 20:49:41 +02:00
|
|
|
|
case 'F': /* SSH style fingerprint. */
|
|
|
|
|
if (!ssh_fpr && key)
|
2017-05-24 17:48:42 +02:00
|
|
|
|
ssh_get_fingerprint_string (key, opt.ssh_fingerprint_digest,
|
|
|
|
|
&ssh_fpr);
|
2011-07-20 20:49:41 +02:00
|
|
|
|
if (ssh_fpr)
|
|
|
|
|
{
|
|
|
|
|
if (out)
|
|
|
|
|
out = stpcpy (out, ssh_fpr);
|
|
|
|
|
else
|
|
|
|
|
out_len += strlen (ssh_fpr);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
2005-02-25 17:14:55 +01:00
|
|
|
|
default: /* Invalid special sequences are kept as they are. */
|
|
|
|
|
if (out)
|
|
|
|
|
{
|
|
|
|
|
*out++ = '%';
|
|
|
|
|
*out++ = in[i];
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
out_len+=2;
|
2005-02-03 18:40:02 +01:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2005-02-25 17:14:55 +01:00
|
|
|
|
else if (in[i] == '%')
|
|
|
|
|
special = 1;
|
2005-02-03 18:40:02 +01:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (out)
|
|
|
|
|
*out++ = in[i];
|
2005-02-15 17:23:45 +01:00
|
|
|
|
else
|
|
|
|
|
out_len++;
|
2005-02-03 18:40:02 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2005-02-03 18:40:02 +01:00
|
|
|
|
if (!pass)
|
|
|
|
|
{
|
|
|
|
|
*result = out = xtrymalloc (out_len + 1);
|
|
|
|
|
if (!out)
|
2011-07-20 20:49:41 +02:00
|
|
|
|
{
|
|
|
|
|
xfree (ssh_fpr);
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
}
|
2005-02-03 18:40:02 +01:00
|
|
|
|
}
|
2005-01-26 23:20:21 +01:00
|
|
|
|
}
|
|
|
|
|
|
2005-02-03 18:40:02 +01:00
|
|
|
|
*out = 0;
|
2017-02-22 11:04:55 +01:00
|
|
|
|
log_assert (*result + out_len == out);
|
2011-07-20 20:49:41 +02:00
|
|
|
|
xfree (ssh_fpr);
|
2017-02-22 11:04:55 +01:00
|
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
}
|
|
|
|
|
|
2005-02-03 18:40:02 +01:00
|
|
|
|
return 0;
|
2005-01-26 23:20:21 +01:00
|
|
|
|
}
|
|
|
|
|
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2005-01-26 23:20:21 +01:00
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
/* Unprotect the canconical encoded S-expression key in KEYBUF. GRIP
|
|
|
|
|
should be the hex encoded keygrip of that key to be used with the
|
2004-02-13 18:06:34 +01:00
|
|
|
|
caching mechanism. DESC_TEXT may be set to override the default
|
2009-05-15 13:16:28 +02:00
|
|
|
|
description used for the pinentry. If LOOKUP_TTL is given this
|
2010-10-01 22:33:53 +02:00
|
|
|
|
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. */
|
2017-07-28 10:37:33 +02:00
|
|
|
|
static gpg_error_t
|
2010-09-01 14:49:05 +02:00
|
|
|
|
unprotect (ctrl_t ctrl, const char *cache_nonce, const char *desc_text,
|
2011-02-04 12:57:53 +01:00
|
|
|
|
unsigned char **keybuf, const unsigned char *grip,
|
2010-10-01 22:33:53 +02:00
|
|
|
|
cache_mode_t cache_mode, lookup_ttl_t lookup_ttl,
|
|
|
|
|
char **r_passphrase)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
|
|
|
|
struct pin_entry_info_s *pi;
|
|
|
|
|
struct try_unprotect_arg_s arg;
|
2009-03-06 18:31:27 +01:00
|
|
|
|
int rc;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
unsigned char *result;
|
|
|
|
|
size_t resultlen;
|
|
|
|
|
char hexgrip[40+1];
|
2010-10-01 22:33:53 +02:00
|
|
|
|
|
|
|
|
|
if (r_passphrase)
|
|
|
|
|
*r_passphrase = NULL;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-03-06 18:31:27 +01:00
|
|
|
|
bin2hex (grip, 20, hexgrip);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2010-09-01 14:49:05 +02:00
|
|
|
|
/* Initially try to get it using a cache nonce. */
|
|
|
|
|
if (cache_nonce)
|
|
|
|
|
{
|
2010-09-02 12:46:23 +02:00
|
|
|
|
char *pw;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2018-03-27 08:40:58 +02:00
|
|
|
|
pw = agent_get_cache (ctrl, cache_nonce, CACHE_MODE_NONCE);
|
2010-09-01 14:49:05 +02:00
|
|
|
|
if (pw)
|
|
|
|
|
{
|
2013-05-22 10:50:12 +02:00
|
|
|
|
rc = agent_unprotect (ctrl, *keybuf, pw, NULL, &result, &resultlen);
|
2010-09-01 14:49:05 +02:00
|
|
|
|
if (!rc)
|
|
|
|
|
{
|
2010-10-01 22:33:53 +02:00
|
|
|
|
if (r_passphrase)
|
|
|
|
|
*r_passphrase = pw;
|
|
|
|
|
else
|
|
|
|
|
xfree (pw);
|
2010-09-01 14:49:05 +02:00
|
|
|
|
xfree (*keybuf);
|
|
|
|
|
*keybuf = result;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2010-10-01 22:33:53 +02:00
|
|
|
|
xfree (pw);
|
2010-09-01 14:49:05 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2004-02-03 17:24:37 +01:00
|
|
|
|
/* First try to get it from the cache - if there is none or we can't
|
2003-08-05 19:11:04 +02:00
|
|
|
|
unprotect it, we fall back to ask the user */
|
2005-06-07 21:09:18 +02:00
|
|
|
|
if (cache_mode != CACHE_MODE_IGNORE)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
2010-09-02 12:46:23 +02:00
|
|
|
|
char *pw;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2006-10-19 16:22:06 +02:00
|
|
|
|
retry:
|
2018-03-27 08:40:58 +02:00
|
|
|
|
pw = agent_get_cache (ctrl, hexgrip, cache_mode);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (pw)
|
|
|
|
|
{
|
2013-05-22 10:50:12 +02:00
|
|
|
|
rc = agent_unprotect (ctrl, *keybuf, pw, NULL, &result, &resultlen);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (!rc)
|
|
|
|
|
{
|
2014-09-17 15:12:08 +02:00
|
|
|
|
if (cache_mode == CACHE_MODE_NORMAL)
|
|
|
|
|
agent_store_cache_hit (hexgrip);
|
2010-10-01 22:33:53 +02:00
|
|
|
|
if (r_passphrase)
|
|
|
|
|
*r_passphrase = pw;
|
|
|
|
|
else
|
|
|
|
|
xfree (pw);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
xfree (*keybuf);
|
|
|
|
|
*keybuf = result;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2010-10-01 22:33:53 +02:00
|
|
|
|
xfree (pw);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
2014-09-17 15:12:08 +02:00
|
|
|
|
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. */
|
2018-03-27 08:40:58 +02:00
|
|
|
|
pw = agent_get_cache (ctrl, NULL, cache_mode);
|
2014-09-17 15:12:08 +02:00
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
}
|
2006-10-19 16:22:06 +02:00
|
|
|
|
|
|
|
|
|
/* If the pinentry is currently in use, we wait up to 60 seconds
|
2007-08-28 19:48:13 +02:00
|
|
|
|
for it to close and check the cache again. This solves a common
|
2006-10-19 16:22:06 +02:00
|
|
|
|
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. */
|
Port to npth.
* configure.ac: Don't check for PTH but for NPTH.
(AH_BOTTOM): Remove PTH_SYSCALL_SOFT.
(have_pth): Rename to ...
(have_npth): ... this.
(USE_GNU_NPTH): Rename to ...
(USE_GNU_PTH): ... this.
* m4/npth.m4: New file.
* agent/Makefile.am, agent/cache.c, agent/call-pinentry.c,
agent/call-scd.c, agent/findkey.c, agent/gpg-agent.c,
agent/trustlist.c, common/Makefile.am, common/estream.c,
common/exechelp-posix.c, common/exechelp-w32.c,
common/exechelp-w32ce.c, common/http.c, common/init.c,
common/sysutils.c, dirmngr/Makefile.am, dirmngr/crlfetch.c,
dirmngr/dirmngr.c, dirmngr/dirmngr_ldap.c, dirmngr/ldap-wrapper-ce.c,
dirmngr/ldap-wrapper.c, dirmngr/ldap.c, g13/Makefile.am,
g13/call-gpg.c, g13/g13.c, g13/runner.c, scd/Makefile.am,
scd/apdu.c, scd/app.c, scd/ccid-driver.c, scd/command.c,
scd/scdaemon.c, tools/Makefile.am: Port to npth.
2012-01-03 22:12:37 +01:00
|
|
|
|
npth_sleep (1);
|
2006-10-19 16:22:06 +02:00
|
|
|
|
goto retry;
|
|
|
|
|
}
|
|
|
|
|
/* Timeout - better call pinentry now the plain way. */
|
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
2007-08-28 19:48:13 +02:00
|
|
|
|
|
2015-08-24 16:14:09 +02:00
|
|
|
|
pi = gcry_calloc_secure (1, sizeof (*pi) + MAX_PASSPHRASE_LEN + 1);
|
2005-02-23 22:06:32 +01:00
|
|
|
|
if (!pi)
|
2006-09-14 18:50:33 +02:00
|
|
|
|
return gpg_error_from_syserror ();
|
2015-08-24 16:14:09 +02:00
|
|
|
|
pi->max_length = MAX_PASSPHRASE_LEN + 1;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
pi->min_digits = 0; /* we want a real passphrase */
|
2009-03-05 20:19:37 +01:00
|
|
|
|
pi->max_digits = 16;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
pi->max_tries = 3;
|
|
|
|
|
pi->check_cb = try_unprotect_cb;
|
2007-08-28 19:48:13 +02:00
|
|
|
|
arg.ctrl = ctrl;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
arg.protected_key = *keybuf;
|
|
|
|
|
arg.unprotected_key = NULL;
|
2007-08-28 19:48:13 +02:00
|
|
|
|
arg.change_required = 0;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
pi->check_cb_arg = &arg;
|
|
|
|
|
|
2015-04-14 18:41:05 +02:00
|
|
|
|
rc = agent_askpin (ctrl, desc_text, NULL, NULL, pi, hexgrip, cache_mode);
|
2019-01-28 04:58:13 +01:00
|
|
|
|
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
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
2023-03-14 10:09:41 +01:00
|
|
|
|
log_assert (arg.unprotected_key);
|
2007-08-28 19:48:13 +02:00
|
|
|
|
if (arg.change_required)
|
|
|
|
|
{
|
2015-05-08 08:55:57 +02:00
|
|
|
|
/* The callback told as that the user should change their
|
|
|
|
|
passphrase. Present the dialog to do. */
|
2007-08-28 19:48:13 +02:00
|
|
|
|
size_t canlen, erroff;
|
|
|
|
|
gcry_sexp_t s_skey;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2023-03-14 10:09:41 +01:00
|
|
|
|
log_assert (arg.unprotected_key);
|
2007-08-28 19:48:13 +02:00
|
|
|
|
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;
|
|
|
|
|
}
|
2010-10-26 11:10:29 +02:00
|
|
|
|
rc = agent_protect_and_store (ctrl, s_skey, NULL);
|
2007-08-28 19:48:13 +02:00
|
|
|
|
gcry_sexp_release (s_skey);
|
|
|
|
|
if (rc)
|
|
|
|
|
{
|
2011-02-04 12:57:53 +01:00
|
|
|
|
log_error ("changing the passphrase failed: %s\n",
|
2007-08-28 19:48:13 +02:00
|
|
|
|
gpg_strerror (rc));
|
|
|
|
|
wipememory (arg.unprotected_key, canlen);
|
|
|
|
|
xfree (arg.unprotected_key);
|
|
|
|
|
xfree (pi);
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-10-01 22:33:53 +02:00
|
|
|
|
else
|
|
|
|
|
{
|
2015-05-08 08:55:57 +02:00
|
|
|
|
/* Passphrase is fine. */
|
2018-03-27 08:40:58 +02:00
|
|
|
|
agent_put_cache (ctrl, hexgrip, cache_mode, pi->pin,
|
2010-10-01 22:33:53 +02:00
|
|
|
|
lookup_ttl? lookup_ttl (hexgrip) : 0);
|
2014-09-17 15:12:08 +02:00
|
|
|
|
agent_store_cache_hit (hexgrip);
|
2010-10-01 22:33:53 +02:00
|
|
|
|
if (r_passphrase && *pi->pin)
|
|
|
|
|
*r_passphrase = xtrystrdup (pi->pin);
|
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
xfree (*keybuf);
|
|
|
|
|
*keybuf = arg.unprotected_key;
|
|
|
|
|
}
|
|
|
|
|
xfree (pi);
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-02-23 22:06:32 +01:00
|
|
|
|
/* Read the key identified by GRIP from the private key directory and
|
2022-08-15 12:49:56 +02:00
|
|
|
|
* return it as an gcrypt S-expression object in RESULT. If R_KEYMETA
|
2023-03-14 10:09:41 +01:00
|
|
|
|
* is not NULL, the meta data items are stored there. However the
|
2023-11-21 12:13:50 +01:00
|
|
|
|
* "Key:" item is removed. If R_ORIG_KEY_VALUE is non-NULL and the
|
|
|
|
|
* Key items was removed, its value is stored at that R_ORIG_KEY_VALUE
|
|
|
|
|
* and the caller must free it. Returns an error code and stores NULL
|
|
|
|
|
* at RESULT. */
|
2005-02-23 22:06:32 +01:00
|
|
|
|
static gpg_error_t
|
2023-11-21 12:13:50 +01:00
|
|
|
|
read_key_file (const unsigned char *grip, gcry_sexp_t *result, nvc_t *r_keymeta,
|
|
|
|
|
char **r_orig_key_value)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
2017-07-28 10:37:33 +02:00
|
|
|
|
gpg_error_t err;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
char *fname;
|
2023-03-14 10:09:41 +01:00
|
|
|
|
estream_t fp = NULL;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
struct stat st;
|
2023-03-14 10:09:41 +01:00
|
|
|
|
unsigned char *buf = NULL;
|
2005-02-23 22:06:32 +01:00
|
|
|
|
size_t buflen, erroff;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
gcry_sexp_t s_skey;
|
2016-04-08 19:21:12 +02:00
|
|
|
|
char first;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2004-01-16 18:39:58 +01:00
|
|
|
|
*result = NULL;
|
2022-08-15 12:49:56 +02:00
|
|
|
|
if (r_keymeta)
|
|
|
|
|
*r_keymeta = NULL;
|
2023-11-21 12:13:50 +01:00
|
|
|
|
if (r_orig_key_value)
|
|
|
|
|
*r_orig_key_value = NULL;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2023-03-14 10:09:41 +01:00
|
|
|
|
fname = fname_from_keygrip (grip, 0);
|
|
|
|
|
if (!fname)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
fp = es_fopen (fname, "rb");
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (!fp)
|
|
|
|
|
{
|
2017-07-28 10:37:33 +02:00
|
|
|
|
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));
|
2023-03-14 10:09:41 +01:00
|
|
|
|
goto leave;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2016-04-08 19:21:12 +02:00
|
|
|
|
if (es_fread (&first, 1, 1, fp) != 1)
|
|
|
|
|
{
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = gpg_error_from_syserror ();
|
2016-04-08 19:21:12 +02:00
|
|
|
|
log_error ("error reading first byte from '%s': %s\n",
|
2017-07-28 10:37:33 +02:00
|
|
|
|
fname, gpg_strerror (err));
|
2023-03-14 10:09:41 +01:00
|
|
|
|
goto leave;
|
2016-04-08 19:21:12 +02:00
|
|
|
|
}
|
|
|
|
|
|
2017-07-28 10:37:33 +02:00
|
|
|
|
if (es_fseek (fp, 0, SEEK_SET))
|
2016-04-08 19:21:12 +02:00
|
|
|
|
{
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
log_error ("error seeking in '%s': %s\n", fname, gpg_strerror (err));
|
2023-03-14 10:09:41 +01:00
|
|
|
|
goto leave;
|
2016-04-08 19:21:12 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (first != '(')
|
|
|
|
|
{
|
|
|
|
|
/* Key is in extended format. */
|
2016-06-23 12:12:50 +02:00
|
|
|
|
nvc_t pk;
|
2016-04-08 19:21:12 +02:00
|
|
|
|
int line;
|
|
|
|
|
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = nvc_parse_private_key (&pk, &line, fp);
|
|
|
|
|
if (err)
|
2016-04-08 19:21:12 +02:00
|
|
|
|
log_error ("error parsing '%s' line %d: %s\n",
|
2017-07-28 10:37:33 +02:00
|
|
|
|
fname, line, gpg_strerror (err));
|
2016-04-08 19:21:12 +02:00
|
|
|
|
else
|
|
|
|
|
{
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = nvc_get_private_key (pk, result);
|
|
|
|
|
if (err)
|
2016-04-08 19:21:12 +02:00
|
|
|
|
log_error ("error getting private key from '%s': %s\n",
|
2017-07-28 10:37:33 +02:00
|
|
|
|
fname, gpg_strerror (err));
|
2022-08-15 12:49:56 +02:00
|
|
|
|
else
|
2023-11-21 12:13:50 +01:00
|
|
|
|
{
|
|
|
|
|
if (r_orig_key_value)
|
|
|
|
|
{
|
|
|
|
|
const char *s = nvc_get_string (pk, "Key:");
|
|
|
|
|
if (s)
|
|
|
|
|
{
|
|
|
|
|
*r_orig_key_value = xtrystrdup (s);
|
|
|
|
|
if (!*r_orig_key_value)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
nvc_release (pk);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
nvc_delete_named (pk, "Key:");
|
|
|
|
|
}
|
2016-04-08 19:21:12 +02:00
|
|
|
|
}
|
|
|
|
|
|
2022-08-15 12:49:56 +02:00
|
|
|
|
if (!err && r_keymeta)
|
|
|
|
|
*r_keymeta = pk;
|
|
|
|
|
else
|
|
|
|
|
nvc_release (pk);
|
2023-03-14 10:09:41 +01:00
|
|
|
|
goto leave;
|
2016-04-08 19:21:12 +02:00
|
|
|
|
}
|
|
|
|
|
|
2010-04-14 13:24:02 +02:00
|
|
|
|
if (fstat (es_fileno (fp), &st))
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
log_error ("can't stat '%s': %s\n", fname, gpg_strerror (err));
|
2023-03-14 10:09:41 +01:00
|
|
|
|
goto leave;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
buflen = st.st_size;
|
2005-02-23 22:06:32 +01:00
|
|
|
|
buf = xtrymalloc (buflen+1);
|
2010-04-14 13:24:02 +02:00
|
|
|
|
if (!buf)
|
|
|
|
|
{
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = gpg_error_from_syserror ();
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_error ("error allocating %zu bytes for '%s': %s\n",
|
2017-07-28 10:37:33 +02:00
|
|
|
|
buflen, fname, gpg_strerror (err));
|
2023-03-14 10:09:41 +01:00
|
|
|
|
goto leave;
|
2010-04-14 13:24:02 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (es_fread (buf, buflen, 1, fp) != 1)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = gpg_error_from_syserror ();
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_error ("error reading %zu bytes from '%s': %s\n",
|
2017-07-28 10:37:33 +02:00
|
|
|
|
buflen, fname, gpg_strerror (err));
|
2023-03-14 10:09:41 +01:00
|
|
|
|
goto leave;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
2005-02-23 22:06:32 +01:00
|
|
|
|
/* Convert the file into a gcrypt S-expression object. */
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = gcry_sexp_sscan (&s_skey, &erroff, (char*)buf, buflen);
|
|
|
|
|
if (err)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
|
|
|
|
log_error ("failed to build S-Exp (off=%u): %s\n",
|
2017-07-28 10:37:33 +02:00
|
|
|
|
(unsigned int)erroff, gpg_strerror (err));
|
2023-03-14 10:09:41 +01:00
|
|
|
|
goto leave;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
2005-02-23 22:06:32 +01:00
|
|
|
|
*result = s_skey;
|
2023-03-14 10:09:41 +01:00
|
|
|
|
|
|
|
|
|
leave:
|
|
|
|
|
es_fclose (fp);
|
|
|
|
|
xfree (fname);
|
|
|
|
|
xfree (buf);
|
|
|
|
|
return err;
|
2005-02-23 22:06:32 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2014-04-15 16:40:48 +02:00
|
|
|
|
/* 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");
|
2016-06-07 10:59:46 +02:00
|
|
|
|
fname = make_filename (gnupg_homedir (), GNUPG_PRIVATE_KEYS_DIR,
|
|
|
|
|
hexgrip, NULL);
|
2014-04-15 16:40:48 +02:00
|
|
|
|
if (gnupg_remove (fname))
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
xfree (fname);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-02-23 22:06:32 +01:00
|
|
|
|
/* Return the secret key as an S-Exp in RESULT after locating it using
|
2014-03-04 03:54:59 +01:00
|
|
|
|
the GRIP. 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.
|
2009-03-06 18:31:27 +01:00
|
|
|
|
CACHE_MODE defines now the cache shall be used. DESC_TEXT may be
|
2009-05-15 13:16:28 +02:00
|
|
|
|
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
|
2010-09-01 13:07:16 +02:00
|
|
|
|
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
|
2010-10-01 22:33:53 +02:00
|
|
|
|
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. */
|
2005-02-23 22:06:32 +01:00
|
|
|
|
gpg_error_t
|
2010-09-01 13:07:16 +02:00
|
|
|
|
agent_key_from_file (ctrl_t ctrl, const char *cache_nonce,
|
|
|
|
|
const char *desc_text,
|
2005-02-23 22:06:32 +01:00
|
|
|
|
const unsigned char *grip, unsigned char **shadow_info,
|
2009-05-15 13:16:28 +02:00
|
|
|
|
cache_mode_t cache_mode, lookup_ttl_t lookup_ttl,
|
2023-10-27 12:19:50 +02:00
|
|
|
|
gcry_sexp_t *result, char **r_passphrase,
|
|
|
|
|
uint64_t *r_timestamp)
|
2005-02-23 22:06:32 +01:00
|
|
|
|
{
|
2017-07-28 10:37:33 +02:00
|
|
|
|
gpg_error_t err;
|
2005-02-23 22:06:32 +01:00
|
|
|
|
unsigned char *buf;
|
|
|
|
|
size_t len, buflen, erroff;
|
|
|
|
|
gcry_sexp_t s_skey;
|
2023-10-27 12:19:50 +02:00
|
|
|
|
nvc_t keymeta = NULL;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2005-02-23 22:06:32 +01:00
|
|
|
|
*result = NULL;
|
|
|
|
|
if (shadow_info)
|
2009-05-15 13:16:28 +02:00
|
|
|
|
*shadow_info = NULL;
|
2010-10-01 22:33:53 +02:00
|
|
|
|
if (r_passphrase)
|
|
|
|
|
*r_passphrase = NULL;
|
2023-10-27 12:19:50 +02:00
|
|
|
|
if (r_timestamp)
|
|
|
|
|
*r_timestamp = (uint64_t)(-1);
|
2005-02-23 22:06:32 +01:00
|
|
|
|
|
2023-11-21 12:13:50 +01:00
|
|
|
|
err = read_key_file (grip, &s_skey, &keymeta, NULL);
|
2017-07-28 10:37:33 +02:00
|
|
|
|
if (err)
|
2014-08-18 15:42:54 +02:00
|
|
|
|
{
|
2017-07-28 10:37:33 +02:00
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_ENOENT)
|
|
|
|
|
err = gpg_error (GPG_ERR_NO_SECKEY);
|
|
|
|
|
return err;
|
2014-08-18 15:42:54 +02:00
|
|
|
|
}
|
2005-02-23 22:06:32 +01:00
|
|
|
|
|
|
|
|
|
/* For use with the protection functions we also need the key as an
|
2009-03-06 18:31:27 +01:00
|
|
|
|
canonical encoded S-expression in a buffer. Create this buffer
|
2005-02-23 22:06:32 +01:00
|
|
|
|
now. */
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = make_canon_sexp (s_skey, &buf, &len);
|
|
|
|
|
if (err)
|
2023-10-27 12:19:50 +02:00
|
|
|
|
{
|
|
|
|
|
nvc_release (keymeta);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (r_timestamp && keymeta)
|
|
|
|
|
{
|
|
|
|
|
const char *created = nvc_get_string (keymeta, "Created:");
|
|
|
|
|
|
|
|
|
|
if (created)
|
|
|
|
|
*r_timestamp = isotime2epoch_u64 (created);
|
|
|
|
|
}
|
|
|
|
|
nvc_release (keymeta);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
switch (agent_private_key_type (buf))
|
|
|
|
|
{
|
|
|
|
|
case PRIVATE_KEY_CLEAR:
|
|
|
|
|
break; /* no unprotection needed */
|
2015-01-29 16:26:07 +01:00
|
|
|
|
case PRIVATE_KEY_OPENPGP_NONE:
|
|
|
|
|
{
|
|
|
|
|
unsigned char *buf_new;
|
|
|
|
|
size_t buf_newlen;
|
|
|
|
|
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = agent_unprotect (ctrl, buf, "", NULL, &buf_new, &buf_newlen);
|
|
|
|
|
if (err)
|
2015-01-29 16:26:07 +01:00
|
|
|
|
log_error ("failed to convert unprotected openpgp key: %s\n",
|
2017-07-28 10:37:33 +02:00
|
|
|
|
gpg_strerror (err));
|
2015-01-29 16:26:07 +01:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
xfree (buf);
|
|
|
|
|
buf = buf_new;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
case PRIVATE_KEY_PROTECTED:
|
2005-01-26 23:20:21 +01:00
|
|
|
|
{
|
|
|
|
|
char *desc_text_final;
|
2011-07-20 20:49:41 +02:00
|
|
|
|
char *comment = NULL;
|
2005-02-03 18:40:02 +01:00
|
|
|
|
|
2005-02-23 22:06:32 +01:00
|
|
|
|
/* Note, that we will take the comment as a C string for
|
2005-02-03 18:40:02 +01:00
|
|
|
|
display purposes; i.e. all stuff beyond a Nul character is
|
|
|
|
|
ignored. */
|
2011-07-20 20:49:41 +02:00
|
|
|
|
{
|
|
|
|
|
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);
|
|
|
|
|
}
|
2005-01-26 23:20:21 +01:00
|
|
|
|
|
2005-02-03 18:40:02 +01:00
|
|
|
|
desc_text_final = NULL;
|
2005-01-26 23:20:21 +01:00
|
|
|
|
if (desc_text)
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = agent_modify_description (desc_text, comment, s_skey,
|
|
|
|
|
&desc_text_final);
|
2011-07-20 20:49:41 +02:00
|
|
|
|
gcry_free (comment);
|
2005-01-26 23:20:21 +01:00
|
|
|
|
|
2017-07-28 10:37:33 +02:00
|
|
|
|
if (!err)
|
2005-01-26 23:20:21 +01:00
|
|
|
|
{
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = unprotect (ctrl, cache_nonce, desc_text_final, &buf, grip,
|
2010-10-01 22:33:53 +02:00
|
|
|
|
cache_mode, lookup_ttl, r_passphrase);
|
2017-07-28 10:37:33 +02:00
|
|
|
|
if (err)
|
2005-01-26 23:20:21 +01:00
|
|
|
|
log_error ("failed to unprotect the secret key: %s\n",
|
2017-07-28 10:37:33 +02:00
|
|
|
|
gpg_strerror (err));
|
2005-01-26 23:20:21 +01:00
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2005-01-26 23:20:21 +01:00
|
|
|
|
xfree (desc_text_final);
|
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
break;
|
|
|
|
|
case PRIVATE_KEY_SHADOWED:
|
|
|
|
|
if (shadow_info)
|
|
|
|
|
{
|
|
|
|
|
const unsigned char *s;
|
|
|
|
|
size_t n;
|
|
|
|
|
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = agent_get_shadow_info (buf, &s);
|
|
|
|
|
if (!err)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
|
|
|
|
n = gcry_sexp_canon_len (s, 0, NULL,NULL);
|
2017-07-28 10:37:33 +02:00
|
|
|
|
log_assert (n);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
*shadow_info = xtrymalloc (n);
|
|
|
|
|
if (!*shadow_info)
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = out_of_core ();
|
2003-08-05 19:11:04 +02:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
memcpy (*shadow_info, s, n);
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = 0;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
2017-07-28 10:37:33 +02:00
|
|
|
|
if (err)
|
|
|
|
|
log_error ("get_shadow_info failed: %s\n", gpg_strerror (err));
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
2004-01-16 18:39:58 +01:00
|
|
|
|
else
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = gpg_error (GPG_ERR_UNUSABLE_SECKEY);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
log_error ("invalid private key format\n");
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = gpg_error (GPG_ERR_BAD_SECKEY);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
break;
|
|
|
|
|
}
|
2005-02-23 22:06:32 +01:00
|
|
|
|
gcry_sexp_release (s_skey);
|
|
|
|
|
s_skey = NULL;
|
2017-07-28 10:37:33 +02:00
|
|
|
|
if (err)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
|
|
|
|
xfree (buf);
|
2010-10-01 22:33:53 +02:00
|
|
|
|
if (r_passphrase)
|
|
|
|
|
{
|
|
|
|
|
xfree (*r_passphrase);
|
|
|
|
|
*r_passphrase = NULL;
|
|
|
|
|
}
|
2017-07-28 10:37:33 +02:00
|
|
|
|
return err;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
2004-02-03 17:24:37 +01:00
|
|
|
|
buflen = gcry_sexp_canon_len (buf, 0, NULL, NULL);
|
2017-07-28 10:37:33 +02:00
|
|
|
|
err = gcry_sexp_sscan (&s_skey, &erroff, (char*)buf, buflen);
|
2004-02-03 17:24:37 +01:00
|
|
|
|
wipememory (buf, buflen);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
xfree (buf);
|
2017-07-28 10:37:33 +02:00
|
|
|
|
if (err)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
|
|
|
|
log_error ("failed to build S-Exp (off=%u): %s\n",
|
2017-07-28 10:37:33 +02:00
|
|
|
|
(unsigned int)erroff, gpg_strerror (err));
|
2010-10-01 22:33:53 +02:00
|
|
|
|
if (r_passphrase)
|
|
|
|
|
{
|
|
|
|
|
xfree (*r_passphrase);
|
|
|
|
|
*r_passphrase = NULL;
|
|
|
|
|
}
|
2017-07-28 10:37:33 +02:00
|
|
|
|
return err;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
2004-01-16 18:39:58 +01:00
|
|
|
|
*result = s_skey;
|
|
|
|
|
return 0;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
2005-02-23 22:06:32 +01:00
|
|
|
|
|
2010-04-21 18:26:17 +02:00
|
|
|
|
/* Return the string name from the S-expression S_KEY as well as a
|
|
|
|
|
string describing the names of the parameters. ALGONAMESIZE and
|
|
|
|
|
ELEMSSIZE give the allocated size of the provided buffers. The
|
|
|
|
|
buffers may be NULL if not required. If R_LIST is not NULL the top
|
2014-03-22 20:51:16 +01:00
|
|
|
|
level list will be stored there; the caller needs to release it in
|
2010-04-21 18:26:17 +02:00
|
|
|
|
this case. */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
key_parms_from_sexp (gcry_sexp_t s_key, gcry_sexp_t *r_list,
|
|
|
|
|
char *r_algoname, size_t algonamesize,
|
|
|
|
|
char *r_elems, size_t elemssize)
|
2005-02-23 22:06:32 +01:00
|
|
|
|
{
|
|
|
|
|
gcry_sexp_t list, l2;
|
2010-04-21 18:26:17 +02:00
|
|
|
|
const char *name, *algoname, *elems;
|
2005-02-23 22:06:32 +01:00
|
|
|
|
size_t n;
|
2008-10-20 15:53:23 +02:00
|
|
|
|
|
2010-04-21 18:26:17 +02:00
|
|
|
|
if (r_list)
|
|
|
|
|
*r_list = NULL;
|
2005-02-23 22:06:32 +01:00
|
|
|
|
|
2010-04-21 18:26:17 +02:00
|
|
|
|
list = gcry_sexp_find_token (s_key, "shadowed-private-key", 0 );
|
2005-02-23 22:06:32 +01:00
|
|
|
|
if (!list)
|
2010-04-21 18:26:17 +02:00
|
|
|
|
list = gcry_sexp_find_token (s_key, "protected-private-key", 0 );
|
2005-02-23 22:06:32 +01:00
|
|
|
|
if (!list)
|
2010-04-21 18:26:17 +02:00
|
|
|
|
list = gcry_sexp_find_token (s_key, "private-key", 0 );
|
2005-02-23 22:06:32 +01:00
|
|
|
|
if (!list)
|
|
|
|
|
{
|
|
|
|
|
log_error ("invalid private key format\n");
|
|
|
|
|
return gpg_error (GPG_ERR_BAD_SECKEY);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
l2 = gcry_sexp_cadr (list);
|
|
|
|
|
gcry_sexp_release (list);
|
|
|
|
|
list = l2;
|
|
|
|
|
name = gcry_sexp_nth_data (list, 0, &n);
|
|
|
|
|
if (n==3 && !memcmp (name, "rsa", 3))
|
|
|
|
|
{
|
|
|
|
|
algoname = "rsa";
|
|
|
|
|
elems = "ne";
|
|
|
|
|
}
|
|
|
|
|
else if (n==3 && !memcmp (name, "dsa", 3))
|
|
|
|
|
{
|
|
|
|
|
algoname = "dsa";
|
|
|
|
|
elems = "pqgy";
|
|
|
|
|
}
|
2013-11-15 08:59:45 +01:00
|
|
|
|
else if (n==3 && !memcmp (name, "ecc", 3))
|
|
|
|
|
{
|
|
|
|
|
algoname = "ecc";
|
|
|
|
|
elems = "pabgnq";
|
|
|
|
|
}
|
2011-01-06 02:33:17 +01:00
|
|
|
|
else if (n==5 && !memcmp (name, "ecdsa", 5))
|
|
|
|
|
{
|
|
|
|
|
algoname = "ecdsa";
|
2011-01-31 15:44:24 +01:00
|
|
|
|
elems = "pabgnq";
|
2011-01-06 02:33:17 +01:00
|
|
|
|
}
|
|
|
|
|
else if (n==4 && !memcmp (name, "ecdh", 4))
|
|
|
|
|
{
|
|
|
|
|
algoname = "ecdh";
|
2011-01-31 15:44:24 +01:00
|
|
|
|
elems = "pabgnq";
|
2011-01-06 02:33:17 +01:00
|
|
|
|
}
|
2005-02-23 22:06:32 +01:00
|
|
|
|
else if (n==3 && !memcmp (name, "elg", 3))
|
|
|
|
|
{
|
|
|
|
|
algoname = "elg";
|
|
|
|
|
elems = "pgy";
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
log_error ("unknown private key algorithm\n");
|
|
|
|
|
gcry_sexp_release (list);
|
|
|
|
|
return gpg_error (GPG_ERR_BAD_SECKEY);
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-21 18:26:17 +02:00
|
|
|
|
if (r_algoname)
|
|
|
|
|
{
|
|
|
|
|
if (strlen (algoname) >= algonamesize)
|
|
|
|
|
return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
|
|
|
|
|
strcpy (r_algoname, algoname);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
}
|
2010-04-21 18:26:17 +02:00
|
|
|
|
if (r_elems)
|
|
|
|
|
{
|
|
|
|
|
if (strlen (elems) >= elemssize)
|
|
|
|
|
return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
|
|
|
|
|
strcpy (r_elems, elems);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (r_list)
|
|
|
|
|
*r_list = list;
|
|
|
|
|
else
|
|
|
|
|
gcry_sexp_release (list);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2010-04-21 18:26:17 +02:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2014-03-22 20:51:16 +01:00
|
|
|
|
/* Return true if KEYPARMS holds an EdDSA key. */
|
|
|
|
|
static int
|
|
|
|
|
is_eddsa (gcry_sexp_t keyparms)
|
|
|
|
|
{
|
|
|
|
|
int result = 0;
|
|
|
|
|
gcry_sexp_t list;
|
|
|
|
|
const char *s;
|
|
|
|
|
size_t n;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
list = gcry_sexp_find_token (keyparms, "flags", 0);
|
|
|
|
|
for (i = list ? gcry_sexp_length (list)-1 : 0; i > 0; i--)
|
|
|
|
|
{
|
|
|
|
|
s = gcry_sexp_nth_data (list, i, &n);
|
|
|
|
|
if (!s)
|
|
|
|
|
continue; /* Not a data element. */
|
|
|
|
|
|
|
|
|
|
if (n == 5 && !memcmp (s, "eddsa", 5))
|
|
|
|
|
{
|
|
|
|
|
result = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
gcry_sexp_release (list);
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-08-31 17:58:39 +02:00
|
|
|
|
/* Return the public key algorithm number if S_KEY is a DSA style key.
|
|
|
|
|
If it is not a DSA style key, return 0. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
int
|
2010-04-21 18:26:17 +02:00
|
|
|
|
agent_is_dsa_key (gcry_sexp_t s_key)
|
|
|
|
|
{
|
2014-03-22 20:51:16 +01:00
|
|
|
|
int result;
|
|
|
|
|
gcry_sexp_t list;
|
2010-04-21 18:26:17 +02:00
|
|
|
|
char algoname[6];
|
|
|
|
|
|
|
|
|
|
if (!s_key)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2014-03-22 20:51:16 +01:00
|
|
|
|
if (key_parms_from_sexp (s_key, &list, algoname, sizeof algoname, NULL, 0))
|
2010-04-21 18:26:17 +02:00
|
|
|
|
return 0; /* Error - assume it is not an DSA key. */
|
|
|
|
|
|
2010-08-31 17:58:39 +02:00
|
|
|
|
if (!strcmp (algoname, "dsa"))
|
2014-03-22 20:51:16 +01:00
|
|
|
|
result = GCRY_PK_DSA;
|
2013-11-15 08:59:45 +01:00
|
|
|
|
else if (!strcmp (algoname, "ecc"))
|
2014-03-22 20:51:16 +01:00
|
|
|
|
{
|
|
|
|
|
if (is_eddsa (list))
|
|
|
|
|
result = 0;
|
|
|
|
|
else
|
|
|
|
|
result = GCRY_PK_ECDSA;
|
|
|
|
|
}
|
2010-08-31 17:58:39 +02:00
|
|
|
|
else if (!strcmp (algoname, "ecdsa"))
|
2014-03-22 20:51:16 +01:00
|
|
|
|
result = GCRY_PK_ECDSA;
|
2010-08-31 17:58:39 +02:00
|
|
|
|
else
|
2014-03-22 20:51:16 +01:00
|
|
|
|
result = 0;
|
|
|
|
|
|
|
|
|
|
gcry_sexp_release (list);
|
|
|
|
|
return result;
|
2010-04-21 18:26:17 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-11-15 08:59:45 +01:00
|
|
|
|
/* Return true if S_KEY is an EdDSA key as used with curve Ed25519. */
|
|
|
|
|
int
|
|
|
|
|
agent_is_eddsa_key (gcry_sexp_t s_key)
|
|
|
|
|
{
|
2014-03-22 20:51:16 +01:00
|
|
|
|
int result;
|
|
|
|
|
gcry_sexp_t list;
|
2013-11-15 08:59:45 +01:00
|
|
|
|
char algoname[6];
|
|
|
|
|
|
|
|
|
|
if (!s_key)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2014-03-22 20:51:16 +01:00
|
|
|
|
if (key_parms_from_sexp (s_key, &list, algoname, sizeof algoname, NULL, 0))
|
2014-01-16 01:07:11 +01:00
|
|
|
|
return 0; /* Error - assume it is not an EdDSA key. */
|
2013-11-15 08:59:45 +01:00
|
|
|
|
|
2014-03-22 20:51:16 +01:00
|
|
|
|
if (!strcmp (algoname, "ecc") && is_eddsa (list))
|
|
|
|
|
result = 1;
|
|
|
|
|
else if (!strcmp (algoname, "eddsa")) /* backward compatibility. */
|
|
|
|
|
result = 1;
|
2013-11-15 08:59:45 +01:00
|
|
|
|
else
|
2014-03-22 20:51:16 +01:00
|
|
|
|
result = 0;
|
|
|
|
|
|
|
|
|
|
gcry_sexp_release (list);
|
|
|
|
|
return result;
|
2013-11-15 08:59:45 +01:00
|
|
|
|
}
|
|
|
|
|
|
2010-04-21 18:26:17 +02:00
|
|
|
|
|
2023-03-14 10:09:41 +01:00
|
|
|
|
/* This function returns GPG_ERR_TRUE if S_SKEY represents a shadowed
|
|
|
|
|
* key. 0 is return for other key types. Any other error may occur
|
|
|
|
|
* if S_SKEY is not valid. */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
is_shadowed_key (gcry_sexp_t s_skey)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
unsigned char *buf;
|
|
|
|
|
size_t buflen;
|
|
|
|
|
|
|
|
|
|
err = make_canon_sexp (s_skey, &buf, &buflen);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
if (agent_private_key_type (buf) == PRIVATE_KEY_SHADOWED)
|
|
|
|
|
err = gpg_error (GPG_ERR_TRUE);
|
|
|
|
|
|
|
|
|
|
wipememory (buf, buflen);
|
|
|
|
|
xfree (buf);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2011-07-20 20:49:41 +02:00
|
|
|
|
/* 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;
|
|
|
|
|
|
2023-11-21 12:13:50 +01:00
|
|
|
|
err = read_key_file (grip, &s_skey, NULL, NULL);
|
2011-07-20 20:49:41 +02:00
|
|
|
|
if (!err)
|
|
|
|
|
*result = s_skey;
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-08-15 12:49:56 +02:00
|
|
|
|
gpg_error_t
|
|
|
|
|
agent_keymeta_from_file (ctrl_t ctrl, const unsigned char *grip,
|
|
|
|
|
nvc_t *r_keymeta)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
gcry_sexp_t s_skey;
|
|
|
|
|
|
|
|
|
|
(void)ctrl;
|
|
|
|
|
|
2023-11-21 12:13:50 +01:00
|
|
|
|
err = read_key_file (grip, &s_skey, r_keymeta, NULL);
|
2022-08-15 12:49:56 +02:00
|
|
|
|
gcry_sexp_release (s_skey);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-21 18:26:17 +02:00
|
|
|
|
/* 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
|
2011-02-04 12:57:53 +01:00
|
|
|
|
agent_public_key_from_file (ctrl_t ctrl,
|
2010-04-21 18:26:17 +02:00
|
|
|
|
const unsigned char *grip,
|
|
|
|
|
gcry_sexp_t *result)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
int i, idx;
|
|
|
|
|
gcry_sexp_t s_skey;
|
2015-01-27 01:30:11 +01:00
|
|
|
|
const char *algoname, *elems;
|
|
|
|
|
int npkey;
|
|
|
|
|
gcry_mpi_t array[10];
|
|
|
|
|
gcry_sexp_t curve = NULL;
|
|
|
|
|
gcry_sexp_t flags = NULL;
|
2010-04-21 18:26:17 +02:00
|
|
|
|
gcry_sexp_t uri_sexp, comment_sexp;
|
|
|
|
|
const char *uri, *comment;
|
|
|
|
|
size_t uri_length, comment_length;
|
2019-05-14 06:05:42 +02:00
|
|
|
|
int uri_intlen, comment_intlen;
|
2010-04-21 18:26:17 +02:00
|
|
|
|
char *format, *p;
|
2015-01-27 01:30:11 +01:00
|
|
|
|
void *args[2+7+2+2+1]; /* Size is 2 + max. # of elements + 2 for uri + 2
|
|
|
|
|
for comment + end-of-list. */
|
2010-04-21 18:26:17 +02:00
|
|
|
|
int argidx;
|
2015-01-27 01:30:11 +01:00
|
|
|
|
gcry_sexp_t list = NULL;
|
2010-04-21 18:26:17 +02:00
|
|
|
|
const char *s;
|
|
|
|
|
|
|
|
|
|
(void)ctrl;
|
|
|
|
|
|
|
|
|
|
*result = NULL;
|
|
|
|
|
|
2023-11-21 12:13:50 +01:00
|
|
|
|
err = read_key_file (grip, &s_skey, NULL, NULL);
|
2010-04-21 18:26:17 +02:00
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
2015-01-27 01:30:11 +01:00
|
|
|
|
for (i=0; i < DIM (array); i++)
|
|
|
|
|
array[i] = NULL;
|
2010-04-21 18:26:17 +02:00
|
|
|
|
|
2015-01-27 01:30:11 +01:00
|
|
|
|
err = extract_private_key (s_skey, 0, &algoname, &npkey, NULL, &elems,
|
2015-01-27 10:22:47 +01:00
|
|
|
|
array, DIM (array), &curve, &flags);
|
2015-01-27 01:30:11 +01:00
|
|
|
|
if (err)
|
2005-02-23 22:06:32 +01:00
|
|
|
|
{
|
|
|
|
|
gcry_sexp_release (s_skey);
|
2010-04-21 18:26:17 +02:00
|
|
|
|
return err;
|
2005-02-23 22:06:32 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* FIXME: The following thing is pretty ugly code; we should
|
2010-04-21 18:26:17 +02:00
|
|
|
|
investigate how to make it cleaner. Probably code to handle
|
|
|
|
|
canonical S-expressions in a memory buffer is better suited for
|
2017-04-28 03:06:33 +02:00
|
|
|
|
such a task. After all that is what we do in protect.c. Need
|
2005-02-23 22:06:32 +01:00
|
|
|
|
to find common patterns and write a straightformward API to use
|
|
|
|
|
them. */
|
2023-03-14 10:09:41 +01:00
|
|
|
|
log_assert (sizeof (size_t) <= sizeof (void*));
|
2005-02-23 22:06:32 +01:00
|
|
|
|
|
2015-01-27 01:30:11 +01:00
|
|
|
|
format = xtrymalloc (15+4+7*npkey+10+15+1+1);
|
2005-02-23 22:06:32 +01:00
|
|
|
|
if (!format)
|
|
|
|
|
{
|
2010-04-21 18:26:17 +02:00
|
|
|
|
err = gpg_error_from_syserror ();
|
2005-02-23 22:06:32 +01:00
|
|
|
|
for (i=0; array[i]; i++)
|
|
|
|
|
gcry_mpi_release (array[i]);
|
2015-01-27 01:30:11 +01:00
|
|
|
|
gcry_sexp_release (curve);
|
|
|
|
|
gcry_sexp_release (flags);
|
2005-02-23 22:06:32 +01:00
|
|
|
|
gcry_sexp_release (uri_sexp);
|
|
|
|
|
gcry_sexp_release (comment_sexp);
|
2010-04-21 18:26:17 +02:00
|
|
|
|
return err;
|
2005-02-23 22:06:32 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
argidx = 0;
|
|
|
|
|
p = stpcpy (stpcpy (format, "(public-key("), algoname);
|
2015-01-27 01:30:11 +01:00
|
|
|
|
p = stpcpy (p, "%S%S"); /* curve name and flags. */
|
|
|
|
|
args[argidx++] = &curve;
|
|
|
|
|
args[argidx++] = &flags;
|
|
|
|
|
for (idx=0, s=elems; idx < npkey; idx++)
|
2005-02-23 22:06:32 +01:00
|
|
|
|
{
|
|
|
|
|
*p++ = '(';
|
2015-01-27 01:30:11 +01:00
|
|
|
|
*p++ = *s++;
|
2005-02-23 22:06:32 +01:00
|
|
|
|
p = stpcpy (p, " %m)");
|
2023-03-14 10:09:41 +01:00
|
|
|
|
log_assert (argidx < DIM (args));
|
2005-07-25 16:35:04 +02:00
|
|
|
|
args[argidx++] = &array[idx];
|
2005-02-23 22:06:32 +01:00
|
|
|
|
}
|
|
|
|
|
*p++ = ')';
|
|
|
|
|
if (uri)
|
|
|
|
|
{
|
|
|
|
|
p = stpcpy (p, "(uri %b)");
|
2023-03-14 10:09:41 +01:00
|
|
|
|
log_assert (argidx+1 < DIM (args));
|
2019-05-14 06:05:42 +02:00
|
|
|
|
uri_intlen = (int)uri_length;
|
|
|
|
|
args[argidx++] = (void *)&uri_intlen;
|
2012-10-31 08:09:06 +01:00
|
|
|
|
args[argidx++] = (void *)&uri;
|
2005-02-23 22:06:32 +01:00
|
|
|
|
}
|
|
|
|
|
if (comment)
|
|
|
|
|
{
|
|
|
|
|
p = stpcpy (p, "(comment %b)");
|
2023-03-14 10:09:41 +01:00
|
|
|
|
log_assert (argidx+1 < DIM (args));
|
2019-05-14 06:05:42 +02:00
|
|
|
|
comment_intlen = (int)comment_length;
|
|
|
|
|
args[argidx++] = (void *)&comment_intlen;
|
2012-10-31 08:09:06 +01:00
|
|
|
|
args[argidx++] = (void*)&comment;
|
2005-02-23 22:06:32 +01:00
|
|
|
|
}
|
|
|
|
|
*p++ = ')';
|
|
|
|
|
*p = 0;
|
2023-03-14 10:09:41 +01:00
|
|
|
|
log_assert (argidx < DIM (args));
|
2005-02-23 22:06:32 +01:00
|
|
|
|
args[argidx] = NULL;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2010-04-21 18:26:17 +02:00
|
|
|
|
err = gcry_sexp_build_array (&list, NULL, format, args);
|
2005-02-23 22:06:32 +01:00
|
|
|
|
xfree (format);
|
|
|
|
|
for (i=0; array[i]; i++)
|
|
|
|
|
gcry_mpi_release (array[i]);
|
2015-01-27 01:30:11 +01:00
|
|
|
|
gcry_sexp_release (curve);
|
|
|
|
|
gcry_sexp_release (flags);
|
2005-02-23 22:06:32 +01:00
|
|
|
|
gcry_sexp_release (uri_sexp);
|
|
|
|
|
gcry_sexp_release (comment_sexp);
|
|
|
|
|
|
2010-04-21 18:26:17 +02:00
|
|
|
|
if (!err)
|
2005-02-23 22:06:32 +01:00
|
|
|
|
*result = list;
|
2010-04-21 18:26:17 +02:00
|
|
|
|
return err;
|
2005-02-23 22:06:32 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2017-02-20 22:19:50 +01:00
|
|
|
|
/* Check whether the secret key identified by GRIP is available.
|
2010-06-17 17:44:44 +02:00
|
|
|
|
Returns 0 is the key is available. */
|
2003-08-05 19:11:04 +02:00
|
|
|
|
int
|
|
|
|
|
agent_key_available (const unsigned char *grip)
|
|
|
|
|
{
|
2009-03-06 18:31:27 +01:00
|
|
|
|
int result;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
char *fname;
|
|
|
|
|
char hexgrip[40+4+1];
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-03-06 18:31:27 +01:00
|
|
|
|
bin2hex (grip, 20, hexgrip);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
strcpy (hexgrip+40, ".key");
|
|
|
|
|
|
2016-06-07 10:59:46 +02:00
|
|
|
|
fname = make_filename (gnupg_homedir (), GNUPG_PRIVATE_KEYS_DIR,
|
|
|
|
|
hexgrip, NULL);
|
2020-10-20 10:43:55 +02:00
|
|
|
|
result = !gnupg_access (fname, R_OK)? 0 : -1;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
xfree (fname);
|
2009-03-06 18:31:27 +01:00
|
|
|
|
return result;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2009-03-06 18:31:27 +01:00
|
|
|
|
/* 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)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
unsigned char *buf;
|
|
|
|
|
size_t len;
|
|
|
|
|
int keytype;
|
|
|
|
|
|
|
|
|
|
(void)ctrl;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-03-06 18:31:27 +01:00
|
|
|
|
if (r_keytype)
|
|
|
|
|
*r_keytype = PRIVATE_KEY_UNKNOWN;
|
|
|
|
|
if (r_shadow_info)
|
|
|
|
|
*r_shadow_info = NULL;
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
gcry_sexp_t sexp;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2023-11-21 12:13:50 +01:00
|
|
|
|
err = read_key_file (grip, &sexp, NULL, NULL);
|
2009-03-06 18:31:27 +01:00
|
|
|
|
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;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-03-06 18:31:27 +01:00
|
|
|
|
keytype = agent_private_key_type (buf);
|
|
|
|
|
switch (keytype)
|
|
|
|
|
{
|
|
|
|
|
case PRIVATE_KEY_CLEAR:
|
2015-01-29 16:26:07 +01:00
|
|
|
|
case PRIVATE_KEY_OPENPGP_NONE:
|
2011-02-04 12:57:53 +01:00
|
|
|
|
break;
|
2009-03-06 18:31:27 +01:00
|
|
|
|
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 (buf, &s);
|
|
|
|
|
if (!err)
|
|
|
|
|
{
|
|
|
|
|
n = gcry_sexp_canon_len (s, 0, NULL, NULL);
|
2023-03-14 10:09:41 +01:00
|
|
|
|
log_assert (n);
|
2009-03-06 18:31:27 +01:00
|
|
|
|
*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;
|
|
|
|
|
}
|
2014-04-15 16:40:48 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Delete the key with GRIP from the disk after having asked for
|
2017-03-24 09:02:02 +01:00
|
|
|
|
* 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.
|
|
|
|
|
*/
|
2014-04-15 16:40:48 +02:00
|
|
|
|
gpg_error_t
|
|
|
|
|
agent_delete_key (ctrl_t ctrl, const char *desc_text,
|
2017-03-24 09:02:02 +01:00
|
|
|
|
const unsigned char *grip, int force, int only_stubs)
|
2014-04-15 16:40:48 +02:00
|
|
|
|
{
|
|
|
|
|
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;
|
2017-03-24 09:02:02 +01:00
|
|
|
|
int key_type;
|
2014-04-15 16:40:48 +02:00
|
|
|
|
|
2023-11-21 12:13:50 +01:00
|
|
|
|
err = read_key_file (grip, &s_skey, NULL, NULL);
|
2014-04-15 16:40:48 +02:00
|
|
|
|
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;
|
|
|
|
|
|
2017-03-24 09:02:02 +01:00
|
|
|
|
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)
|
2014-04-15 16:40:48 +02:00
|
|
|
|
{
|
|
|
|
|
case PRIVATE_KEY_CLEAR:
|
2015-01-29 16:26:07 +01:00
|
|
|
|
case PRIVATE_KEY_OPENPGP_NONE:
|
2014-04-15 16:40:48 +02:00
|
|
|
|
case PRIVATE_KEY_PROTECTED:
|
2015-08-07 12:55:29 +02:00
|
|
|
|
bin2hex (grip, 20, hexgrip);
|
|
|
|
|
if (!force)
|
2014-04-15 16:40:48 +02:00
|
|
|
|
{
|
2015-08-07 12:55:29 +02:00
|
|
|
|
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;
|
|
|
|
|
}
|
2014-04-15 16:40:48 +02:00
|
|
|
|
|
2015-08-07 12:55:29 +02:00
|
|
|
|
/* Note, that we will take the comment as a C string for
|
|
|
|
|
display purposes; i.e. all stuff beyond a Nul character is
|
|
|
|
|
ignored. */
|
2014-04-15 16:40:48 +02:00
|
|
|
|
{
|
2015-08-07 12:55:29 +02:00
|
|
|
|
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);
|
2014-04-15 16:40:48 +02:00
|
|
|
|
}
|
|
|
|
|
|
2015-08-07 12:55:29 +02:00
|
|
|
|
if (desc_text)
|
2017-02-22 11:04:55 +01:00
|
|
|
|
err = agent_modify_description (desc_text, comment, s_skey,
|
|
|
|
|
&desc_text_final);
|
2015-08-07 12:55:29 +02:00
|
|
|
|
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);
|
2014-04-15 16:40:48 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PRIVATE_KEY_SHADOWED:
|
2016-03-17 00:37:58 +01:00
|
|
|
|
err = remove_key_file (grip);
|
2014-04-15 16:40:48 +02:00
|
|
|
|
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;
|
|
|
|
|
}
|
2016-10-20 05:05:15 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Write an S-expression formatted shadow key to our key storage.
|
2023-03-13 08:49:49 +01:00
|
|
|
|
* 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. If
|
2024-01-24 11:29:24 +01:00
|
|
|
|
* REALLYFORCE is also true, even a private key will be overwritten by
|
|
|
|
|
* a shadown key. If DISPSERIALNO is not NULL the human readable s/n
|
|
|
|
|
* will also be recorded in the key file. */
|
2016-10-20 05:05:15 +02:00
|
|
|
|
gpg_error_t
|
2023-03-13 08:49:49 +01:00
|
|
|
|
agent_write_shadow_key (const unsigned char *grip,
|
2016-10-20 05:05:15 +02:00
|
|
|
|
const char *serialno, const char *keyid,
|
2024-01-24 11:29:24 +01:00
|
|
|
|
const unsigned char *pkbuf, int force, int reallyforce,
|
2022-08-15 12:49:56 +02:00
|
|
|
|
const char *dispserialno)
|
2016-10-20 05:05:15 +02:00
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
unsigned char *shadow_info;
|
|
|
|
|
unsigned char *shdkey;
|
|
|
|
|
size_t len;
|
|
|
|
|
|
2022-08-15 12:49:56 +02:00
|
|
|
|
/* Just in case some caller did not parse the stuff correctly, skip
|
|
|
|
|
* leading spaces. */
|
|
|
|
|
while (spacep (serialno))
|
|
|
|
|
serialno++;
|
|
|
|
|
while (spacep (keyid))
|
|
|
|
|
keyid++;
|
|
|
|
|
|
2016-10-20 05:05:15 +02:00
|
|
|
|
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);
|
2024-01-24 11:29:24 +01:00
|
|
|
|
err = agent_write_private_key (grip, shdkey, len, force, reallyforce,
|
2023-03-13 08:49:49 +01:00
|
|
|
|
serialno, keyid, dispserialno, 0);
|
2016-10-20 05:05:15 +02:00
|
|
|
|
xfree (shdkey);
|
|
|
|
|
if (err)
|
2023-03-13 08:49:49 +01:00
|
|
|
|
log_error ("error writing key: %s\n", gpg_strerror (err));
|
2016-10-20 05:05:15 +02:00
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|