2008-02-14 19:50:10 +00:00
|
|
|
|
/* call-agent.c - Divert GPG operations to the agent.
|
2015-01-21 11:31:20 +01:00
|
|
|
|
* Copyright (C) 2001-2003, 2006-2011, 2013 Free Software Foundation, Inc.
|
|
|
|
|
* Copyright (C) 2013-2015 Werner Koch
|
2003-06-05 07:14:21 +00: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 19:49:40 +00:00
|
|
|
|
* the Free Software Foundation; either version 3 of the License, or
|
2003-06-05 07:14:21 +00: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
|
2007-07-04 19:49:40 +00:00
|
|
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
2003-06-05 07:14:21 +00:00
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
#include <errno.h>
|
2011-02-04 12:57:53 +01:00
|
|
|
|
#include <unistd.h>
|
2003-06-05 07:14:21 +00:00
|
|
|
|
#include <time.h>
|
|
|
|
|
#ifdef HAVE_LOCALE_H
|
|
|
|
|
#include <locale.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#include "gpg.h"
|
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* configure.ac (NEED_LIBASSUAN_API, NEED_LIBASSUAN_VERSION):
Update to new API (2, 1.1.0).
agent/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-agent.c (parse_rereadable_options): Don't set global assuan
log file (there ain't one anymore).
(main): Update to new API.
(check_own_socket_pid_cb): Return gpg_error_t instead of int.
(check_own_socket_thread, check_for_running_agent): Create assuan
context before connecting to server.
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(write_and_clear_outbuf): Use gpg_error_t instead of
assuan_error_t.
(cmd_geteventcounter, cmd_istrusted, cmd_listtrusted)
(cmd_marktrusted, cmd_havekey, cmd_sigkey, cmd_setkeydesc)
(cmd_sethash, cmd_pksign, cmd_pkdecrypt, cmd_genkey, cmd_readkey)
(cmd_keyinfo, cmd_get_passphrase, cmd_clear_passphrase)
(cmd_get_confirmation, cmd_learn, cmd_passwd)
(cmd_preset_passphrase, cmd_scd, cmd_getval, cmd_putval)
(cmd_updatestartuptty, cmd_killagent, cmd_reloadagent)
(cmd_getinfo, option_handler): Return gpg_error_t instead of int.
(post_cmd_notify): Change type of ERR to gpg_error_t from int.
(io_monitor): Add hook argument. Use symbols for constants.
(register_commands): Change return type of HANDLER to gpg_error_t.
(start_command_handler): Allocate assuan context before starting
server.
* call-pinentry.c: Include "scdaemon.h" before <assuan.h> because
of GPG_ERR_SOURCE_DEFAULT check.
(unlock_pinentry): Call assuan_release instead of
assuan_disconnect.
(getinfo_pid_cb, getpin_cb): Return gpg_error_t instead of int.
(start_pinentry): Allocate assuan context before connecting to
server.
* call-scd.c (membuf_data_cb, learn_status_cb, get_serialno_cb)
(membuf_data_cb, inq_needpin, card_getattr_cb, pass_status_thru)
(pass_data_thru): Change return type to gpg_error_t.
(start_scd): Allocate assuan context before connecting to server.
common/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* asshelp.c (start_new_gpg_agent): Allocate assuan context before
starting server.
g10/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* call-agent.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(learn_status_cb, dummy_data_cb, get_serialno_cb, default_inq_cb)
(learn_status_cb, inq_writecert_parms, inq_writekey_parms)
(scd_genkey_cb, membuf_data_cb): Return gpg_error_t instead of
int.
* gpg.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(main): Update to new Assuan API.
* server.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, do_listkeys, cmd_listkeys)
(cmd_listsecretkeys, cmd_genkey, cmd_getinfo): Return gpg_error_t
instead of int.
(register_commands): Allocate assuan context before starting
server.
(gpg_server): Allocate assuan_context before starting server.
scd/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, open_card, cmd_serialno, cmd_lean, cmd_readcert)
(cmd_readkey, cmd_setdata, cmd_pksign, cmd_pkauth, cmd_pkdecrypt)
(cmd_getattr, cmd_setattr, cmd_writecert, cmd_writekey)
(cmd_genkey, cmd_random, cmd_passwd, cmd_checkpin, cmd_lock)
(cmd_unlock, cmd_getinfo, cmd_restart, cmd_disconnect, cmd_apdu)
(cmd_killscd): Return gpg_error_t instead of int.
(scd_command_handler): Allocate assuan context before starting server.
* scdaemon.c (main): Update to new Assuan API.
sm/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpgsm.c (main): Update to new assuan API.
* server.c: Include "gpgsm.h" before <assuan.h> due to check for
GPG_ERR_SOURCE_DEFAULT and assuan.h now including gpg-error.h.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, cmd_listkeys, cmd_dumpkeys)
(cmd_listsecretkeys, cmd_dumpsecretkeys, cmd_genkey)
(cmd_getauditlog, cmd_getinfo): Return gpg_error_t instead of int.
(register_commands): Same for member HANDLER in table.
(gpgsm_server): Allocate assuan context before starting server.
* sm/call-dirmngr.c:
* call-dirmngr.c (prepare_dirmngr): Check for CTX and error before
setting LDAPSERVER.
(start_dirmngr_ext): Allocate assuan context before starting
server.
(inq_certificate, isvalid_status_cb, lookup_cb, lookup_status_cb)
(run_command_cb, run_command_inq_cb, run_command_status_cb):
Return gpg_error_t instead of int.
tools/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-connect-agent.c (getinfo_pid_cb, read_and_print_response)
(main): Update to new Assuan API.
2009-09-23 00:01:25 +00:00
|
|
|
|
#include <assuan.h>
|
2003-06-18 19:56:13 +00:00
|
|
|
|
#include "util.h"
|
|
|
|
|
#include "membuf.h"
|
|
|
|
|
#include "options.h"
|
2003-06-05 07:14:21 +00:00
|
|
|
|
#include "i18n.h"
|
2006-09-20 11:01:49 +00:00
|
|
|
|
#include "asshelp.h"
|
2008-02-14 19:50:10 +00:00
|
|
|
|
#include "sysutils.h"
|
2003-06-18 19:56:13 +00:00
|
|
|
|
#include "call-agent.h"
|
2009-07-22 16:08:58 +00:00
|
|
|
|
#include "status.h"
|
2013-02-07 20:37:58 +01:00
|
|
|
|
#include "../common/shareddefs.h"
|
2015-02-11 10:27:57 +01:00
|
|
|
|
#include "host2net.h"
|
2003-06-18 19:56:13 +00:00
|
|
|
|
|
2013-02-07 20:37:58 +01:00
|
|
|
|
#define CONTROL_D ('D' - 'A' + 1)
|
|
|
|
|
|
|
|
|
|
|
2006-08-16 10:47:53 +00:00
|
|
|
|
static assuan_context_t agent_ctx = NULL;
|
2009-07-22 16:08:58 +00:00
|
|
|
|
static int did_early_card_test;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s
|
2006-08-16 10:47:53 +00:00
|
|
|
|
{
|
2010-04-23 11:36:59 +00:00
|
|
|
|
ctrl_t ctrl;
|
2006-08-16 10:47:53 +00:00
|
|
|
|
assuan_context_t ctx;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct {
|
|
|
|
|
u32 *keyid;
|
|
|
|
|
u32 *mainkeyid;
|
|
|
|
|
int pubkey_algo;
|
|
|
|
|
} keyinfo;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct cipher_parm_s
|
|
|
|
|
{
|
|
|
|
|
struct default_inq_parm_s *dflt;
|
|
|
|
|
assuan_context_t ctx;
|
2010-04-23 11:36:59 +00:00
|
|
|
|
unsigned char *ciphertext;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
size_t ciphertextlen;
|
|
|
|
|
};
|
|
|
|
|
|
2008-09-23 09:57:45 +00:00
|
|
|
|
struct writecert_parm_s
|
|
|
|
|
{
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s *dflt;
|
2008-09-23 09:57:45 +00:00
|
|
|
|
const unsigned char *certdata;
|
|
|
|
|
size_t certdatalen;
|
|
|
|
|
};
|
|
|
|
|
|
2006-08-16 10:47:53 +00:00
|
|
|
|
struct writekey_parm_s
|
|
|
|
|
{
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s *dflt;
|
2006-08-16 10:47:53 +00:00
|
|
|
|
const unsigned char *keydata;
|
|
|
|
|
size_t keydatalen;
|
|
|
|
|
};
|
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
struct genkey_parm_s
|
2006-08-16 10:47:53 +00:00
|
|
|
|
{
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s *dflt;
|
2010-04-20 17:57:50 +00:00
|
|
|
|
const char *keyparms;
|
2015-01-21 11:31:20 +01:00
|
|
|
|
const char *passphrase;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
};
|
|
|
|
|
|
2010-08-31 15:58:39 +00:00
|
|
|
|
struct import_key_parm_s
|
|
|
|
|
{
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s *dflt;
|
2010-08-31 15:58:39 +00:00
|
|
|
|
const void *key;
|
|
|
|
|
size_t keylen;
|
|
|
|
|
};
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
2010-10-26 09:10:29 +00:00
|
|
|
|
struct cache_nonce_parm_s
|
|
|
|
|
{
|
|
|
|
|
char **cache_nonce_addr;
|
|
|
|
|
char **passwd_nonce_addr;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2011-06-16 14:27:33 +02:00
|
|
|
|
struct scd_genkey_parm_s
|
|
|
|
|
{
|
|
|
|
|
struct agent_card_genkey_s *cgk;
|
|
|
|
|
char *savedbytes; /* Malloced space to save key parameter chunks. */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* configure.ac (NEED_LIBASSUAN_API, NEED_LIBASSUAN_VERSION):
Update to new API (2, 1.1.0).
agent/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-agent.c (parse_rereadable_options): Don't set global assuan
log file (there ain't one anymore).
(main): Update to new API.
(check_own_socket_pid_cb): Return gpg_error_t instead of int.
(check_own_socket_thread, check_for_running_agent): Create assuan
context before connecting to server.
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(write_and_clear_outbuf): Use gpg_error_t instead of
assuan_error_t.
(cmd_geteventcounter, cmd_istrusted, cmd_listtrusted)
(cmd_marktrusted, cmd_havekey, cmd_sigkey, cmd_setkeydesc)
(cmd_sethash, cmd_pksign, cmd_pkdecrypt, cmd_genkey, cmd_readkey)
(cmd_keyinfo, cmd_get_passphrase, cmd_clear_passphrase)
(cmd_get_confirmation, cmd_learn, cmd_passwd)
(cmd_preset_passphrase, cmd_scd, cmd_getval, cmd_putval)
(cmd_updatestartuptty, cmd_killagent, cmd_reloadagent)
(cmd_getinfo, option_handler): Return gpg_error_t instead of int.
(post_cmd_notify): Change type of ERR to gpg_error_t from int.
(io_monitor): Add hook argument. Use symbols for constants.
(register_commands): Change return type of HANDLER to gpg_error_t.
(start_command_handler): Allocate assuan context before starting
server.
* call-pinentry.c: Include "scdaemon.h" before <assuan.h> because
of GPG_ERR_SOURCE_DEFAULT check.
(unlock_pinentry): Call assuan_release instead of
assuan_disconnect.
(getinfo_pid_cb, getpin_cb): Return gpg_error_t instead of int.
(start_pinentry): Allocate assuan context before connecting to
server.
* call-scd.c (membuf_data_cb, learn_status_cb, get_serialno_cb)
(membuf_data_cb, inq_needpin, card_getattr_cb, pass_status_thru)
(pass_data_thru): Change return type to gpg_error_t.
(start_scd): Allocate assuan context before connecting to server.
common/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* asshelp.c (start_new_gpg_agent): Allocate assuan context before
starting server.
g10/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* call-agent.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(learn_status_cb, dummy_data_cb, get_serialno_cb, default_inq_cb)
(learn_status_cb, inq_writecert_parms, inq_writekey_parms)
(scd_genkey_cb, membuf_data_cb): Return gpg_error_t instead of
int.
* gpg.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(main): Update to new Assuan API.
* server.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, do_listkeys, cmd_listkeys)
(cmd_listsecretkeys, cmd_genkey, cmd_getinfo): Return gpg_error_t
instead of int.
(register_commands): Allocate assuan context before starting
server.
(gpg_server): Allocate assuan_context before starting server.
scd/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, open_card, cmd_serialno, cmd_lean, cmd_readcert)
(cmd_readkey, cmd_setdata, cmd_pksign, cmd_pkauth, cmd_pkdecrypt)
(cmd_getattr, cmd_setattr, cmd_writecert, cmd_writekey)
(cmd_genkey, cmd_random, cmd_passwd, cmd_checkpin, cmd_lock)
(cmd_unlock, cmd_getinfo, cmd_restart, cmd_disconnect, cmd_apdu)
(cmd_killscd): Return gpg_error_t instead of int.
(scd_command_handler): Allocate assuan context before starting server.
* scdaemon.c (main): Update to new Assuan API.
sm/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpgsm.c (main): Update to new assuan API.
* server.c: Include "gpgsm.h" before <assuan.h> due to check for
GPG_ERR_SOURCE_DEFAULT and assuan.h now including gpg-error.h.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, cmd_listkeys, cmd_dumpkeys)
(cmd_listsecretkeys, cmd_dumpsecretkeys, cmd_genkey)
(cmd_getauditlog, cmd_getinfo): Return gpg_error_t instead of int.
(register_commands): Same for member HANDLER in table.
(gpgsm_server): Allocate assuan context before starting server.
* sm/call-dirmngr.c:
* call-dirmngr.c (prepare_dirmngr): Check for CTX and error before
setting LDAPSERVER.
(start_dirmngr_ext): Allocate assuan context before starting
server.
(inq_certificate, isvalid_status_cb, lookup_cb, lookup_status_cb)
(run_command_cb, run_command_inq_cb, run_command_status_cb):
Return gpg_error_t instead of int.
tools/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-connect-agent.c (getinfo_pid_cb, read_and_print_response)
(main): Update to new Assuan API.
2009-09-23 00:01:25 +00:00
|
|
|
|
static gpg_error_t learn_status_cb (void *opaque, const char *line);
|
2009-07-22 16:08:58 +00:00
|
|
|
|
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
2009-07-22 16:08:58 +00:00
|
|
|
|
/* If RC is not 0, write an appropriate status message. */
|
|
|
|
|
static void
|
|
|
|
|
status_sc_op_failure (int rc)
|
|
|
|
|
{
|
|
|
|
|
switch (gpg_err_code (rc))
|
|
|
|
|
{
|
|
|
|
|
case 0:
|
|
|
|
|
break;
|
|
|
|
|
case GPG_ERR_CANCELED:
|
2010-10-13 15:57:08 +00:00
|
|
|
|
case GPG_ERR_FULLY_CANCELED:
|
2009-07-22 16:08:58 +00:00
|
|
|
|
write_status_text (STATUS_SC_OP_FAILURE, "1");
|
|
|
|
|
break;
|
|
|
|
|
case GPG_ERR_BAD_PIN:
|
|
|
|
|
write_status_text (STATUS_SC_OP_FAILURE, "2");
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
write_status (STATUS_SC_OP_FAILURE);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
}
|
2009-07-22 16:08:58 +00:00
|
|
|
|
|
|
|
|
|
|
2014-04-15 16:40:48 +02:00
|
|
|
|
/* This is the default inquiry callback. It mainly handles the
|
|
|
|
|
Pinentry notifications. */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
default_inq_cb (void *opaque, const char *line)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err = 0;
|
|
|
|
|
struct default_inq_parm_s *parm = opaque;
|
|
|
|
|
|
|
|
|
|
if (has_leading_keyword (line, "PINENTRY_LAUNCHED"))
|
|
|
|
|
{
|
|
|
|
|
err = gpg_proxy_pinentry_notify (parm->ctrl, line);
|
|
|
|
|
if (err)
|
|
|
|
|
log_error (_("failed to proxy %s inquiry to client\n"),
|
|
|
|
|
"PINENTRY_LAUNCHED");
|
|
|
|
|
/* We do not pass errors to avoid breaking other code. */
|
|
|
|
|
}
|
|
|
|
|
else if ((has_leading_keyword (line, "PASSPHRASE")
|
|
|
|
|
|| has_leading_keyword (line, "NEW_PASSPHRASE"))
|
|
|
|
|
&& opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
|
|
|
|
|
{
|
|
|
|
|
if (have_static_passphrase ())
|
|
|
|
|
{
|
|
|
|
|
const char *s = get_static_passphrase ();
|
|
|
|
|
err = assuan_send_data (parm->ctx, s, strlen (s));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
char *pw;
|
2015-04-16 21:00:30 -04:00
|
|
|
|
char buf[32];
|
2014-04-15 16:40:48 +02:00
|
|
|
|
|
|
|
|
|
if (parm->keyinfo.keyid)
|
|
|
|
|
emit_status_need_passphrase (parm->keyinfo.keyid,
|
|
|
|
|
parm->keyinfo.mainkeyid,
|
|
|
|
|
parm->keyinfo.pubkey_algo);
|
2015-04-16 21:00:30 -04:00
|
|
|
|
|
|
|
|
|
snprintf (buf, sizeof (buf), "%u", 100);
|
|
|
|
|
write_status_text (STATUS_INQUIRE_MAXLEN, buf);
|
2014-04-15 16:40:48 +02:00
|
|
|
|
pw = cpr_get_hidden ("passphrase.enter", _("Enter passphrase: "));
|
|
|
|
|
cpr_kill_prompt ();
|
|
|
|
|
if (*pw == CONTROL_D && !pw[1])
|
|
|
|
|
err = gpg_error (GPG_ERR_CANCELED);
|
|
|
|
|
else
|
|
|
|
|
err = assuan_send_data (parm->ctx, pw, strlen (pw));
|
|
|
|
|
xfree (pw);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
log_debug ("ignoring gpg-agent inquiry '%s'\n", line);
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-01-08 10:33:19 +01:00
|
|
|
|
/* Print a warning if the server's version number is less than our
|
|
|
|
|
version number. Returns an error code on a connection problem. */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
warn_version_mismatch (assuan_context_t ctx, const char *servername, int mode)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
char *serverversion;
|
|
|
|
|
const char *myversion = strusage (13);
|
|
|
|
|
|
|
|
|
|
err = get_assuan_server_version (ctx, mode, &serverversion);
|
|
|
|
|
if (err)
|
|
|
|
|
log_error (_("error getting version from '%s': %s\n"),
|
|
|
|
|
servername, gpg_strerror (err));
|
|
|
|
|
else if (!compare_version_strings (serverversion, myversion))
|
|
|
|
|
{
|
|
|
|
|
char *warn;
|
|
|
|
|
|
|
|
|
|
warn = xtryasprintf (_("server '%s' is older than us (%s < %s)"),
|
|
|
|
|
servername, serverversion, myversion);
|
|
|
|
|
if (!warn)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
log_info (_("WARNING: %s\n"), warn);
|
|
|
|
|
write_status_strings (STATUS_WARNING, "server_version_mismatch 0",
|
|
|
|
|
" ", warn, NULL);
|
|
|
|
|
xfree (warn);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
xfree (serverversion);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
/* Try to connect to the agent via socket or fork it off and work by
|
|
|
|
|
pipes. Handle the server's initial greeting */
|
|
|
|
|
static int
|
2010-04-20 17:57:50 +00:00
|
|
|
|
start_agent (ctrl_t ctrl, int for_card)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2008-02-14 19:50:10 +00:00
|
|
|
|
int rc;
|
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
(void)ctrl; /* Not yet used. */
|
|
|
|
|
|
2009-07-22 16:08:58 +00:00
|
|
|
|
/* Fixme: We need a context for each thread or serialize the access
|
|
|
|
|
to the agent. */
|
2003-06-05 07:14:21 +00:00
|
|
|
|
if (agent_ctx)
|
2009-07-22 16:08:58 +00:00
|
|
|
|
rc = 0;
|
|
|
|
|
else
|
2008-02-14 19:50:10 +00:00
|
|
|
|
{
|
2009-07-22 16:08:58 +00:00
|
|
|
|
rc = start_new_gpg_agent (&agent_ctx,
|
|
|
|
|
GPG_ERR_SOURCE_DEFAULT,
|
|
|
|
|
opt.agent_program,
|
|
|
|
|
opt.lc_ctype, opt.lc_messages,
|
|
|
|
|
opt.session_env,
|
2015-04-06 13:42:17 +02:00
|
|
|
|
opt.autostart, opt.verbose, DBG_IPC,
|
2009-07-22 16:08:58 +00:00
|
|
|
|
NULL, NULL);
|
2014-11-28 09:44:19 +01:00
|
|
|
|
if (!opt.autostart && gpg_err_code (rc) == GPG_ERR_NO_AGENT)
|
|
|
|
|
{
|
|
|
|
|
static int shown;
|
|
|
|
|
|
|
|
|
|
if (!shown)
|
|
|
|
|
{
|
|
|
|
|
shown = 1;
|
|
|
|
|
log_info (_("no gpg-agent running in this session\n"));
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-01-08 10:33:19 +01:00
|
|
|
|
else if (!rc
|
|
|
|
|
&& !(rc = warn_version_mismatch (agent_ctx, GPG_AGENT_NAME, 0)))
|
2009-07-22 16:08:58 +00:00
|
|
|
|
{
|
|
|
|
|
/* Tell the agent that we support Pinentry notifications.
|
|
|
|
|
No error checking so that it will work also with older
|
|
|
|
|
agents. */
|
|
|
|
|
assuan_transact (agent_ctx, "OPTION allow-pinentry-notify",
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
2010-10-13 15:57:08 +00:00
|
|
|
|
/* Tell the agent about what version we are aware. This is
|
|
|
|
|
here used to indirectly enable GPG_ERR_FULLY_CANCELED. */
|
|
|
|
|
assuan_transact (agent_ctx, "OPTION agent-awareness=2.1.0",
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
2013-02-07 20:37:58 +01:00
|
|
|
|
/* Pass on the pinentry mode. */
|
|
|
|
|
if (opt.pinentry_mode)
|
|
|
|
|
{
|
|
|
|
|
char *tmp = xasprintf ("OPTION pinentry-mode=%s",
|
|
|
|
|
str_pinentry_mode (opt.pinentry_mode));
|
|
|
|
|
rc = assuan_transact (agent_ctx, tmp,
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
xfree (tmp);
|
|
|
|
|
if (rc)
|
2015-08-25 09:03:31 +02:00
|
|
|
|
{
|
|
|
|
|
log_error ("setting pinentry mode '%s' failed: %s\n",
|
|
|
|
|
str_pinentry_mode (opt.pinentry_mode),
|
|
|
|
|
gpg_strerror (rc));
|
|
|
|
|
write_status_error ("set_pinentry_mode", rc);
|
|
|
|
|
}
|
2013-02-07 20:37:58 +01:00
|
|
|
|
}
|
2009-07-22 16:08:58 +00:00
|
|
|
|
}
|
2008-02-14 19:50:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2009-07-22 16:08:58 +00:00
|
|
|
|
if (!rc && for_card && !did_early_card_test)
|
|
|
|
|
{
|
|
|
|
|
/* Request the serial number of the card for an early test. */
|
|
|
|
|
struct agent_card_info_s info;
|
|
|
|
|
|
|
|
|
|
memset (&info, 0, sizeof info);
|
2016-01-08 10:33:19 +01:00
|
|
|
|
|
|
|
|
|
rc = warn_version_mismatch (agent_ctx, SCDAEMON_NAME, 2);
|
|
|
|
|
if (!rc)
|
|
|
|
|
rc = assuan_transact (agent_ctx, "SCD SERIALNO openpgp",
|
|
|
|
|
NULL, NULL, NULL, NULL,
|
|
|
|
|
learn_status_cb, &info);
|
2009-07-22 16:08:58 +00:00
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
switch (gpg_err_code (rc))
|
|
|
|
|
{
|
|
|
|
|
case GPG_ERR_NOT_SUPPORTED:
|
|
|
|
|
case GPG_ERR_NO_SCDAEMON:
|
|
|
|
|
write_status_text (STATUS_CARDCTRL, "6");
|
|
|
|
|
break;
|
2014-12-15 17:38:40 +01:00
|
|
|
|
case GPG_ERR_OBJ_TERM_STATE:
|
|
|
|
|
write_status_text (STATUS_CARDCTRL, "7");
|
|
|
|
|
break;
|
2009-07-22 16:08:58 +00:00
|
|
|
|
default:
|
|
|
|
|
write_status_text (STATUS_CARDCTRL, "4");
|
|
|
|
|
log_info ("selecting openpgp failed: %s\n", gpg_strerror (rc));
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!rc && is_status_enabled () && info.serialno)
|
|
|
|
|
{
|
|
|
|
|
char *buf;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-07-22 16:08:58 +00:00
|
|
|
|
buf = xasprintf ("3 %s", info.serialno);
|
|
|
|
|
write_status_text (STATUS_CARDCTRL, buf);
|
|
|
|
|
xfree (buf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
agent_release_card_info (&info);
|
|
|
|
|
|
|
|
|
|
if (!rc)
|
|
|
|
|
did_early_card_test = 1;
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2008-02-14 19:50:10 +00:00
|
|
|
|
return rc;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-06-27 20:53:09 +00:00
|
|
|
|
/* Return a new malloced string by unescaping the string S. Escaping
|
|
|
|
|
is percent escaping and '+'/space mapping. A binary nul will
|
|
|
|
|
silently be replaced by a 0xFF. Function returns NULL to indicate
|
|
|
|
|
an out of memory status. */
|
|
|
|
|
static char *
|
|
|
|
|
unescape_status_string (const unsigned char *s)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
2009-04-01 10:51:53 +00:00
|
|
|
|
return percent_plus_unescape (s, 0xff);
|
2003-06-27 20:53:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2006-10-04 16:45:04 +00:00
|
|
|
|
|
2003-06-27 20:53:09 +00:00
|
|
|
|
/* Take a 20 byte hexencoded string and put it into the the provided
|
|
|
|
|
20 byte buffer FPR in binary format. */
|
|
|
|
|
static int
|
|
|
|
|
unhexify_fpr (const char *hexstr, unsigned char *fpr)
|
|
|
|
|
{
|
|
|
|
|
const char *s;
|
|
|
|
|
int n;
|
|
|
|
|
|
|
|
|
|
for (s=hexstr, n=0; hexdigitp (s); s++, n++)
|
|
|
|
|
;
|
|
|
|
|
if (*s || (n != 40))
|
|
|
|
|
return 0; /* no fingerprint (invalid or wrong length). */
|
|
|
|
|
for (s=hexstr, n=0; *s; s += 2, n++)
|
|
|
|
|
fpr[n] = xtoi_2 (s);
|
|
|
|
|
return 1; /* okay */
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
2003-06-27 20:53:09 +00:00
|
|
|
|
|
2003-07-01 08:34:45 +00:00
|
|
|
|
/* Take the serial number from LINE and return it verbatim in a newly
|
|
|
|
|
allocated string. We make sure that only hex characters are
|
|
|
|
|
returned. */
|
|
|
|
|
static char *
|
|
|
|
|
store_serialno (const char *line)
|
|
|
|
|
{
|
|
|
|
|
const char *s;
|
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
|
|
for (s=line; hexdigitp (s); s++)
|
|
|
|
|
;
|
|
|
|
|
p = xtrymalloc (s + 1 - line);
|
|
|
|
|
if (p)
|
|
|
|
|
{
|
|
|
|
|
memcpy (p, line, s-line);
|
|
|
|
|
p[s-line] = 0;
|
|
|
|
|
}
|
|
|
|
|
return p;
|
|
|
|
|
}
|
|
|
|
|
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
|
|
|
|
|
2009-01-13 14:01:56 +00:00
|
|
|
|
/* This is a dummy data line callback. */
|
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* configure.ac (NEED_LIBASSUAN_API, NEED_LIBASSUAN_VERSION):
Update to new API (2, 1.1.0).
agent/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-agent.c (parse_rereadable_options): Don't set global assuan
log file (there ain't one anymore).
(main): Update to new API.
(check_own_socket_pid_cb): Return gpg_error_t instead of int.
(check_own_socket_thread, check_for_running_agent): Create assuan
context before connecting to server.
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(write_and_clear_outbuf): Use gpg_error_t instead of
assuan_error_t.
(cmd_geteventcounter, cmd_istrusted, cmd_listtrusted)
(cmd_marktrusted, cmd_havekey, cmd_sigkey, cmd_setkeydesc)
(cmd_sethash, cmd_pksign, cmd_pkdecrypt, cmd_genkey, cmd_readkey)
(cmd_keyinfo, cmd_get_passphrase, cmd_clear_passphrase)
(cmd_get_confirmation, cmd_learn, cmd_passwd)
(cmd_preset_passphrase, cmd_scd, cmd_getval, cmd_putval)
(cmd_updatestartuptty, cmd_killagent, cmd_reloadagent)
(cmd_getinfo, option_handler): Return gpg_error_t instead of int.
(post_cmd_notify): Change type of ERR to gpg_error_t from int.
(io_monitor): Add hook argument. Use symbols for constants.
(register_commands): Change return type of HANDLER to gpg_error_t.
(start_command_handler): Allocate assuan context before starting
server.
* call-pinentry.c: Include "scdaemon.h" before <assuan.h> because
of GPG_ERR_SOURCE_DEFAULT check.
(unlock_pinentry): Call assuan_release instead of
assuan_disconnect.
(getinfo_pid_cb, getpin_cb): Return gpg_error_t instead of int.
(start_pinentry): Allocate assuan context before connecting to
server.
* call-scd.c (membuf_data_cb, learn_status_cb, get_serialno_cb)
(membuf_data_cb, inq_needpin, card_getattr_cb, pass_status_thru)
(pass_data_thru): Change return type to gpg_error_t.
(start_scd): Allocate assuan context before connecting to server.
common/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* asshelp.c (start_new_gpg_agent): Allocate assuan context before
starting server.
g10/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* call-agent.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(learn_status_cb, dummy_data_cb, get_serialno_cb, default_inq_cb)
(learn_status_cb, inq_writecert_parms, inq_writekey_parms)
(scd_genkey_cb, membuf_data_cb): Return gpg_error_t instead of
int.
* gpg.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(main): Update to new Assuan API.
* server.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, do_listkeys, cmd_listkeys)
(cmd_listsecretkeys, cmd_genkey, cmd_getinfo): Return gpg_error_t
instead of int.
(register_commands): Allocate assuan context before starting
server.
(gpg_server): Allocate assuan_context before starting server.
scd/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, open_card, cmd_serialno, cmd_lean, cmd_readcert)
(cmd_readkey, cmd_setdata, cmd_pksign, cmd_pkauth, cmd_pkdecrypt)
(cmd_getattr, cmd_setattr, cmd_writecert, cmd_writekey)
(cmd_genkey, cmd_random, cmd_passwd, cmd_checkpin, cmd_lock)
(cmd_unlock, cmd_getinfo, cmd_restart, cmd_disconnect, cmd_apdu)
(cmd_killscd): Return gpg_error_t instead of int.
(scd_command_handler): Allocate assuan context before starting server.
* scdaemon.c (main): Update to new Assuan API.
sm/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpgsm.c (main): Update to new assuan API.
* server.c: Include "gpgsm.h" before <assuan.h> due to check for
GPG_ERR_SOURCE_DEFAULT and assuan.h now including gpg-error.h.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, cmd_listkeys, cmd_dumpkeys)
(cmd_listsecretkeys, cmd_dumpsecretkeys, cmd_genkey)
(cmd_getauditlog, cmd_getinfo): Return gpg_error_t instead of int.
(register_commands): Same for member HANDLER in table.
(gpgsm_server): Allocate assuan context before starting server.
* sm/call-dirmngr.c:
* call-dirmngr.c (prepare_dirmngr): Check for CTX and error before
setting LDAPSERVER.
(start_dirmngr_ext): Allocate assuan context before starting
server.
(inq_certificate, isvalid_status_cb, lookup_cb, lookup_status_cb)
(run_command_cb, run_command_inq_cb, run_command_status_cb):
Return gpg_error_t instead of int.
tools/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-connect-agent.c (getinfo_pid_cb, read_and_print_response)
(main): Update to new Assuan API.
2009-09-23 00:01:25 +00:00
|
|
|
|
static gpg_error_t
|
2009-01-13 14:01:56 +00:00
|
|
|
|
dummy_data_cb (void *opaque, const void *buffer, size_t length)
|
|
|
|
|
{
|
|
|
|
|
(void)opaque;
|
|
|
|
|
(void)buffer;
|
|
|
|
|
(void)length;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-11 10:56:44 +00:00
|
|
|
|
/* A simple callback used to return the serialnumber of a card. */
|
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* configure.ac (NEED_LIBASSUAN_API, NEED_LIBASSUAN_VERSION):
Update to new API (2, 1.1.0).
agent/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-agent.c (parse_rereadable_options): Don't set global assuan
log file (there ain't one anymore).
(main): Update to new API.
(check_own_socket_pid_cb): Return gpg_error_t instead of int.
(check_own_socket_thread, check_for_running_agent): Create assuan
context before connecting to server.
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(write_and_clear_outbuf): Use gpg_error_t instead of
assuan_error_t.
(cmd_geteventcounter, cmd_istrusted, cmd_listtrusted)
(cmd_marktrusted, cmd_havekey, cmd_sigkey, cmd_setkeydesc)
(cmd_sethash, cmd_pksign, cmd_pkdecrypt, cmd_genkey, cmd_readkey)
(cmd_keyinfo, cmd_get_passphrase, cmd_clear_passphrase)
(cmd_get_confirmation, cmd_learn, cmd_passwd)
(cmd_preset_passphrase, cmd_scd, cmd_getval, cmd_putval)
(cmd_updatestartuptty, cmd_killagent, cmd_reloadagent)
(cmd_getinfo, option_handler): Return gpg_error_t instead of int.
(post_cmd_notify): Change type of ERR to gpg_error_t from int.
(io_monitor): Add hook argument. Use symbols for constants.
(register_commands): Change return type of HANDLER to gpg_error_t.
(start_command_handler): Allocate assuan context before starting
server.
* call-pinentry.c: Include "scdaemon.h" before <assuan.h> because
of GPG_ERR_SOURCE_DEFAULT check.
(unlock_pinentry): Call assuan_release instead of
assuan_disconnect.
(getinfo_pid_cb, getpin_cb): Return gpg_error_t instead of int.
(start_pinentry): Allocate assuan context before connecting to
server.
* call-scd.c (membuf_data_cb, learn_status_cb, get_serialno_cb)
(membuf_data_cb, inq_needpin, card_getattr_cb, pass_status_thru)
(pass_data_thru): Change return type to gpg_error_t.
(start_scd): Allocate assuan context before connecting to server.
common/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* asshelp.c (start_new_gpg_agent): Allocate assuan context before
starting server.
g10/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* call-agent.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(learn_status_cb, dummy_data_cb, get_serialno_cb, default_inq_cb)
(learn_status_cb, inq_writecert_parms, inq_writekey_parms)
(scd_genkey_cb, membuf_data_cb): Return gpg_error_t instead of
int.
* gpg.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(main): Update to new Assuan API.
* server.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, do_listkeys, cmd_listkeys)
(cmd_listsecretkeys, cmd_genkey, cmd_getinfo): Return gpg_error_t
instead of int.
(register_commands): Allocate assuan context before starting
server.
(gpg_server): Allocate assuan_context before starting server.
scd/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, open_card, cmd_serialno, cmd_lean, cmd_readcert)
(cmd_readkey, cmd_setdata, cmd_pksign, cmd_pkauth, cmd_pkdecrypt)
(cmd_getattr, cmd_setattr, cmd_writecert, cmd_writekey)
(cmd_genkey, cmd_random, cmd_passwd, cmd_checkpin, cmd_lock)
(cmd_unlock, cmd_getinfo, cmd_restart, cmd_disconnect, cmd_apdu)
(cmd_killscd): Return gpg_error_t instead of int.
(scd_command_handler): Allocate assuan context before starting server.
* scdaemon.c (main): Update to new Assuan API.
sm/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpgsm.c (main): Update to new assuan API.
* server.c: Include "gpgsm.h" before <assuan.h> due to check for
GPG_ERR_SOURCE_DEFAULT and assuan.h now including gpg-error.h.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, cmd_listkeys, cmd_dumpkeys)
(cmd_listsecretkeys, cmd_dumpsecretkeys, cmd_genkey)
(cmd_getauditlog, cmd_getinfo): Return gpg_error_t instead of int.
(register_commands): Same for member HANDLER in table.
(gpgsm_server): Allocate assuan context before starting server.
* sm/call-dirmngr.c:
* call-dirmngr.c (prepare_dirmngr): Check for CTX and error before
setting LDAPSERVER.
(start_dirmngr_ext): Allocate assuan context before starting
server.
(inq_certificate, isvalid_status_cb, lookup_cb, lookup_status_cb)
(run_command_cb, run_command_inq_cb, run_command_status_cb):
Return gpg_error_t instead of int.
tools/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-connect-agent.c (getinfo_pid_cb, read_and_print_response)
(main): Update to new Assuan API.
2009-09-23 00:01:25 +00:00
|
|
|
|
static gpg_error_t
|
2009-08-11 10:56:44 +00:00
|
|
|
|
get_serialno_cb (void *opaque, const char *line)
|
|
|
|
|
{
|
|
|
|
|
char **serialno = opaque;
|
|
|
|
|
const char *keyword = line;
|
|
|
|
|
const char *s;
|
|
|
|
|
int keywordlen, n;
|
|
|
|
|
|
|
|
|
|
for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
|
|
|
|
|
;
|
|
|
|
|
while (spacep (line))
|
|
|
|
|
line++;
|
|
|
|
|
|
|
|
|
|
if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
|
|
|
|
|
{
|
|
|
|
|
if (*serialno)
|
|
|
|
|
return gpg_error (GPG_ERR_CONFLICT); /* Unexpected status line. */
|
|
|
|
|
for (n=0,s=line; hexdigitp (s); s++, n++)
|
|
|
|
|
;
|
|
|
|
|
if (!n || (n&1)|| !(spacep (s) || !*s) )
|
|
|
|
|
return gpg_error (GPG_ERR_ASS_PARAMETER);
|
|
|
|
|
*serialno = xtrymalloc (n+1);
|
|
|
|
|
if (!*serialno)
|
|
|
|
|
return out_of_core ();
|
|
|
|
|
memcpy (*serialno, line, n);
|
|
|
|
|
(*serialno)[n] = 0;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-08-11 10:56:44 +00:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-01-13 14:01:56 +00:00
|
|
|
|
|
2008-02-14 19:50:10 +00:00
|
|
|
|
|
2003-07-23 07:11:06 +00:00
|
|
|
|
/* Release the card info structure INFO. */
|
|
|
|
|
void
|
|
|
|
|
agent_release_card_info (struct agent_card_info_s *info)
|
|
|
|
|
{
|
2014-12-16 13:10:09 +01:00
|
|
|
|
int i;
|
|
|
|
|
|
2003-07-23 07:11:06 +00:00
|
|
|
|
if (!info)
|
|
|
|
|
return;
|
|
|
|
|
|
2015-11-09 16:15:44 +09:00
|
|
|
|
xfree (info->reader); info->reader = NULL;
|
2003-07-23 07:11:06 +00:00
|
|
|
|
xfree (info->serialno); info->serialno = NULL;
|
2009-01-13 14:01:56 +00:00
|
|
|
|
xfree (info->apptype); info->apptype = NULL;
|
2003-07-23 07:11:06 +00:00
|
|
|
|
xfree (info->disp_name); info->disp_name = NULL;
|
2003-07-24 09:06:43 +00:00
|
|
|
|
xfree (info->disp_lang); info->disp_lang = NULL;
|
2003-07-23 07:11:06 +00:00
|
|
|
|
xfree (info->pubkey_url); info->pubkey_url = NULL;
|
2003-07-24 09:06:43 +00:00
|
|
|
|
xfree (info->login_data); info->login_data = NULL;
|
2004-07-01 17:42:09 +00:00
|
|
|
|
info->cafpr1valid = info->cafpr2valid = info->cafpr3valid = 0;
|
2003-07-23 07:11:06 +00:00
|
|
|
|
info->fpr1valid = info->fpr2valid = info->fpr3valid = 0;
|
2014-12-16 13:10:09 +01:00
|
|
|
|
for (i=0; i < DIM(info->private_do); i++)
|
|
|
|
|
{
|
|
|
|
|
xfree (info->private_do[i]);
|
|
|
|
|
info->private_do[i] = NULL;
|
|
|
|
|
}
|
2003-07-23 07:11:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
2014-12-16 13:10:09 +01:00
|
|
|
|
|
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* configure.ac (NEED_LIBASSUAN_API, NEED_LIBASSUAN_VERSION):
Update to new API (2, 1.1.0).
agent/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-agent.c (parse_rereadable_options): Don't set global assuan
log file (there ain't one anymore).
(main): Update to new API.
(check_own_socket_pid_cb): Return gpg_error_t instead of int.
(check_own_socket_thread, check_for_running_agent): Create assuan
context before connecting to server.
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(write_and_clear_outbuf): Use gpg_error_t instead of
assuan_error_t.
(cmd_geteventcounter, cmd_istrusted, cmd_listtrusted)
(cmd_marktrusted, cmd_havekey, cmd_sigkey, cmd_setkeydesc)
(cmd_sethash, cmd_pksign, cmd_pkdecrypt, cmd_genkey, cmd_readkey)
(cmd_keyinfo, cmd_get_passphrase, cmd_clear_passphrase)
(cmd_get_confirmation, cmd_learn, cmd_passwd)
(cmd_preset_passphrase, cmd_scd, cmd_getval, cmd_putval)
(cmd_updatestartuptty, cmd_killagent, cmd_reloadagent)
(cmd_getinfo, option_handler): Return gpg_error_t instead of int.
(post_cmd_notify): Change type of ERR to gpg_error_t from int.
(io_monitor): Add hook argument. Use symbols for constants.
(register_commands): Change return type of HANDLER to gpg_error_t.
(start_command_handler): Allocate assuan context before starting
server.
* call-pinentry.c: Include "scdaemon.h" before <assuan.h> because
of GPG_ERR_SOURCE_DEFAULT check.
(unlock_pinentry): Call assuan_release instead of
assuan_disconnect.
(getinfo_pid_cb, getpin_cb): Return gpg_error_t instead of int.
(start_pinentry): Allocate assuan context before connecting to
server.
* call-scd.c (membuf_data_cb, learn_status_cb, get_serialno_cb)
(membuf_data_cb, inq_needpin, card_getattr_cb, pass_status_thru)
(pass_data_thru): Change return type to gpg_error_t.
(start_scd): Allocate assuan context before connecting to server.
common/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* asshelp.c (start_new_gpg_agent): Allocate assuan context before
starting server.
g10/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* call-agent.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(learn_status_cb, dummy_data_cb, get_serialno_cb, default_inq_cb)
(learn_status_cb, inq_writecert_parms, inq_writekey_parms)
(scd_genkey_cb, membuf_data_cb): Return gpg_error_t instead of
int.
* gpg.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(main): Update to new Assuan API.
* server.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, do_listkeys, cmd_listkeys)
(cmd_listsecretkeys, cmd_genkey, cmd_getinfo): Return gpg_error_t
instead of int.
(register_commands): Allocate assuan context before starting
server.
(gpg_server): Allocate assuan_context before starting server.
scd/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, open_card, cmd_serialno, cmd_lean, cmd_readcert)
(cmd_readkey, cmd_setdata, cmd_pksign, cmd_pkauth, cmd_pkdecrypt)
(cmd_getattr, cmd_setattr, cmd_writecert, cmd_writekey)
(cmd_genkey, cmd_random, cmd_passwd, cmd_checkpin, cmd_lock)
(cmd_unlock, cmd_getinfo, cmd_restart, cmd_disconnect, cmd_apdu)
(cmd_killscd): Return gpg_error_t instead of int.
(scd_command_handler): Allocate assuan context before starting server.
* scdaemon.c (main): Update to new Assuan API.
sm/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpgsm.c (main): Update to new assuan API.
* server.c: Include "gpgsm.h" before <assuan.h> due to check for
GPG_ERR_SOURCE_DEFAULT and assuan.h now including gpg-error.h.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, cmd_listkeys, cmd_dumpkeys)
(cmd_listsecretkeys, cmd_dumpsecretkeys, cmd_genkey)
(cmd_getauditlog, cmd_getinfo): Return gpg_error_t instead of int.
(register_commands): Same for member HANDLER in table.
(gpgsm_server): Allocate assuan context before starting server.
* sm/call-dirmngr.c:
* call-dirmngr.c (prepare_dirmngr): Check for CTX and error before
setting LDAPSERVER.
(start_dirmngr_ext): Allocate assuan context before starting
server.
(inq_certificate, isvalid_status_cb, lookup_cb, lookup_status_cb)
(run_command_cb, run_command_inq_cb, run_command_status_cb):
Return gpg_error_t instead of int.
tools/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-connect-agent.c (getinfo_pid_cb, read_and_print_response)
(main): Update to new Assuan API.
2009-09-23 00:01:25 +00:00
|
|
|
|
static gpg_error_t
|
2003-06-27 20:53:09 +00:00
|
|
|
|
learn_status_cb (void *opaque, const char *line)
|
|
|
|
|
{
|
|
|
|
|
struct agent_card_info_s *parm = opaque;
|
|
|
|
|
const char *keyword = line;
|
|
|
|
|
int keywordlen;
|
2003-07-24 09:06:43 +00:00
|
|
|
|
int i;
|
2003-06-27 20:53:09 +00:00
|
|
|
|
|
|
|
|
|
for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
|
|
|
|
|
;
|
|
|
|
|
while (spacep (line))
|
|
|
|
|
line++;
|
|
|
|
|
|
2015-11-09 16:15:44 +09:00
|
|
|
|
if (keywordlen == 6 && !memcmp (keyword, "READER", keywordlen))
|
|
|
|
|
{
|
|
|
|
|
xfree (parm->reader);
|
|
|
|
|
parm->reader = unescape_status_string (line);
|
|
|
|
|
}
|
|
|
|
|
else if (keywordlen == 8 && !memcmp (keyword, "SERIALNO", keywordlen))
|
2003-07-01 08:34:45 +00:00
|
|
|
|
{
|
2003-09-30 17:34:38 +00:00
|
|
|
|
xfree (parm->serialno);
|
2003-07-01 08:34:45 +00:00
|
|
|
|
parm->serialno = store_serialno (line);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
parm->is_v2 = (strlen (parm->serialno) >= 16
|
2008-09-25 10:06:02 +00:00
|
|
|
|
&& xtoi_2 (parm->serialno+12) >= 2 );
|
2003-07-01 08:34:45 +00:00
|
|
|
|
}
|
2009-01-13 14:01:56 +00:00
|
|
|
|
else if (keywordlen == 7 && !memcmp (keyword, "APPTYPE", keywordlen))
|
|
|
|
|
{
|
|
|
|
|
xfree (parm->apptype);
|
|
|
|
|
parm->apptype = unescape_status_string (line);
|
|
|
|
|
}
|
2003-07-01 08:34:45 +00:00
|
|
|
|
else if (keywordlen == 9 && !memcmp (keyword, "DISP-NAME", keywordlen))
|
2003-06-27 20:53:09 +00:00
|
|
|
|
{
|
2003-09-30 17:34:38 +00:00
|
|
|
|
xfree (parm->disp_name);
|
2003-06-27 20:53:09 +00:00
|
|
|
|
parm->disp_name = unescape_status_string (line);
|
|
|
|
|
}
|
2003-07-24 09:06:43 +00:00
|
|
|
|
else if (keywordlen == 9 && !memcmp (keyword, "DISP-LANG", keywordlen))
|
|
|
|
|
{
|
2003-09-30 17:34:38 +00:00
|
|
|
|
xfree (parm->disp_lang);
|
2003-07-24 09:06:43 +00:00
|
|
|
|
parm->disp_lang = unescape_status_string (line);
|
|
|
|
|
}
|
|
|
|
|
else if (keywordlen == 8 && !memcmp (keyword, "DISP-SEX", keywordlen))
|
|
|
|
|
{
|
|
|
|
|
parm->disp_sex = *line == '1'? 1 : *line == '2' ? 2: 0;
|
|
|
|
|
}
|
2003-07-03 18:08:16 +00:00
|
|
|
|
else if (keywordlen == 10 && !memcmp (keyword, "PUBKEY-URL", keywordlen))
|
2003-06-27 20:53:09 +00:00
|
|
|
|
{
|
2003-09-30 17:34:38 +00:00
|
|
|
|
xfree (parm->pubkey_url);
|
2003-06-27 20:53:09 +00:00
|
|
|
|
parm->pubkey_url = unescape_status_string (line);
|
|
|
|
|
}
|
2003-07-24 09:06:43 +00:00
|
|
|
|
else if (keywordlen == 10 && !memcmp (keyword, "LOGIN-DATA", keywordlen))
|
|
|
|
|
{
|
2003-09-30 17:34:38 +00:00
|
|
|
|
xfree (parm->login_data);
|
2003-07-24 09:06:43 +00:00
|
|
|
|
parm->login_data = unescape_status_string (line);
|
|
|
|
|
}
|
|
|
|
|
else if (keywordlen == 11 && !memcmp (keyword, "SIG-COUNTER", keywordlen))
|
|
|
|
|
{
|
|
|
|
|
parm->sig_counter = strtoul (line, NULL, 0);
|
|
|
|
|
}
|
|
|
|
|
else if (keywordlen == 10 && !memcmp (keyword, "CHV-STATUS", keywordlen))
|
|
|
|
|
{
|
|
|
|
|
char *p, *buf;
|
|
|
|
|
|
|
|
|
|
buf = p = unescape_status_string (line);
|
|
|
|
|
if (buf)
|
|
|
|
|
{
|
|
|
|
|
while (spacep (p))
|
|
|
|
|
p++;
|
|
|
|
|
parm->chv1_cached = atoi (p);
|
2003-10-25 14:22:08 +00:00
|
|
|
|
while (*p && !spacep (p))
|
2003-07-24 09:06:43 +00:00
|
|
|
|
p++;
|
|
|
|
|
while (spacep (p))
|
|
|
|
|
p++;
|
|
|
|
|
for (i=0; *p && i < 3; i++)
|
|
|
|
|
{
|
|
|
|
|
parm->chvmaxlen[i] = atoi (p);
|
2003-10-25 14:22:08 +00:00
|
|
|
|
while (*p && !spacep (p))
|
2003-07-24 09:06:43 +00:00
|
|
|
|
p++;
|
|
|
|
|
while (spacep (p))
|
|
|
|
|
p++;
|
|
|
|
|
}
|
|
|
|
|
for (i=0; *p && i < 3; i++)
|
|
|
|
|
{
|
|
|
|
|
parm->chvretry[i] = atoi (p);
|
2003-10-25 14:22:08 +00:00
|
|
|
|
while (*p && !spacep (p))
|
2003-07-24 09:06:43 +00:00
|
|
|
|
p++;
|
|
|
|
|
while (spacep (p))
|
|
|
|
|
p++;
|
|
|
|
|
}
|
|
|
|
|
xfree (buf);
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-07-22 17:21:47 +00:00
|
|
|
|
else if (keywordlen == 6 && !memcmp (keyword, "EXTCAP", keywordlen))
|
|
|
|
|
{
|
|
|
|
|
char *p, *p2, *buf;
|
|
|
|
|
int abool;
|
|
|
|
|
|
|
|
|
|
buf = p = unescape_status_string (line);
|
|
|
|
|
if (buf)
|
|
|
|
|
{
|
|
|
|
|
for (p = strtok (buf, " "); p; p = strtok (NULL, " "))
|
|
|
|
|
{
|
|
|
|
|
p2 = strchr (p, '=');
|
|
|
|
|
if (p2)
|
|
|
|
|
{
|
|
|
|
|
*p2++ = 0;
|
|
|
|
|
abool = (*p2 == '1');
|
|
|
|
|
if (!strcmp (p, "ki"))
|
|
|
|
|
parm->extcap.ki = abool;
|
|
|
|
|
else if (!strcmp (p, "aac"))
|
|
|
|
|
parm->extcap.aac = abool;
|
2014-12-15 17:38:40 +01:00
|
|
|
|
else if (!strcmp (p, "si"))
|
|
|
|
|
parm->status_indicator = strtoul (p2, NULL, 10);
|
2009-07-22 17:21:47 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
xfree (buf);
|
|
|
|
|
}
|
|
|
|
|
}
|
2003-06-27 20:53:09 +00:00
|
|
|
|
else if (keywordlen == 7 && !memcmp (keyword, "KEY-FPR", keywordlen))
|
|
|
|
|
{
|
|
|
|
|
int no = atoi (line);
|
2003-10-25 14:22:08 +00:00
|
|
|
|
while (*line && !spacep (line))
|
2003-06-27 20:53:09 +00:00
|
|
|
|
line++;
|
|
|
|
|
while (spacep (line))
|
|
|
|
|
line++;
|
|
|
|
|
if (no == 1)
|
|
|
|
|
parm->fpr1valid = unhexify_fpr (line, parm->fpr1);
|
|
|
|
|
else if (no == 2)
|
|
|
|
|
parm->fpr2valid = unhexify_fpr (line, parm->fpr2);
|
|
|
|
|
else if (no == 3)
|
|
|
|
|
parm->fpr3valid = unhexify_fpr (line, parm->fpr3);
|
|
|
|
|
}
|
2009-07-22 17:21:47 +00:00
|
|
|
|
else if (keywordlen == 8 && !memcmp (keyword, "KEY-TIME", keywordlen))
|
|
|
|
|
{
|
|
|
|
|
int no = atoi (line);
|
|
|
|
|
while (* line && !spacep (line))
|
|
|
|
|
line++;
|
|
|
|
|
while (spacep (line))
|
|
|
|
|
line++;
|
|
|
|
|
if (no == 1)
|
|
|
|
|
parm->fpr1time = strtoul (line, NULL, 10);
|
|
|
|
|
else if (no == 2)
|
|
|
|
|
parm->fpr2time = strtoul (line, NULL, 10);
|
|
|
|
|
else if (no == 3)
|
|
|
|
|
parm->fpr3time = strtoul (line, NULL, 10);
|
|
|
|
|
}
|
2004-07-01 17:42:09 +00:00
|
|
|
|
else if (keywordlen == 6 && !memcmp (keyword, "CA-FPR", keywordlen))
|
|
|
|
|
{
|
|
|
|
|
int no = atoi (line);
|
|
|
|
|
while (*line && !spacep (line))
|
|
|
|
|
line++;
|
|
|
|
|
while (spacep (line))
|
|
|
|
|
line++;
|
|
|
|
|
if (no == 1)
|
|
|
|
|
parm->cafpr1valid = unhexify_fpr (line, parm->cafpr1);
|
|
|
|
|
else if (no == 2)
|
|
|
|
|
parm->cafpr2valid = unhexify_fpr (line, parm->cafpr2);
|
|
|
|
|
else if (no == 3)
|
|
|
|
|
parm->cafpr3valid = unhexify_fpr (line, parm->cafpr3);
|
|
|
|
|
}
|
2009-05-15 19:26:46 +00:00
|
|
|
|
else if (keywordlen == 8 && !memcmp (keyword, "KEY-ATTR", keywordlen))
|
|
|
|
|
{
|
2015-07-25 12:09:23 +09:00
|
|
|
|
int keyno = 0;
|
|
|
|
|
int algo = PUBKEY_ALGO_RSA;
|
|
|
|
|
int n = 0;
|
2009-05-15 19:26:46 +00:00
|
|
|
|
|
2015-07-25 12:09:23 +09:00
|
|
|
|
sscanf (line, "%d %d %n", &keyno, &algo, &n);
|
2009-05-15 19:26:46 +00:00
|
|
|
|
keyno--;
|
2015-07-25 12:09:23 +09:00
|
|
|
|
if (keyno < 0 || keyno >= DIM (parm->key_attr))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
parm->key_attr[keyno].algo = algo;
|
|
|
|
|
if (algo == PUBKEY_ALGO_RSA)
|
|
|
|
|
parm->key_attr[keyno].nbits = strtoul (line+n+3, NULL, 10);
|
|
|
|
|
else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA
|
|
|
|
|
|| algo == PUBKEY_ALGO_EDDSA)
|
2009-05-15 19:26:46 +00:00
|
|
|
|
{
|
2015-07-25 12:09:23 +09:00
|
|
|
|
const char *curve;
|
|
|
|
|
|
2016-01-26 11:12:33 +09:00
|
|
|
|
for (i = 0; (curve = openpgp_enum_curves (&i));)
|
|
|
|
|
if (!strcmp (curve, line+n))
|
|
|
|
|
break;
|
|
|
|
|
|
2015-07-25 12:09:23 +09:00
|
|
|
|
parm->key_attr[keyno].curve = curve;
|
2009-05-15 19:26:46 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2014-12-16 13:10:09 +01:00
|
|
|
|
else if (keywordlen == 12 && !memcmp (keyword, "PRIVATE-DO-", 11)
|
|
|
|
|
&& strchr("1234", keyword[11]))
|
|
|
|
|
{
|
|
|
|
|
int no = keyword[11] - '1';
|
2016-04-29 11:05:24 +02:00
|
|
|
|
log_assert (no >= 0 && no <= 3);
|
2014-12-16 13:10:09 +01:00
|
|
|
|
xfree (parm->private_do[no]);
|
|
|
|
|
parm->private_do[no] = unescape_status_string (line);
|
|
|
|
|
}
|
2009-05-15 19:26:46 +00:00
|
|
|
|
|
2003-06-27 20:53:09 +00:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-19 14:09:04 +02:00
|
|
|
|
/* Call the scdaemon to learn about a smartcard */
|
2003-06-05 07:14:21 +00:00
|
|
|
|
int
|
2015-04-03 17:39:59 +09:00
|
|
|
|
agent_scd_learn (struct agent_card_info_s *info, int force)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
{
|
|
|
|
|
int rc;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s parm;
|
2014-12-12 12:35:45 +01:00
|
|
|
|
struct agent_card_info_s dummyinfo;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
|
2014-12-15 17:38:40 +01:00
|
|
|
|
if (!info)
|
|
|
|
|
info = &dummyinfo;
|
|
|
|
|
memset (info, 0, sizeof *info);
|
2013-02-07 20:37:58 +01:00
|
|
|
|
memset (&parm, 0, sizeof parm);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
rc = start_agent (NULL, 1);
|
2003-06-05 07:14:21 +00:00
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
2009-08-05 13:48:23 +00:00
|
|
|
|
/* Send the serialno command to initialize the connection. We don't
|
|
|
|
|
care about the data returned. If the card has already been
|
|
|
|
|
initialized, this is a very fast command. The main reason we
|
|
|
|
|
need to do this here is to handle a card removed case so that an
|
|
|
|
|
"l" command in --card-edit can be used to show ta newly inserted
|
|
|
|
|
card. We request the openpgp card because that is what we
|
|
|
|
|
expect. */
|
|
|
|
|
rc = assuan_transact (agent_ctx, "SCD SERIALNO openpgp",
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
2013-02-07 20:37:58 +01:00
|
|
|
|
parm.ctx = agent_ctx;
|
2015-04-03 17:39:59 +09:00
|
|
|
|
rc = assuan_transact (agent_ctx,
|
|
|
|
|
force ? "LEARN --sendinfo --force" : "LEARN --sendinfo",
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dummy_data_cb, NULL, default_inq_cb, &parm,
|
2003-06-27 20:53:09 +00:00
|
|
|
|
learn_status_cb, info);
|
2009-05-15 19:26:46 +00:00
|
|
|
|
/* Also try to get the key attributes. */
|
|
|
|
|
if (!rc)
|
|
|
|
|
agent_scd_getattr ("KEY-ATTR", info);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2014-12-12 12:35:45 +01:00
|
|
|
|
if (info == &dummyinfo)
|
|
|
|
|
agent_release_card_info (info);
|
2014-10-19 14:09:04 +02:00
|
|
|
|
|
2014-12-12 12:35:45 +01:00
|
|
|
|
return rc;
|
2014-10-19 14:09:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2014-12-15 17:38:40 +01:00
|
|
|
|
/* Send an APDU to the current card. On success the status word is
|
|
|
|
|
stored at R_SW. With HEXAPDU being NULL only a RESET command is
|
|
|
|
|
send to scd. With HEXAPDU being the string "undefined" the command
|
|
|
|
|
"SERIALNO undefined" is send to scd. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
agent_scd_apdu (const char *hexapdu, unsigned int *r_sw)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
|
|
|
|
|
/* Start the agent but not with the card flag so that we do not
|
|
|
|
|
autoselect the openpgp application. */
|
|
|
|
|
err = start_agent (NULL, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
if (!hexapdu)
|
|
|
|
|
{
|
|
|
|
|
err = assuan_transact (agent_ctx, "SCD RESET",
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
else if (!strcmp (hexapdu, "undefined"))
|
|
|
|
|
{
|
|
|
|
|
err = assuan_transact (agent_ctx, "SCD SERIALNO undefined",
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
|
|
|
|
membuf_t mb;
|
|
|
|
|
unsigned char *data;
|
|
|
|
|
size_t datalen;
|
|
|
|
|
|
|
|
|
|
init_membuf (&mb, 256);
|
|
|
|
|
|
|
|
|
|
snprintf (line, DIM(line)-1, "SCD APDU %s", hexapdu);
|
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
2016-01-08 06:33:27 +01:00
|
|
|
|
put_membuf_cb, &mb, NULL, NULL, NULL, NULL);
|
2014-12-15 17:38:40 +01:00
|
|
|
|
if (!err)
|
|
|
|
|
{
|
|
|
|
|
data = get_membuf (&mb, &datalen);
|
|
|
|
|
if (!data)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
else if (datalen < 2) /* Ooops */
|
|
|
|
|
err = gpg_error (GPG_ERR_CARD);
|
|
|
|
|
else
|
|
|
|
|
{
|
2015-02-11 10:27:57 +01:00
|
|
|
|
*r_sw = buf16_to_uint (data+datalen-2);
|
2014-12-15 17:38:40 +01:00
|
|
|
|
}
|
|
|
|
|
xfree (data);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-02-06 14:01:23 +09:00
|
|
|
|
int
|
|
|
|
|
agent_keytocard (const char *hexgrip, int keyno, int force,
|
|
|
|
|
const char *serialno, const char *timestamp)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2013-02-22 11:00:27 +09:00
|
|
|
|
struct default_inq_parm_s parm;
|
|
|
|
|
|
|
|
|
|
memset (&parm, 0, sizeof parm);
|
2013-02-06 14:01:23 +09:00
|
|
|
|
|
|
|
|
|
snprintf (line, DIM(line)-1, "KEYTOCARD %s%s %s OPENPGP.%d %s",
|
|
|
|
|
force?"--force ": "", hexgrip, serialno, keyno, timestamp);
|
|
|
|
|
line[DIM(line)-1] = 0;
|
|
|
|
|
|
|
|
|
|
rc = start_agent (NULL, 1);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
2016-09-27 14:45:21 +09:00
|
|
|
|
parm.ctx = agent_ctx;
|
2013-02-06 14:01:23 +09:00
|
|
|
|
|
2013-02-22 11:00:27 +09:00
|
|
|
|
rc = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
|
|
|
|
|
NULL, NULL);
|
2013-02-06 14:01:23 +09:00
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2003-09-30 17:34:38 +00:00
|
|
|
|
/* Call the agent to retrieve a data object. This function returns
|
|
|
|
|
the data in the same structure as used by the learn command. It is
|
|
|
|
|
allowed to update such a structure using this commmand. */
|
|
|
|
|
int
|
|
|
|
|
agent_scd_getattr (const char *name, struct agent_card_info_s *info)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s parm;
|
|
|
|
|
|
|
|
|
|
memset (&parm, 0, sizeof parm);
|
2003-09-30 17:34:38 +00:00
|
|
|
|
|
|
|
|
|
if (!*name)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
|
|
|
|
|
/* We assume that NAME does not need escaping. */
|
|
|
|
|
if (12 + strlen (name) > DIM(line)-1)
|
|
|
|
|
return gpg_error (GPG_ERR_TOO_LARGE);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
stpcpy (stpcpy (line, "SCD GETATTR "), name);
|
2003-09-30 17:34:38 +00:00
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
rc = start_agent (NULL, 1);
|
2003-09-30 17:34:38 +00:00
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
2013-02-07 20:37:58 +01:00
|
|
|
|
parm.ctx = agent_ctx;
|
|
|
|
|
rc = assuan_transact (agent_ctx, line, NULL, NULL, default_inq_cb, &parm,
|
2003-09-30 17:34:38 +00:00
|
|
|
|
learn_status_cb, info);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2006-09-06 16:35:52 +00:00
|
|
|
|
return rc;
|
2003-09-30 17:34:38 +00:00
|
|
|
|
}
|
|
|
|
|
|
2003-06-27 20:53:09 +00:00
|
|
|
|
|
2006-05-23 16:19:43 +00:00
|
|
|
|
/* Send an setattr command to the SCdaemon. SERIALNO is not actually
|
|
|
|
|
used here but required by gpg 1.4's implementation of this code in
|
|
|
|
|
cardglue.c. */
|
2003-06-27 20:53:09 +00:00
|
|
|
|
int
|
|
|
|
|
agent_scd_setattr (const char *name,
|
2006-05-23 16:19:43 +00:00
|
|
|
|
const unsigned char *value, size_t valuelen,
|
|
|
|
|
const char *serialno)
|
2003-06-27 20:53:09 +00:00
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
|
|
|
|
char *p;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s parm;
|
|
|
|
|
|
|
|
|
|
memset (&parm, 0, sizeof parm);
|
2003-06-27 20:53:09 +00:00
|
|
|
|
|
2008-10-20 13:53:23 +00:00
|
|
|
|
(void)serialno;
|
|
|
|
|
|
2003-06-27 20:53:09 +00:00
|
|
|
|
if (!*name || !valuelen)
|
2003-06-05 07:14:21 +00:00
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
|
2003-06-27 20:53:09 +00:00
|
|
|
|
/* We assume that NAME does not need escaping. */
|
|
|
|
|
if (12 + strlen (name) > DIM(line)-1)
|
|
|
|
|
return gpg_error (GPG_ERR_TOO_LARGE);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
|
|
|
|
p = stpcpy (stpcpy (line, "SCD SETATTR "), name);
|
2003-06-27 20:53:09 +00:00
|
|
|
|
*p++ = ' ';
|
|
|
|
|
for (; valuelen; value++, valuelen--)
|
|
|
|
|
{
|
|
|
|
|
if (p >= line + DIM(line)-5 )
|
|
|
|
|
return gpg_error (GPG_ERR_TOO_LARGE);
|
|
|
|
|
if (*value < ' ' || *value == '+' || *value == '%')
|
|
|
|
|
{
|
|
|
|
|
sprintf (p, "%%%02X", *value);
|
|
|
|
|
p += 3;
|
|
|
|
|
}
|
|
|
|
|
else if (*value == ' ')
|
|
|
|
|
*p++ = '+';
|
|
|
|
|
else
|
|
|
|
|
*p++ = *value;
|
|
|
|
|
}
|
|
|
|
|
*p = 0;
|
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
rc = start_agent (NULL, 1);
|
2009-07-22 16:08:58 +00:00
|
|
|
|
if (!rc)
|
|
|
|
|
{
|
2013-02-07 20:37:58 +01:00
|
|
|
|
parm.ctx = agent_ctx;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
rc = assuan_transact (agent_ctx, line, NULL, NULL,
|
2013-02-07 20:37:58 +01:00
|
|
|
|
default_inq_cb, &parm, NULL, NULL);
|
2009-07-22 16:08:58 +00:00
|
|
|
|
}
|
2003-06-05 07:14:21 +00:00
|
|
|
|
|
2009-07-22 16:08:58 +00:00
|
|
|
|
status_sc_op_failure (rc);
|
2006-09-06 16:35:52 +00:00
|
|
|
|
return rc;
|
2003-06-05 07:14:21 +00:00
|
|
|
|
}
|
2003-06-27 20:53:09 +00:00
|
|
|
|
|
2006-08-16 10:47:53 +00:00
|
|
|
|
|
2008-09-23 09:57:45 +00:00
|
|
|
|
|
|
|
|
|
/* Handle a CERTDATA inquiry. Note, we only send the data,
|
|
|
|
|
assuan_transact takes care of flushing and writing the END
|
|
|
|
|
command. */
|
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* configure.ac (NEED_LIBASSUAN_API, NEED_LIBASSUAN_VERSION):
Update to new API (2, 1.1.0).
agent/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-agent.c (parse_rereadable_options): Don't set global assuan
log file (there ain't one anymore).
(main): Update to new API.
(check_own_socket_pid_cb): Return gpg_error_t instead of int.
(check_own_socket_thread, check_for_running_agent): Create assuan
context before connecting to server.
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(write_and_clear_outbuf): Use gpg_error_t instead of
assuan_error_t.
(cmd_geteventcounter, cmd_istrusted, cmd_listtrusted)
(cmd_marktrusted, cmd_havekey, cmd_sigkey, cmd_setkeydesc)
(cmd_sethash, cmd_pksign, cmd_pkdecrypt, cmd_genkey, cmd_readkey)
(cmd_keyinfo, cmd_get_passphrase, cmd_clear_passphrase)
(cmd_get_confirmation, cmd_learn, cmd_passwd)
(cmd_preset_passphrase, cmd_scd, cmd_getval, cmd_putval)
(cmd_updatestartuptty, cmd_killagent, cmd_reloadagent)
(cmd_getinfo, option_handler): Return gpg_error_t instead of int.
(post_cmd_notify): Change type of ERR to gpg_error_t from int.
(io_monitor): Add hook argument. Use symbols for constants.
(register_commands): Change return type of HANDLER to gpg_error_t.
(start_command_handler): Allocate assuan context before starting
server.
* call-pinentry.c: Include "scdaemon.h" before <assuan.h> because
of GPG_ERR_SOURCE_DEFAULT check.
(unlock_pinentry): Call assuan_release instead of
assuan_disconnect.
(getinfo_pid_cb, getpin_cb): Return gpg_error_t instead of int.
(start_pinentry): Allocate assuan context before connecting to
server.
* call-scd.c (membuf_data_cb, learn_status_cb, get_serialno_cb)
(membuf_data_cb, inq_needpin, card_getattr_cb, pass_status_thru)
(pass_data_thru): Change return type to gpg_error_t.
(start_scd): Allocate assuan context before connecting to server.
common/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* asshelp.c (start_new_gpg_agent): Allocate assuan context before
starting server.
g10/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* call-agent.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(learn_status_cb, dummy_data_cb, get_serialno_cb, default_inq_cb)
(learn_status_cb, inq_writecert_parms, inq_writekey_parms)
(scd_genkey_cb, membuf_data_cb): Return gpg_error_t instead of
int.
* gpg.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(main): Update to new Assuan API.
* server.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, do_listkeys, cmd_listkeys)
(cmd_listsecretkeys, cmd_genkey, cmd_getinfo): Return gpg_error_t
instead of int.
(register_commands): Allocate assuan context before starting
server.
(gpg_server): Allocate assuan_context before starting server.
scd/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, open_card, cmd_serialno, cmd_lean, cmd_readcert)
(cmd_readkey, cmd_setdata, cmd_pksign, cmd_pkauth, cmd_pkdecrypt)
(cmd_getattr, cmd_setattr, cmd_writecert, cmd_writekey)
(cmd_genkey, cmd_random, cmd_passwd, cmd_checkpin, cmd_lock)
(cmd_unlock, cmd_getinfo, cmd_restart, cmd_disconnect, cmd_apdu)
(cmd_killscd): Return gpg_error_t instead of int.
(scd_command_handler): Allocate assuan context before starting server.
* scdaemon.c (main): Update to new Assuan API.
sm/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpgsm.c (main): Update to new assuan API.
* server.c: Include "gpgsm.h" before <assuan.h> due to check for
GPG_ERR_SOURCE_DEFAULT and assuan.h now including gpg-error.h.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, cmd_listkeys, cmd_dumpkeys)
(cmd_listsecretkeys, cmd_dumpsecretkeys, cmd_genkey)
(cmd_getauditlog, cmd_getinfo): Return gpg_error_t instead of int.
(register_commands): Same for member HANDLER in table.
(gpgsm_server): Allocate assuan context before starting server.
* sm/call-dirmngr.c:
* call-dirmngr.c (prepare_dirmngr): Check for CTX and error before
setting LDAPSERVER.
(start_dirmngr_ext): Allocate assuan context before starting
server.
(inq_certificate, isvalid_status_cb, lookup_cb, lookup_status_cb)
(run_command_cb, run_command_inq_cb, run_command_status_cb):
Return gpg_error_t instead of int.
tools/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-connect-agent.c (getinfo_pid_cb, read_and_print_response)
(main): Update to new Assuan API.
2009-09-23 00:01:25 +00:00
|
|
|
|
static gpg_error_t
|
2008-09-23 09:57:45 +00:00
|
|
|
|
inq_writecert_parms (void *opaque, const char *line)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
struct writecert_parm_s *parm = opaque;
|
2008-09-23 09:57:45 +00:00
|
|
|
|
|
Use has_leading_keyword in the assuan callbacks.
* agent/call-pinentry.c (inq_quality): Use has_leading_keyword.
* agent/call-scd.c (inq_needpin, inq_writekey_parms): Ditto.
* g10/call-agent.c (inq_writecert_parms, keyinfo_status_cb): Ditto.
(inq_genkey_parms, inq_ciphertext_cb, inq_import_key_parms): Ditto.
* g10/call-dirmngr.c (ks_put_inq_cb): Ditto.
* sm/call-agent.c (default_inq_cb, inq_ciphertext_cb): Ditto.
(inq_genkey_parms, istrusted_status_cb, learn_status_cb): Ditto.
(keyinfo_status_cb, inq_import_key_parms): Ditto.
* sm/call-dirmngr.c (inq_certificate, isvalid_status_cb): Ditto.
(lookup_status_cb, run_command_inq_cb, run_command_status_cb): Ditto.
2013-02-22 10:56:13 +01:00
|
|
|
|
if (has_leading_keyword (line, "CERTDATA"))
|
2008-09-23 09:57:45 +00:00
|
|
|
|
{
|
2013-02-07 20:37:58 +01:00
|
|
|
|
rc = assuan_send_data (parm->dflt->ctx,
|
|
|
|
|
parm->certdata, parm->certdatalen);
|
2008-09-23 09:57:45 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
2013-02-07 20:37:58 +01:00
|
|
|
|
rc = default_inq_cb (parm->dflt, line);
|
2008-09-23 09:57:45 +00:00
|
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Send a WRITECERT command to the SCdaemon. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
int
|
2008-09-23 09:57:45 +00:00
|
|
|
|
agent_scd_writecert (const char *certidstr,
|
|
|
|
|
const unsigned char *certdata, size_t certdatalen)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
|
|
|
|
struct writecert_parm_s parms;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
2008-09-23 09:57:45 +00:00
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
rc = start_agent (NULL, 1);
|
2008-09-23 09:57:45 +00:00
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
memset (&parms, 0, sizeof parms);
|
|
|
|
|
|
|
|
|
|
snprintf (line, DIM(line)-1, "SCD WRITECERT %s", certidstr);
|
|
|
|
|
line[DIM(line)-1] = 0;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
|
|
|
|
parms.dflt = &dfltparm;
|
2008-09-23 09:57:45 +00:00
|
|
|
|
parms.certdata = certdata;
|
|
|
|
|
parms.certdatalen = certdatalen;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2008-09-23 09:57:45 +00:00
|
|
|
|
rc = assuan_transact (agent_ctx, line, NULL, NULL,
|
|
|
|
|
inq_writecert_parms, &parms, NULL, NULL);
|
|
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-08-16 10:47:53 +00:00
|
|
|
|
|
|
|
|
|
/* Handle a KEYDATA inquiry. Note, we only send the data,
|
|
|
|
|
assuan_transact takes care of flushing and writing the end */
|
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* configure.ac (NEED_LIBASSUAN_API, NEED_LIBASSUAN_VERSION):
Update to new API (2, 1.1.0).
agent/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-agent.c (parse_rereadable_options): Don't set global assuan
log file (there ain't one anymore).
(main): Update to new API.
(check_own_socket_pid_cb): Return gpg_error_t instead of int.
(check_own_socket_thread, check_for_running_agent): Create assuan
context before connecting to server.
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(write_and_clear_outbuf): Use gpg_error_t instead of
assuan_error_t.
(cmd_geteventcounter, cmd_istrusted, cmd_listtrusted)
(cmd_marktrusted, cmd_havekey, cmd_sigkey, cmd_setkeydesc)
(cmd_sethash, cmd_pksign, cmd_pkdecrypt, cmd_genkey, cmd_readkey)
(cmd_keyinfo, cmd_get_passphrase, cmd_clear_passphrase)
(cmd_get_confirmation, cmd_learn, cmd_passwd)
(cmd_preset_passphrase, cmd_scd, cmd_getval, cmd_putval)
(cmd_updatestartuptty, cmd_killagent, cmd_reloadagent)
(cmd_getinfo, option_handler): Return gpg_error_t instead of int.
(post_cmd_notify): Change type of ERR to gpg_error_t from int.
(io_monitor): Add hook argument. Use symbols for constants.
(register_commands): Change return type of HANDLER to gpg_error_t.
(start_command_handler): Allocate assuan context before starting
server.
* call-pinentry.c: Include "scdaemon.h" before <assuan.h> because
of GPG_ERR_SOURCE_DEFAULT check.
(unlock_pinentry): Call assuan_release instead of
assuan_disconnect.
(getinfo_pid_cb, getpin_cb): Return gpg_error_t instead of int.
(start_pinentry): Allocate assuan context before connecting to
server.
* call-scd.c (membuf_data_cb, learn_status_cb, get_serialno_cb)
(membuf_data_cb, inq_needpin, card_getattr_cb, pass_status_thru)
(pass_data_thru): Change return type to gpg_error_t.
(start_scd): Allocate assuan context before connecting to server.
common/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* asshelp.c (start_new_gpg_agent): Allocate assuan context before
starting server.
g10/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* call-agent.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(learn_status_cb, dummy_data_cb, get_serialno_cb, default_inq_cb)
(learn_status_cb, inq_writecert_parms, inq_writekey_parms)
(scd_genkey_cb, membuf_data_cb): Return gpg_error_t instead of
int.
* gpg.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(main): Update to new Assuan API.
* server.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, do_listkeys, cmd_listkeys)
(cmd_listsecretkeys, cmd_genkey, cmd_getinfo): Return gpg_error_t
instead of int.
(register_commands): Allocate assuan context before starting
server.
(gpg_server): Allocate assuan_context before starting server.
scd/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, open_card, cmd_serialno, cmd_lean, cmd_readcert)
(cmd_readkey, cmd_setdata, cmd_pksign, cmd_pkauth, cmd_pkdecrypt)
(cmd_getattr, cmd_setattr, cmd_writecert, cmd_writekey)
(cmd_genkey, cmd_random, cmd_passwd, cmd_checkpin, cmd_lock)
(cmd_unlock, cmd_getinfo, cmd_restart, cmd_disconnect, cmd_apdu)
(cmd_killscd): Return gpg_error_t instead of int.
(scd_command_handler): Allocate assuan context before starting server.
* scdaemon.c (main): Update to new Assuan API.
sm/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpgsm.c (main): Update to new assuan API.
* server.c: Include "gpgsm.h" before <assuan.h> due to check for
GPG_ERR_SOURCE_DEFAULT and assuan.h now including gpg-error.h.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, cmd_listkeys, cmd_dumpkeys)
(cmd_listsecretkeys, cmd_dumpsecretkeys, cmd_genkey)
(cmd_getauditlog, cmd_getinfo): Return gpg_error_t instead of int.
(register_commands): Same for member HANDLER in table.
(gpgsm_server): Allocate assuan context before starting server.
* sm/call-dirmngr.c:
* call-dirmngr.c (prepare_dirmngr): Check for CTX and error before
setting LDAPSERVER.
(start_dirmngr_ext): Allocate assuan context before starting
server.
(inq_certificate, isvalid_status_cb, lookup_cb, lookup_status_cb)
(run_command_cb, run_command_inq_cb, run_command_status_cb):
Return gpg_error_t instead of int.
tools/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-connect-agent.c (getinfo_pid_cb, read_and_print_response)
(main): Update to new Assuan API.
2009-09-23 00:01:25 +00:00
|
|
|
|
static gpg_error_t
|
2008-02-14 19:50:10 +00:00
|
|
|
|
inq_writekey_parms (void *opaque, const char *line)
|
2006-08-16 10:47:53 +00:00
|
|
|
|
{
|
2008-02-14 19:50:10 +00:00
|
|
|
|
int rc;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
struct writekey_parm_s *parm = opaque;
|
2006-08-16 10:47:53 +00:00
|
|
|
|
|
Use has_leading_keyword in the assuan callbacks.
* agent/call-pinentry.c (inq_quality): Use has_leading_keyword.
* agent/call-scd.c (inq_needpin, inq_writekey_parms): Ditto.
* g10/call-agent.c (inq_writecert_parms, keyinfo_status_cb): Ditto.
(inq_genkey_parms, inq_ciphertext_cb, inq_import_key_parms): Ditto.
* g10/call-dirmngr.c (ks_put_inq_cb): Ditto.
* sm/call-agent.c (default_inq_cb, inq_ciphertext_cb): Ditto.
(inq_genkey_parms, istrusted_status_cb, learn_status_cb): Ditto.
(keyinfo_status_cb, inq_import_key_parms): Ditto.
* sm/call-dirmngr.c (inq_certificate, isvalid_status_cb): Ditto.
(lookup_status_cb, run_command_inq_cb, run_command_status_cb): Ditto.
2013-02-22 10:56:13 +01:00
|
|
|
|
if (has_leading_keyword (line, "KEYDATA"))
|
2008-02-14 19:50:10 +00:00
|
|
|
|
{
|
2013-02-07 20:37:58 +01:00
|
|
|
|
rc = assuan_send_data (parm->dflt->ctx, parm->keydata, parm->keydatalen);
|
2008-02-14 19:50:10 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
2013-02-07 20:37:58 +01:00
|
|
|
|
rc = default_inq_cb (parm->dflt, line);
|
2008-02-14 19:50:10 +00:00
|
|
|
|
|
|
|
|
|
return rc;
|
2006-08-16 10:47:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Send a WRITEKEY command to the SCdaemon. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
int
|
2006-08-16 10:47:53 +00:00
|
|
|
|
agent_scd_writekey (int keyno, const char *serialno,
|
|
|
|
|
const unsigned char *keydata, size_t keydatalen)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
|
|
|
|
struct writekey_parm_s parms;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
2006-08-16 10:47:53 +00:00
|
|
|
|
|
2008-10-20 13:53:23 +00:00
|
|
|
|
(void)serialno;
|
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
rc = start_agent (NULL, 1);
|
2006-08-16 10:47:53 +00:00
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
memset (&parms, 0, sizeof parms);
|
|
|
|
|
|
|
|
|
|
snprintf (line, DIM(line)-1, "SCD WRITEKEY --force OPENPGP.%d", keyno);
|
|
|
|
|
line[DIM(line)-1] = 0;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
|
|
|
|
parms.dflt = &dfltparm;
|
2006-08-16 10:47:53 +00:00
|
|
|
|
parms.keydata = keydata;
|
|
|
|
|
parms.keydatalen = keydatalen;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2006-08-16 10:47:53 +00:00
|
|
|
|
rc = assuan_transact (agent_ctx, line, NULL, NULL,
|
|
|
|
|
inq_writekey_parms, &parms, NULL, NULL);
|
|
|
|
|
|
2009-07-22 16:08:58 +00:00
|
|
|
|
status_sc_op_failure (rc);
|
2006-09-06 16:35:52 +00:00
|
|
|
|
return rc;
|
2006-08-16 10:47:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-06-27 20:53:09 +00:00
|
|
|
|
|
2011-06-16 14:27:33 +02:00
|
|
|
|
static gpg_error_t
|
|
|
|
|
scd_genkey_cb_append_savedbytes (struct scd_genkey_parm_s *parm,
|
|
|
|
|
const char *line)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err = 0;
|
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
|
|
if (!parm->savedbytes)
|
|
|
|
|
{
|
|
|
|
|
parm->savedbytes = xtrystrdup (line);
|
|
|
|
|
if (!parm->savedbytes)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
p = xtrymalloc (strlen (parm->savedbytes) + strlen (line) + 1);
|
|
|
|
|
if (!p)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
strcpy (stpcpy (p, parm->savedbytes), line);
|
|
|
|
|
xfree (parm->savedbytes);
|
|
|
|
|
parm->savedbytes = p;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2003-06-27 20:53:09 +00:00
|
|
|
|
/* Status callback for the SCD GENKEY command. */
|
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* configure.ac (NEED_LIBASSUAN_API, NEED_LIBASSUAN_VERSION):
Update to new API (2, 1.1.0).
agent/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-agent.c (parse_rereadable_options): Don't set global assuan
log file (there ain't one anymore).
(main): Update to new API.
(check_own_socket_pid_cb): Return gpg_error_t instead of int.
(check_own_socket_thread, check_for_running_agent): Create assuan
context before connecting to server.
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(write_and_clear_outbuf): Use gpg_error_t instead of
assuan_error_t.
(cmd_geteventcounter, cmd_istrusted, cmd_listtrusted)
(cmd_marktrusted, cmd_havekey, cmd_sigkey, cmd_setkeydesc)
(cmd_sethash, cmd_pksign, cmd_pkdecrypt, cmd_genkey, cmd_readkey)
(cmd_keyinfo, cmd_get_passphrase, cmd_clear_passphrase)
(cmd_get_confirmation, cmd_learn, cmd_passwd)
(cmd_preset_passphrase, cmd_scd, cmd_getval, cmd_putval)
(cmd_updatestartuptty, cmd_killagent, cmd_reloadagent)
(cmd_getinfo, option_handler): Return gpg_error_t instead of int.
(post_cmd_notify): Change type of ERR to gpg_error_t from int.
(io_monitor): Add hook argument. Use symbols for constants.
(register_commands): Change return type of HANDLER to gpg_error_t.
(start_command_handler): Allocate assuan context before starting
server.
* call-pinentry.c: Include "scdaemon.h" before <assuan.h> because
of GPG_ERR_SOURCE_DEFAULT check.
(unlock_pinentry): Call assuan_release instead of
assuan_disconnect.
(getinfo_pid_cb, getpin_cb): Return gpg_error_t instead of int.
(start_pinentry): Allocate assuan context before connecting to
server.
* call-scd.c (membuf_data_cb, learn_status_cb, get_serialno_cb)
(membuf_data_cb, inq_needpin, card_getattr_cb, pass_status_thru)
(pass_data_thru): Change return type to gpg_error_t.
(start_scd): Allocate assuan context before connecting to server.
common/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* asshelp.c (start_new_gpg_agent): Allocate assuan context before
starting server.
g10/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* call-agent.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(learn_status_cb, dummy_data_cb, get_serialno_cb, default_inq_cb)
(learn_status_cb, inq_writecert_parms, inq_writekey_parms)
(scd_genkey_cb, membuf_data_cb): Return gpg_error_t instead of
int.
* gpg.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(main): Update to new Assuan API.
* server.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, do_listkeys, cmd_listkeys)
(cmd_listsecretkeys, cmd_genkey, cmd_getinfo): Return gpg_error_t
instead of int.
(register_commands): Allocate assuan context before starting
server.
(gpg_server): Allocate assuan_context before starting server.
scd/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* command.c: Include "scdaemon.h" before <assuan.h> because of
GPG_ERR_SOURCE_DEFAULT check.
(option_handler, open_card, cmd_serialno, cmd_lean, cmd_readcert)
(cmd_readkey, cmd_setdata, cmd_pksign, cmd_pkauth, cmd_pkdecrypt)
(cmd_getattr, cmd_setattr, cmd_writecert, cmd_writekey)
(cmd_genkey, cmd_random, cmd_passwd, cmd_checkpin, cmd_lock)
(cmd_unlock, cmd_getinfo, cmd_restart, cmd_disconnect, cmd_apdu)
(cmd_killscd): Return gpg_error_t instead of int.
(scd_command_handler): Allocate assuan context before starting server.
* scdaemon.c (main): Update to new Assuan API.
sm/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpgsm.c (main): Update to new assuan API.
* server.c: Include "gpgsm.h" before <assuan.h> due to check for
GPG_ERR_SOURCE_DEFAULT and assuan.h now including gpg-error.h.
(option_handler, cmd_recipient, cmd_signer, cmd_encrypt)
(cmd_decrypt, cmd_verify, cmd_sign, cmd_import, cmd_export)
(cmd_delkeys, cmd_message, cmd_listkeys, cmd_dumpkeys)
(cmd_listsecretkeys, cmd_dumpsecretkeys, cmd_genkey)
(cmd_getauditlog, cmd_getinfo): Return gpg_error_t instead of int.
(register_commands): Same for member HANDLER in table.
(gpgsm_server): Allocate assuan context before starting server.
* sm/call-dirmngr.c:
* call-dirmngr.c (prepare_dirmngr): Check for CTX and error before
setting LDAPSERVER.
(start_dirmngr_ext): Allocate assuan context before starting
server.
(inq_certificate, isvalid_status_cb, lookup_cb, lookup_status_cb)
(run_command_cb, run_command_inq_cb, run_command_status_cb):
Return gpg_error_t instead of int.
tools/
2009-09-23 Marcus Brinkmann <marcus@g10code.de>
* gpg-connect-agent.c (getinfo_pid_cb, read_and_print_response)
(main): Update to new Assuan API.
2009-09-23 00:01:25 +00:00
|
|
|
|
static gpg_error_t
|
2003-06-27 20:53:09 +00:00
|
|
|
|
scd_genkey_cb (void *opaque, const char *line)
|
|
|
|
|
{
|
2011-06-16 14:27:33 +02:00
|
|
|
|
struct scd_genkey_parm_s *parm = opaque;
|
2003-06-27 20:53:09 +00:00
|
|
|
|
const char *keyword = line;
|
|
|
|
|
int keywordlen;
|
2011-06-16 14:27:33 +02:00
|
|
|
|
gpg_error_t rc = 0;
|
2003-06-27 20:53:09 +00:00
|
|
|
|
|
|
|
|
|
for (keywordlen=0; *line && !spacep (line); line++, keywordlen++)
|
|
|
|
|
;
|
|
|
|
|
while (spacep (line))
|
|
|
|
|
line++;
|
|
|
|
|
|
|
|
|
|
if (keywordlen == 7 && !memcmp (keyword, "KEY-FPR", keywordlen))
|
|
|
|
|
{
|
2011-06-16 14:27:33 +02:00
|
|
|
|
parm->cgk->fprvalid = unhexify_fpr (line, parm->cgk->fpr);
|
2003-06-27 20:53:09 +00:00
|
|
|
|
}
|
2009-08-05 11:24:43 +00:00
|
|
|
|
else if (keywordlen == 8 && !memcmp (keyword, "KEY-DATA", keywordlen))
|
2003-06-27 20:53:09 +00:00
|
|
|
|
{
|
|
|
|
|
gcry_mpi_t a;
|
|
|
|
|
const char *name = line;
|
|
|
|
|
|
2003-10-25 14:22:08 +00:00
|
|
|
|
while (*line && !spacep (line))
|
2003-06-27 20:53:09 +00:00
|
|
|
|
line++;
|
|
|
|
|
while (spacep (line))
|
|
|
|
|
line++;
|
|
|
|
|
|
2011-06-16 14:27:33 +02:00
|
|
|
|
if (*name == '-' && spacep (name+1))
|
|
|
|
|
rc = scd_genkey_cb_append_savedbytes (parm, line);
|
2003-06-27 20:53:09 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
2011-06-16 14:27:33 +02:00
|
|
|
|
if (parm->savedbytes)
|
|
|
|
|
{
|
|
|
|
|
rc = scd_genkey_cb_append_savedbytes (parm, line);
|
|
|
|
|
if (!rc)
|
|
|
|
|
rc = gcry_mpi_scan (&a, GCRYMPI_FMT_HEX,
|
|
|
|
|
parm->savedbytes, 0, NULL);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
rc = gcry_mpi_scan (&a, GCRYMPI_FMT_HEX, line, 0, NULL);
|
|
|
|
|
if (rc)
|
|
|
|
|
log_error ("error parsing received key data: %s\n",
|
|
|
|
|
gpg_strerror (rc));
|
|
|
|
|
else if (*name == 'n' && spacep (name+1))
|
|
|
|
|
parm->cgk->n = a;
|
|
|
|
|
else if (*name == 'e' && spacep (name+1))
|
|
|
|
|
parm->cgk->e = a;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
log_info ("unknown parameter name in received key data\n");
|
|
|
|
|
gcry_mpi_release (a);
|
|
|
|
|
rc = gpg_error (GPG_ERR_INV_PARAMETER);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
xfree (parm->savedbytes);
|
|
|
|
|
parm->savedbytes = NULL;
|
2003-06-27 20:53:09 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (keywordlen == 14 && !memcmp (keyword,"KEY-CREATED-AT", keywordlen))
|
|
|
|
|
{
|
2011-06-16 14:27:33 +02:00
|
|
|
|
parm->cgk->created_at = (u32)strtoul (line, NULL, 10);
|
2003-06-27 20:53:09 +00:00
|
|
|
|
}
|
2009-08-05 11:24:43 +00:00
|
|
|
|
else if (keywordlen == 8 && !memcmp (keyword, "PROGRESS", keywordlen))
|
|
|
|
|
{
|
|
|
|
|
write_status_text (STATUS_PROGRESS, line);
|
|
|
|
|
}
|
2003-06-27 20:53:09 +00:00
|
|
|
|
|
2011-06-16 14:27:33 +02:00
|
|
|
|
return rc;
|
2003-06-27 20:53:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2006-05-23 16:19:43 +00:00
|
|
|
|
/* Send a GENKEY command to the SCdaemon. SERIALNO is not used in
|
2010-11-17 13:21:24 +00:00
|
|
|
|
this implementation. If CREATEDATE is not 0, it will be passed to
|
|
|
|
|
SCDAEMON so that the key is created with this timestamp. INFO will
|
|
|
|
|
receive information about the generated key. */
|
2003-06-27 20:53:09 +00:00
|
|
|
|
int
|
2006-05-23 16:19:43 +00:00
|
|
|
|
agent_scd_genkey (struct agent_card_genkey_s *info, int keyno, int force,
|
2007-07-05 16:58:19 +00:00
|
|
|
|
const char *serialno, u32 createtime)
|
2003-06-27 20:53:09 +00:00
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2007-07-05 16:58:19 +00:00
|
|
|
|
gnupg_isotime_t tbuf;
|
2011-06-16 14:27:33 +02:00
|
|
|
|
struct scd_genkey_parm_s parms;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
2003-06-27 20:53:09 +00:00
|
|
|
|
|
2008-10-20 13:53:23 +00:00
|
|
|
|
(void)serialno;
|
|
|
|
|
|
2011-06-16 14:27:33 +02:00
|
|
|
|
memset (&parms, 0, sizeof parms);
|
|
|
|
|
parms.cgk = info;
|
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
rc = start_agent (NULL, 1);
|
2003-06-27 20:53:09 +00:00
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
2007-07-05 16:58:19 +00:00
|
|
|
|
if (createtime)
|
|
|
|
|
epoch2isotime (tbuf, createtime);
|
|
|
|
|
else
|
|
|
|
|
*tbuf = 0;
|
|
|
|
|
|
|
|
|
|
snprintf (line, DIM(line)-1, "SCD GENKEY %s%s %s %d",
|
|
|
|
|
*tbuf? "--timestamp=":"", tbuf,
|
2011-02-04 12:57:53 +01:00
|
|
|
|
force? "--force":"",
|
2007-07-05 16:58:19 +00:00
|
|
|
|
keyno);
|
2003-06-27 20:53:09 +00:00
|
|
|
|
line[DIM(line)-1] = 0;
|
|
|
|
|
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
2003-06-27 20:53:09 +00:00
|
|
|
|
memset (info, 0, sizeof *info);
|
|
|
|
|
rc = assuan_transact (agent_ctx, line,
|
2013-02-07 20:37:58 +01:00
|
|
|
|
NULL, NULL, default_inq_cb, &dfltparm,
|
2011-06-16 14:27:33 +02:00
|
|
|
|
scd_genkey_cb, &parms);
|
|
|
|
|
|
|
|
|
|
xfree (parms.savedbytes);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-07-22 16:08:58 +00:00
|
|
|
|
status_sc_op_failure (rc);
|
2006-09-06 16:35:52 +00:00
|
|
|
|
return rc;
|
2003-06-27 20:53:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2009-08-11 10:56:44 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Issue an SCD SERIALNO openpgp command and if SERIALNO is not NULL
|
|
|
|
|
ask the user to insert the requested card. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
select_openpgp (const char *serialno)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
|
|
|
|
|
/* Send the serialno command to initialize the connection. Without
|
|
|
|
|
a given S/N we don't care about the data returned. If the card
|
|
|
|
|
has already been initialized, this is a very fast command. We
|
2011-02-04 12:57:53 +01:00
|
|
|
|
request the openpgp card because that is what we expect.
|
2009-08-11 10:56:44 +00:00
|
|
|
|
|
|
|
|
|
Note that an opt.limit_card_insert_tries of 1 means: No tries at
|
|
|
|
|
all whereas 0 means do not limit the number of tries. Due to the
|
|
|
|
|
sue of a pinentry prompt with a cancel option we use it here in a
|
|
|
|
|
boolean sense. */
|
|
|
|
|
if (!serialno || opt.limit_card_insert_tries == 1)
|
|
|
|
|
err = assuan_transact (agent_ctx, "SCD SERIALNO openpgp",
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
char *this_sn = NULL;
|
|
|
|
|
char *desc;
|
|
|
|
|
int ask;
|
|
|
|
|
char *want_sn;
|
|
|
|
|
char *p;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-08-11 10:56:44 +00:00
|
|
|
|
want_sn = xtrystrdup (serialno);
|
|
|
|
|
if (!want_sn)
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
p = strchr (want_sn, '/');
|
|
|
|
|
if (p)
|
|
|
|
|
*p = 0;
|
|
|
|
|
|
2011-02-04 12:57:53 +01:00
|
|
|
|
do
|
2009-08-11 10:56:44 +00:00
|
|
|
|
{
|
|
|
|
|
ask = 0;
|
|
|
|
|
err = assuan_transact (agent_ctx, "SCD SERIALNO openpgp",
|
2011-02-04 12:57:53 +01:00
|
|
|
|
NULL, NULL, NULL, NULL,
|
2009-08-11 10:56:44 +00:00
|
|
|
|
get_serialno_cb, &this_sn);
|
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_CARD_NOT_PRESENT)
|
2011-02-04 12:57:53 +01:00
|
|
|
|
ask = 1;
|
2009-08-11 10:56:44 +00:00
|
|
|
|
else if (gpg_err_code (err) == GPG_ERR_NOT_SUPPORTED)
|
|
|
|
|
ask = 2;
|
|
|
|
|
else if (err)
|
|
|
|
|
;
|
|
|
|
|
else if (this_sn)
|
|
|
|
|
{
|
|
|
|
|
if (strcmp (want_sn, this_sn))
|
|
|
|
|
ask = 2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
xfree (this_sn);
|
|
|
|
|
this_sn = NULL;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-08-11 10:56:44 +00:00
|
|
|
|
if (ask)
|
|
|
|
|
{
|
|
|
|
|
char *formatted = NULL;
|
|
|
|
|
char *ocodeset = i18n_switchto_utf8 ();
|
|
|
|
|
|
2011-02-04 12:57:53 +01:00
|
|
|
|
if (!strncmp (want_sn, "D27600012401", 12)
|
2009-08-11 10:56:44 +00:00
|
|
|
|
&& strlen (want_sn) == 32 )
|
|
|
|
|
formatted = xtryasprintf ("(%.4s) %.8s",
|
|
|
|
|
want_sn + 16, want_sn + 20);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-08-11 10:56:44 +00:00
|
|
|
|
err = 0;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
desc = xtryasprintf
|
2009-08-11 10:56:44 +00:00
|
|
|
|
("%s:\n\n"
|
|
|
|
|
" \"%s\"",
|
|
|
|
|
ask == 1
|
|
|
|
|
? _("Please insert the card with serial number")
|
|
|
|
|
: _("Please remove the current card and "
|
|
|
|
|
"insert the one with serial number"),
|
|
|
|
|
formatted? formatted : want_sn);
|
|
|
|
|
if (!desc)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
xfree (formatted);
|
|
|
|
|
i18n_switchback (ocodeset);
|
|
|
|
|
if (!err)
|
|
|
|
|
err = gpg_agent_get_confirmation (desc);
|
|
|
|
|
xfree (desc);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
while (ask && !err);
|
|
|
|
|
xfree (want_sn);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2009-06-17 09:45:50 +00:00
|
|
|
|
|
|
|
|
|
/* Send a READCERT command to the SCdaemon. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
int
|
2009-06-17 09:45:50 +00:00
|
|
|
|
agent_scd_readcert (const char *certidstr,
|
|
|
|
|
void **r_buf, size_t *r_buflen)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
|
|
|
|
membuf_t data;
|
|
|
|
|
size_t len;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
2009-06-17 09:45:50 +00:00
|
|
|
|
|
|
|
|
|
*r_buf = NULL;
|
2010-04-20 17:57:50 +00:00
|
|
|
|
rc = start_agent (NULL, 1);
|
2009-06-17 09:45:50 +00:00
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
|
|
|
|
|
2009-06-17 09:45:50 +00:00
|
|
|
|
init_membuf (&data, 2048);
|
|
|
|
|
|
|
|
|
|
snprintf (line, DIM(line)-1, "SCD READCERT %s", certidstr);
|
|
|
|
|
line[DIM(line)-1] = 0;
|
|
|
|
|
rc = assuan_transact (agent_ctx, line,
|
2016-01-08 06:33:27 +01:00
|
|
|
|
put_membuf_cb, &data,
|
2013-02-07 20:37:58 +01:00
|
|
|
|
default_inq_cb, &dfltparm,
|
|
|
|
|
NULL, NULL);
|
2009-06-17 09:45:50 +00:00
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
xfree (get_membuf (&data, &len));
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
*r_buf = get_membuf (&data, r_buflen);
|
|
|
|
|
if (!*r_buf)
|
|
|
|
|
return gpg_error (GPG_ERR_ENOMEM);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2003-07-23 07:11:06 +00:00
|
|
|
|
/* Change the PIN of an OpenPGP card or reset the retry counter.
|
2003-09-30 17:34:38 +00:00
|
|
|
|
CHVNO 1: Change the PIN
|
2008-09-25 10:06:02 +00:00
|
|
|
|
2: For v1 cards: Same as 1.
|
|
|
|
|
For v2 cards: Reset the PIN using the Reset Code.
|
2003-07-23 07:11:06 +00:00
|
|
|
|
3: Change the admin PIN
|
2003-09-30 17:34:38 +00:00
|
|
|
|
101: Set a new PIN and reset the retry counter
|
2008-09-25 10:06:02 +00:00
|
|
|
|
102: For v1 cars: Same as 101.
|
|
|
|
|
For v2 cards: Set a new Reset Code.
|
2006-05-23 16:19:43 +00:00
|
|
|
|
SERIALNO is not used.
|
2003-07-23 07:11:06 +00:00
|
|
|
|
*/
|
|
|
|
|
int
|
2006-05-23 16:19:43 +00:00
|
|
|
|
agent_scd_change_pin (int chvno, const char *serialno)
|
2003-07-23 07:11:06 +00:00
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
|
|
|
|
const char *reset = "";
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
2003-07-23 07:11:06 +00:00
|
|
|
|
|
2008-10-20 13:53:23 +00:00
|
|
|
|
(void)serialno;
|
|
|
|
|
|
2003-07-23 07:11:06 +00:00
|
|
|
|
if (chvno >= 100)
|
|
|
|
|
reset = "--reset";
|
|
|
|
|
chvno %= 100;
|
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
rc = start_agent (NULL, 1);
|
2003-07-23 07:11:06 +00:00
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
2003-07-23 07:11:06 +00:00
|
|
|
|
|
|
|
|
|
snprintf (line, DIM(line)-1, "SCD PASSWD %s %d", reset, chvno);
|
|
|
|
|
line[DIM(line)-1] = 0;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
rc = assuan_transact (agent_ctx, line,
|
|
|
|
|
NULL, NULL,
|
|
|
|
|
default_inq_cb, &dfltparm,
|
|
|
|
|
NULL, NULL);
|
2009-07-22 16:08:58 +00:00
|
|
|
|
status_sc_op_failure (rc);
|
2006-09-06 16:35:52 +00:00
|
|
|
|
return rc;
|
2003-07-23 07:11:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
2003-10-21 17:12:21 +00:00
|
|
|
|
|
2004-04-29 17:25:38 +00:00
|
|
|
|
/* Perform a CHECKPIN operation. SERIALNO should be the serial
|
2006-05-23 16:19:43 +00:00
|
|
|
|
number of the card - optionally followed by the fingerprint;
|
2003-10-21 17:12:21 +00:00
|
|
|
|
however the fingerprint is ignored here. */
|
|
|
|
|
int
|
|
|
|
|
agent_scd_checkpin (const char *serialno)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
2003-10-21 17:12:21 +00:00
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
rc = start_agent (NULL, 1);
|
2003-10-21 17:12:21 +00:00
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
2003-10-21 17:12:21 +00:00
|
|
|
|
|
|
|
|
|
snprintf (line, DIM(line)-1, "SCD CHECKPIN %s", serialno);
|
|
|
|
|
line[DIM(line)-1] = 0;
|
2009-07-22 16:08:58 +00:00
|
|
|
|
rc = assuan_transact (agent_ctx, line,
|
|
|
|
|
NULL, NULL,
|
2013-02-07 20:37:58 +01:00
|
|
|
|
default_inq_cb, &dfltparm,
|
|
|
|
|
NULL, NULL);
|
2009-07-22 16:08:58 +00:00
|
|
|
|
status_sc_op_failure (rc);
|
|
|
|
|
return rc;
|
2003-10-21 17:12:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-05-23 16:19:43 +00:00
|
|
|
|
/* Dummy function, only used by the gpg 1.4 implementation. */
|
|
|
|
|
void
|
|
|
|
|
agent_clear_pin_cache (const char *sn)
|
|
|
|
|
{
|
2008-10-20 13:53:23 +00:00
|
|
|
|
(void)sn;
|
2006-05-23 16:19:43 +00:00
|
|
|
|
}
|
2006-10-04 16:45:04 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2007-10-23 18:13:27 +00:00
|
|
|
|
/* Note: All strings shall be UTF-8. On success the caller needs to
|
2006-10-04 16:45:04 +00:00
|
|
|
|
free the string stored at R_PASSPHRASE. On error NULL will be
|
|
|
|
|
stored at R_PASSPHRASE and an appropriate fpf error code
|
|
|
|
|
returned. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
agent_get_passphrase (const char *cache_id,
|
|
|
|
|
const char *err_msg,
|
|
|
|
|
const char *prompt,
|
|
|
|
|
const char *desc_msg,
|
2009-03-17 12:13:32 +00:00
|
|
|
|
int repeat,
|
2009-05-15 19:26:46 +00:00
|
|
|
|
int check,
|
2006-10-04 16:45:04 +00:00
|
|
|
|
char **r_passphrase)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
2009-03-17 17:59:36 +00:00
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
|
|
|
|
char *arg1 = NULL;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
char *arg2 = NULL;
|
|
|
|
|
char *arg3 = NULL;
|
2009-03-17 17:59:36 +00:00
|
|
|
|
char *arg4 = NULL;
|
2006-10-04 16:45:04 +00:00
|
|
|
|
membuf_t data;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
2006-10-04 16:45:04 +00:00
|
|
|
|
|
|
|
|
|
*r_passphrase = NULL;
|
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
rc = start_agent (NULL, 0);
|
2006-10-04 16:45:04 +00:00
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
2006-10-04 16:45:04 +00:00
|
|
|
|
|
2009-03-17 17:59:36 +00:00
|
|
|
|
/* Check that the gpg-agent understands the repeat option. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
if (assuan_transact (agent_ctx,
|
2009-03-17 17:59:36 +00:00
|
|
|
|
"GETINFO cmd_has_option GET_PASSPHRASE repeat",
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL))
|
|
|
|
|
return gpg_error (GPG_ERR_NOT_SUPPORTED);
|
2006-10-04 16:45:04 +00:00
|
|
|
|
|
2009-03-17 17:59:36 +00:00
|
|
|
|
if (cache_id && *cache_id)
|
|
|
|
|
if (!(arg1 = percent_plus_escape (cache_id)))
|
|
|
|
|
goto no_mem;
|
2006-10-04 16:45:04 +00:00
|
|
|
|
if (err_msg && *err_msg)
|
2009-03-17 17:59:36 +00:00
|
|
|
|
if (!(arg2 = percent_plus_escape (err_msg)))
|
|
|
|
|
goto no_mem;
|
2006-10-04 16:45:04 +00:00
|
|
|
|
if (prompt && *prompt)
|
2009-03-17 17:59:36 +00:00
|
|
|
|
if (!(arg3 = percent_plus_escape (prompt)))
|
|
|
|
|
goto no_mem;
|
2006-10-04 16:45:04 +00:00
|
|
|
|
if (desc_msg && *desc_msg)
|
2009-03-17 17:59:36 +00:00
|
|
|
|
if (!(arg4 = percent_plus_escape (desc_msg)))
|
|
|
|
|
goto no_mem;
|
|
|
|
|
|
2011-02-04 12:57:53 +01:00
|
|
|
|
snprintf (line, DIM(line)-1,
|
|
|
|
|
"GET_PASSPHRASE --data --repeat=%d%s -- %s %s %s %s",
|
|
|
|
|
repeat,
|
2009-05-15 19:26:46 +00:00
|
|
|
|
check? " --check --qualitybar":"",
|
2009-03-17 17:59:36 +00:00
|
|
|
|
arg1? arg1:"X",
|
|
|
|
|
arg2? arg2:"X",
|
|
|
|
|
arg3? arg3:"X",
|
|
|
|
|
arg4? arg4:"X");
|
|
|
|
|
line[DIM(line)-1] = 0;
|
|
|
|
|
xfree (arg1);
|
|
|
|
|
xfree (arg2);
|
|
|
|
|
xfree (arg3);
|
|
|
|
|
xfree (arg4);
|
2006-10-04 16:45:04 +00:00
|
|
|
|
|
|
|
|
|
init_membuf_secure (&data, 64);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
rc = assuan_transact (agent_ctx, line,
|
2016-01-08 06:33:27 +01:00
|
|
|
|
put_membuf_cb, &data,
|
2013-02-07 20:37:58 +01:00
|
|
|
|
default_inq_cb, &dfltparm,
|
|
|
|
|
NULL, NULL);
|
2006-10-04 16:45:04 +00:00
|
|
|
|
|
|
|
|
|
if (rc)
|
|
|
|
|
xfree (get_membuf (&data, NULL));
|
2011-02-04 12:57:53 +01:00
|
|
|
|
else
|
2006-10-04 16:45:04 +00:00
|
|
|
|
{
|
|
|
|
|
put_membuf (&data, "", 1);
|
|
|
|
|
*r_passphrase = get_membuf (&data, NULL);
|
|
|
|
|
if (!*r_passphrase)
|
|
|
|
|
rc = gpg_error_from_syserror ();
|
|
|
|
|
}
|
2009-03-17 17:59:36 +00:00
|
|
|
|
return rc;
|
|
|
|
|
no_mem:
|
|
|
|
|
rc = gpg_error_from_syserror ();
|
|
|
|
|
xfree (arg1);
|
|
|
|
|
xfree (arg2);
|
|
|
|
|
xfree (arg3);
|
|
|
|
|
xfree (arg4);
|
2006-10-04 16:45:04 +00:00
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
gpg_error_t
|
|
|
|
|
agent_clear_passphrase (const char *cache_id)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
2006-10-04 16:45:04 +00:00
|
|
|
|
|
|
|
|
|
if (!cache_id || !*cache_id)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
rc = start_agent (NULL, 0);
|
2006-10-04 16:45:04 +00:00
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
2006-10-04 16:45:04 +00:00
|
|
|
|
|
|
|
|
|
snprintf (line, DIM(line)-1, "CLEAR_PASSPHRASE %s", cache_id);
|
|
|
|
|
line[DIM(line)-1] = 0;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
return assuan_transact (agent_ctx, line,
|
|
|
|
|
NULL, NULL,
|
|
|
|
|
default_inq_cb, &dfltparm,
|
|
|
|
|
NULL, NULL);
|
2006-10-04 16:45:04 +00:00
|
|
|
|
}
|
2009-08-11 10:56:44 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Ask the agent to pop up a confirmation dialog with the text DESC
|
|
|
|
|
and an okay and cancel button. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
gpg_agent_get_confirmation (const char *desc)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
char *tmp;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
2009-08-11 10:56:44 +00:00
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
rc = start_agent (NULL, 0);
|
2009-08-11 10:56:44 +00:00
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
2009-08-11 10:56:44 +00:00
|
|
|
|
|
|
|
|
|
tmp = percent_plus_escape (desc);
|
|
|
|
|
if (!tmp)
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
snprintf (line, DIM(line)-1, "GET_CONFIRMATION %s", tmp);
|
|
|
|
|
line[DIM(line)-1] = 0;
|
|
|
|
|
xfree (tmp);
|
|
|
|
|
|
2013-02-07 20:37:58 +01:00
|
|
|
|
rc = assuan_transact (agent_ctx, line,
|
|
|
|
|
NULL, NULL,
|
|
|
|
|
default_inq_cb, &dfltparm,
|
|
|
|
|
NULL, NULL);
|
2009-08-11 10:56:44 +00:00
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-01-08 19:18:49 +00:00
|
|
|
|
/* Return the S2K iteration count as computed by gpg-agent. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
agent_get_s2k_count (unsigned long *r_count)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
membuf_t data;
|
|
|
|
|
char *buf;
|
|
|
|
|
|
|
|
|
|
*r_count = 0;
|
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
err = start_agent (NULL, 0);
|
2010-01-08 19:18:49 +00:00
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
init_membuf (&data, 32);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
err = assuan_transact (agent_ctx, "GETINFO s2k_count",
|
2016-01-08 06:33:27 +01:00
|
|
|
|
put_membuf_cb, &data,
|
2010-01-08 19:18:49 +00:00
|
|
|
|
NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
xfree (get_membuf (&data, NULL));
|
2011-02-04 12:57:53 +01:00
|
|
|
|
else
|
2010-01-08 19:18:49 +00:00
|
|
|
|
{
|
|
|
|
|
put_membuf (&data, "", 1);
|
|
|
|
|
buf = get_membuf (&data, NULL);
|
|
|
|
|
if (!buf)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
*r_count = strtoul (buf, NULL, 10);
|
|
|
|
|
xfree (buf);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
|
|
|
|
|
2010-04-21 16:26:17 +00:00
|
|
|
|
/* Ask the agent whether a secret key for the given public key is
|
|
|
|
|
available. Returns 0 if available. */
|
2010-04-20 17:57:50 +00:00
|
|
|
|
gpg_error_t
|
2010-04-21 16:26:17 +00:00
|
|
|
|
agent_probe_secret_key (ctrl_t ctrl, PKT_public_key *pk)
|
2010-04-20 17:57:50 +00:00
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2010-04-21 16:26:17 +00:00
|
|
|
|
char *hexgrip;
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
|
|
|
|
err = start_agent (ctrl, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
2010-04-21 16:26:17 +00:00
|
|
|
|
err = hexkeygrip_from_pk (pk, &hexgrip);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
2010-04-21 16:26:17 +00:00
|
|
|
|
snprintf (line, sizeof line, "HAVEKEY %s", hexgrip);
|
|
|
|
|
xfree (hexgrip);
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
|
|
|
|
err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-03 21:35:59 +02:00
|
|
|
|
/* Ask the agent whether a secret key is available for any of the
|
2010-10-01 20:33:53 +00:00
|
|
|
|
keys (primary or sub) in KEYBLOCK. Returns 0 if available. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
agent_probe_any_secret_key (ctrl_t ctrl, kbnode_t keyblock)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
|
|
|
|
char *p;
|
|
|
|
|
kbnode_t kbctx, node;
|
|
|
|
|
int nkeys;
|
|
|
|
|
unsigned char grip[20];
|
|
|
|
|
|
|
|
|
|
err = start_agent (ctrl, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
err = gpg_error (GPG_ERR_NO_SECKEY); /* Just in case no key was
|
|
|
|
|
found in KEYBLOCK. */
|
|
|
|
|
p = stpcpy (line, "HAVEKEY");
|
|
|
|
|
for (kbctx=NULL, nkeys=0; (node = walk_kbnode (keyblock, &kbctx, 0)); )
|
|
|
|
|
if (node->pkt->pkttype == PKT_PUBLIC_KEY
|
|
|
|
|
|| node->pkt->pkttype == PKT_PUBLIC_SUBKEY
|
|
|
|
|
|| node->pkt->pkttype == PKT_SECRET_KEY
|
|
|
|
|
|| node->pkt->pkttype == PKT_SECRET_SUBKEY)
|
|
|
|
|
{
|
|
|
|
|
if (nkeys && ((p - line) + 41) > (ASSUAN_LINELENGTH - 2))
|
|
|
|
|
{
|
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err != gpg_err_code (GPG_ERR_NO_SECKEY))
|
|
|
|
|
break; /* Seckey available or unexpected error - ready. */
|
|
|
|
|
p = stpcpy (line, "HAVEKEY");
|
|
|
|
|
nkeys = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = keygrip_from_pk (node->pkt->pkt.public_key, grip);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
*p++ = ' ';
|
|
|
|
|
bin2hex (grip, 20, p);
|
|
|
|
|
p += 40;
|
|
|
|
|
nkeys++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!err && nkeys)
|
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
|
|
|
|
|
2016-06-11 20:42:28 +02:00
|
|
|
|
struct keyinfo_data_parm_s
|
|
|
|
|
{
|
2016-06-10 16:15:33 -04:00
|
|
|
|
char *serialno;
|
|
|
|
|
int cleartext;
|
|
|
|
|
};
|
|
|
|
|
|
2016-06-11 20:42:28 +02:00
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
static gpg_error_t
|
|
|
|
|
keyinfo_status_cb (void *opaque, const char *line)
|
|
|
|
|
{
|
2016-06-11 20:42:28 +02:00
|
|
|
|
struct keyinfo_data_parm_s *data = opaque;
|
2016-06-10 16:15:33 -04:00
|
|
|
|
int is_smartcard;
|
2016-06-11 20:42:28 +02:00
|
|
|
|
char *s;
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
2016-06-10 16:15:33 -04:00
|
|
|
|
if ((s = has_leading_keyword (line, "KEYINFO")) && data)
|
2010-04-20 17:57:50 +00:00
|
|
|
|
{
|
2016-06-11 20:42:28 +02:00
|
|
|
|
/* Parse the arguments:
|
|
|
|
|
* 0 1 2 3 4 5
|
|
|
|
|
* <keygrip> <type> <serialno> <idstr> <cached> <protection>
|
|
|
|
|
*/
|
|
|
|
|
char *fields[6];
|
|
|
|
|
|
|
|
|
|
if (split_fields (s, fields, DIM (fields)) == 6)
|
2010-04-20 17:57:50 +00:00
|
|
|
|
{
|
2016-06-11 20:42:28 +02:00
|
|
|
|
is_smartcard = (fields[1][0] == 'T');
|
|
|
|
|
if (is_smartcard && !data->serialno && strcmp (fields[2], "-"))
|
|
|
|
|
data->serialno = xtrystrdup (fields[2]);
|
|
|
|
|
/* 'P' for protected, 'C' for clear */
|
|
|
|
|
data->cleartext = (fields[5][0] == 'C');
|
2010-04-20 17:57:50 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return the serial number for a secret key. If the returned serial
|
|
|
|
|
number is NULL, the key is not stored on a smartcard. Caller needs
|
2016-06-10 16:15:33 -04:00
|
|
|
|
to free R_SERIALNO.
|
|
|
|
|
|
|
|
|
|
if r_cleartext is not NULL, the referenced int will be set to 1 if
|
|
|
|
|
the agent's copy of the key is stored in the clear, or 0 otherwise
|
|
|
|
|
*/
|
2010-04-20 17:57:50 +00:00
|
|
|
|
gpg_error_t
|
2016-06-10 16:15:33 -04:00
|
|
|
|
agent_get_keyinfo (ctrl_t ctrl, const char *hexkeygrip,
|
|
|
|
|
char **r_serialno, int *r_cleartext)
|
2010-04-20 17:57:50 +00:00
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2016-06-11 20:42:28 +02:00
|
|
|
|
struct keyinfo_data_parm_s keyinfo;
|
|
|
|
|
|
|
|
|
|
memset (&keyinfo, 0,sizeof keyinfo);
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
|
|
|
|
*r_serialno = NULL;
|
|
|
|
|
|
|
|
|
|
err = start_agent (ctrl, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
if (!hexkeygrip || strlen (hexkeygrip) != 40)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
|
|
|
|
|
snprintf (line, DIM(line)-1, "KEYINFO %s", hexkeygrip);
|
|
|
|
|
line[DIM(line)-1] = 0;
|
|
|
|
|
|
|
|
|
|
err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL,
|
2016-06-10 16:15:33 -04:00
|
|
|
|
keyinfo_status_cb, &keyinfo);
|
|
|
|
|
if (!err && keyinfo.serialno)
|
2010-04-20 17:57:50 +00:00
|
|
|
|
{
|
|
|
|
|
/* Sanity check for bad characters. */
|
2016-06-10 16:15:33 -04:00
|
|
|
|
if (strpbrk (keyinfo.serialno, ":\n\r"))
|
2010-04-20 17:57:50 +00:00
|
|
|
|
err = GPG_ERR_INV_VALUE;
|
|
|
|
|
}
|
|
|
|
|
if (err)
|
2016-06-10 16:15:33 -04:00
|
|
|
|
xfree (keyinfo.serialno);
|
2010-04-20 17:57:50 +00:00
|
|
|
|
else
|
2016-06-10 16:15:33 -04:00
|
|
|
|
{
|
|
|
|
|
*r_serialno = keyinfo.serialno;
|
|
|
|
|
if (r_cleartext)
|
|
|
|
|
*r_cleartext = keyinfo.cleartext;
|
|
|
|
|
}
|
2010-04-20 17:57:50 +00:00
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-01 09:48:35 +00:00
|
|
|
|
|
2010-10-01 20:33:53 +00:00
|
|
|
|
/* Status callback for agent_import_key, agent_export_key and
|
|
|
|
|
agent_genkey. */
|
2010-09-01 09:48:35 +00:00
|
|
|
|
static gpg_error_t
|
|
|
|
|
cache_nonce_status_cb (void *opaque, const char *line)
|
|
|
|
|
{
|
2010-10-26 09:10:29 +00:00
|
|
|
|
struct cache_nonce_parm_s *parm = opaque;
|
2016-01-25 11:34:49 +01:00
|
|
|
|
const char *s;
|
2010-09-01 09:48:35 +00:00
|
|
|
|
|
2016-01-25 11:34:49 +01:00
|
|
|
|
if ((s = has_leading_keyword (line, "CACHE_NONCE")))
|
2010-09-01 09:48:35 +00:00
|
|
|
|
{
|
2010-10-26 09:10:29 +00:00
|
|
|
|
if (parm->cache_nonce_addr)
|
|
|
|
|
{
|
|
|
|
|
xfree (*parm->cache_nonce_addr);
|
2016-01-25 11:34:49 +01:00
|
|
|
|
*parm->cache_nonce_addr = xtrystrdup (s);
|
2010-10-26 09:10:29 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2016-01-25 11:34:49 +01:00
|
|
|
|
else if ((s = has_leading_keyword (line, "PASSWD_NONCE")))
|
2010-10-26 09:10:29 +00:00
|
|
|
|
{
|
|
|
|
|
if (parm->passwd_nonce_addr)
|
2010-09-01 09:48:35 +00:00
|
|
|
|
{
|
2010-10-26 09:10:29 +00:00
|
|
|
|
xfree (*parm->passwd_nonce_addr);
|
2016-01-25 11:34:49 +01:00
|
|
|
|
*parm->passwd_nonce_addr = xtrystrdup (s);
|
2010-09-01 09:48:35 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2016-01-25 11:34:49 +01:00
|
|
|
|
else if ((s = has_leading_keyword (line, "PROGRESS")))
|
|
|
|
|
{
|
|
|
|
|
if (opt.enable_progress_filter)
|
|
|
|
|
write_status_text (STATUS_PROGRESS, s);
|
|
|
|
|
}
|
2010-09-01 09:48:35 +00:00
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Handle a KEYPARMS inquiry. Note, we only send the data,
|
|
|
|
|
assuan_transact takes care of flushing and writing the end */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
inq_genkey_parms (void *opaque, const char *line)
|
|
|
|
|
{
|
2011-02-04 12:57:53 +01:00
|
|
|
|
struct genkey_parm_s *parm = opaque;
|
2010-04-20 17:57:50 +00:00
|
|
|
|
gpg_error_t err;
|
|
|
|
|
|
Use has_leading_keyword in the assuan callbacks.
* agent/call-pinentry.c (inq_quality): Use has_leading_keyword.
* agent/call-scd.c (inq_needpin, inq_writekey_parms): Ditto.
* g10/call-agent.c (inq_writecert_parms, keyinfo_status_cb): Ditto.
(inq_genkey_parms, inq_ciphertext_cb, inq_import_key_parms): Ditto.
* g10/call-dirmngr.c (ks_put_inq_cb): Ditto.
* sm/call-agent.c (default_inq_cb, inq_ciphertext_cb): Ditto.
(inq_genkey_parms, istrusted_status_cb, learn_status_cb): Ditto.
(keyinfo_status_cb, inq_import_key_parms): Ditto.
* sm/call-dirmngr.c (inq_certificate, isvalid_status_cb): Ditto.
(lookup_status_cb, run_command_inq_cb, run_command_status_cb): Ditto.
2013-02-22 10:56:13 +01:00
|
|
|
|
if (has_leading_keyword (line, "KEYPARAM"))
|
2010-04-20 17:57:50 +00:00
|
|
|
|
{
|
2013-02-07 20:37:58 +01:00
|
|
|
|
err = assuan_send_data (parm->dflt->ctx,
|
2010-04-20 17:57:50 +00:00
|
|
|
|
parm->keyparms, strlen (parm->keyparms));
|
|
|
|
|
}
|
2015-01-21 11:31:20 +01:00
|
|
|
|
else if (has_leading_keyword (line, "NEWPASSWD") && parm->passphrase)
|
|
|
|
|
{
|
|
|
|
|
err = assuan_send_data (parm->dflt->ctx,
|
|
|
|
|
parm->passphrase, strlen (parm->passphrase));
|
|
|
|
|
}
|
2010-04-20 17:57:50 +00:00
|
|
|
|
else
|
2013-02-07 20:37:58 +01:00
|
|
|
|
err = default_inq_cb (parm->dflt, line);
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
2011-02-04 12:57:53 +01:00
|
|
|
|
return err;
|
2010-04-20 17:57:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Call the agent to generate a new key. KEYPARMS is the usual
|
|
|
|
|
S-expression giving the parameters of the key. gpg-agent passes it
|
2010-10-14 16:34:31 +00:00
|
|
|
|
gcry_pk_genkey. If NO_PROTECTION is true the agent is advised not
|
2015-01-21 11:31:20 +01:00
|
|
|
|
to protect the generated key. If NO_PROTECTION is not set and
|
|
|
|
|
PASSPHRASE is not NULL the agent is requested to protect the key
|
|
|
|
|
with that passphrase instead of asking for one. */
|
2010-04-20 17:57:50 +00:00
|
|
|
|
gpg_error_t
|
2016-06-02 21:21:08 +02:00
|
|
|
|
agent_genkey (ctrl_t ctrl, char **cache_nonce_addr, char **passwd_nonce_addr,
|
2015-01-21 11:31:20 +01:00
|
|
|
|
const char *keyparms, int no_protection,
|
|
|
|
|
const char *passphrase, gcry_sexp_t *r_pubkey)
|
2010-04-20 17:57:50 +00:00
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
struct genkey_parm_s gk_parm;
|
2010-10-26 09:10:29 +00:00
|
|
|
|
struct cache_nonce_parm_s cn_parm;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
2010-04-20 17:57:50 +00:00
|
|
|
|
membuf_t data;
|
|
|
|
|
size_t len;
|
|
|
|
|
unsigned char *buf;
|
2010-09-01 09:48:35 +00:00
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
2013-02-07 20:37:58 +01:00
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
|
|
|
|
dfltparm.ctrl = ctrl;
|
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
*r_pubkey = NULL;
|
|
|
|
|
err = start_agent (ctrl, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
2016-06-02 21:21:08 +02:00
|
|
|
|
if (passwd_nonce_addr && *passwd_nonce_addr)
|
|
|
|
|
; /* A RESET would flush the passwd nonce cache. */
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
err = assuan_transact (agent_ctx, "RESET",
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
|
|
|
|
init_membuf (&data, 1024);
|
2013-02-07 20:37:58 +01:00
|
|
|
|
gk_parm.dflt = &dfltparm;
|
2010-04-20 17:57:50 +00:00
|
|
|
|
gk_parm.keyparms = keyparms;
|
2015-01-21 11:31:20 +01:00
|
|
|
|
gk_parm.passphrase = passphrase;
|
2016-06-02 21:21:08 +02:00
|
|
|
|
snprintf (line, sizeof line, "GENKEY%s%s%s%s%s",
|
2015-01-21 11:31:20 +01:00
|
|
|
|
no_protection? " --no-protection" :
|
|
|
|
|
passphrase ? " --inq-passwd" :
|
|
|
|
|
/* */ "",
|
2016-06-02 21:21:08 +02:00
|
|
|
|
passwd_nonce_addr && *passwd_nonce_addr? " --passwd-nonce=":"",
|
|
|
|
|
passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
|
2010-09-01 09:48:35 +00:00
|
|
|
|
cache_nonce_addr && *cache_nonce_addr? " ":"",
|
|
|
|
|
cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
|
2010-10-26 09:10:29 +00:00
|
|
|
|
cn_parm.cache_nonce_addr = cache_nonce_addr;
|
|
|
|
|
cn_parm.passwd_nonce_addr = NULL;
|
2010-09-01 09:48:35 +00:00
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
2016-01-08 06:33:27 +01:00
|
|
|
|
put_membuf_cb, &data,
|
2011-02-04 12:57:53 +01:00
|
|
|
|
inq_genkey_parms, &gk_parm,
|
2010-10-26 09:10:29 +00:00
|
|
|
|
cache_nonce_status_cb, &cn_parm);
|
2010-04-20 17:57:50 +00:00
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
xfree (get_membuf (&data, &len));
|
|
|
|
|
return err;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2010-04-20 17:57:50 +00:00
|
|
|
|
buf = get_membuf (&data, &len);
|
|
|
|
|
if (!buf)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
err = gcry_sexp_sscan (r_pubkey, NULL, buf, len);
|
|
|
|
|
xfree (buf);
|
|
|
|
|
}
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2011-11-06 17:01:31 +01:00
|
|
|
|
/* Call the agent to read the public key part for a given keygrip. If
|
2010-04-20 17:57:50 +00:00
|
|
|
|
FROMCARD is true, the key is directly read from the current
|
|
|
|
|
smartcard. In this case HEXKEYGRIP should be the keyID
|
|
|
|
|
(e.g. OPENPGP.3). */
|
2011-11-06 17:01:31 +01:00
|
|
|
|
gpg_error_t
|
|
|
|
|
agent_readkey (ctrl_t ctrl, int fromcard, const char *hexkeygrip,
|
|
|
|
|
unsigned char **r_pubkey)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
membuf_t data;
|
|
|
|
|
size_t len;
|
|
|
|
|
unsigned char *buf;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
|
|
|
|
dfltparm.ctrl = ctrl;
|
2011-11-06 17:01:31 +01:00
|
|
|
|
|
|
|
|
|
*r_pubkey = NULL;
|
|
|
|
|
err = start_agent (ctrl, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
2011-11-06 17:01:31 +01:00
|
|
|
|
|
|
|
|
|
err = assuan_transact (agent_ctx, "RESET",NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
snprintf (line, DIM(line)-1, "%sREADKEY %s", fromcard? "SCD ":"", hexkeygrip);
|
|
|
|
|
|
|
|
|
|
init_membuf (&data, 1024);
|
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
2016-01-08 06:33:27 +01:00
|
|
|
|
put_membuf_cb, &data,
|
2013-02-07 20:37:58 +01:00
|
|
|
|
default_inq_cb, &dfltparm,
|
|
|
|
|
NULL, NULL);
|
2011-11-06 17:01:31 +01:00
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
xfree (get_membuf (&data, &len));
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
buf = get_membuf (&data, &len);
|
|
|
|
|
if (!buf)
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
|
|
|
|
|
{
|
|
|
|
|
xfree (buf);
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
}
|
|
|
|
|
*r_pubkey = buf;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Call the agent to do a sign operation using the key identified by
|
|
|
|
|
the hex string KEYGRIP. DESC is a description of the key to be
|
|
|
|
|
displayed if the agent needs to ask for the PIN. DIGEST and
|
|
|
|
|
DIGESTLEN is the hash value to sign and DIGESTALGO the algorithm id
|
2010-09-01 12:49:05 +00:00
|
|
|
|
used to compute the digest. If CACHE_NONCE is used the agent is
|
2010-10-26 09:10:29 +00:00
|
|
|
|
advised to first try a passphrase associated with that nonce. */
|
2010-04-20 17:57:50 +00:00
|
|
|
|
gpg_error_t
|
2010-09-01 12:49:05 +00:00
|
|
|
|
agent_pksign (ctrl_t ctrl, const char *cache_nonce,
|
|
|
|
|
const char *keygrip, const char *desc,
|
2013-02-07 20:37:58 +01:00
|
|
|
|
u32 *keyid, u32 *mainkeyid, int pubkey_algo,
|
2010-04-20 17:57:50 +00:00
|
|
|
|
unsigned char *digest, size_t digestlen, int digestalgo,
|
|
|
|
|
gcry_sexp_t *r_sigval)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
2010-10-18 13:54:42 +00:00
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2010-04-20 17:57:50 +00:00
|
|
|
|
membuf_t data;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
|
|
|
|
dfltparm.ctrl = ctrl;
|
|
|
|
|
dfltparm.keyinfo.keyid = keyid;
|
|
|
|
|
dfltparm.keyinfo.mainkeyid = mainkeyid;
|
|
|
|
|
dfltparm.keyinfo.pubkey_algo = pubkey_algo;
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
|
|
|
|
*r_sigval = NULL;
|
|
|
|
|
err = start_agent (ctrl, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
2010-04-20 17:57:50 +00:00
|
|
|
|
|
|
|
|
|
if (digestlen*2 + 50 > DIM(line))
|
|
|
|
|
return gpg_error (GPG_ERR_GENERAL);
|
|
|
|
|
|
|
|
|
|
err = assuan_transact (agent_ctx, "RESET",
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
snprintf (line, DIM(line)-1, "SIGKEY %s", keygrip);
|
|
|
|
|
line[DIM(line)-1] = 0;
|
|
|
|
|
err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
if (desc)
|
|
|
|
|
{
|
|
|
|
|
snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
|
|
|
|
|
line[DIM(line)-1] = 0;
|
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
snprintf (line, sizeof line, "SETHASH %d ", digestalgo);
|
2010-10-18 13:54:42 +00:00
|
|
|
|
bin2hex (digest, digestlen, line + strlen (line));
|
2010-04-20 17:57:50 +00:00
|
|
|
|
err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
init_membuf (&data, 1024);
|
2010-09-01 12:49:05 +00:00
|
|
|
|
|
|
|
|
|
snprintf (line, sizeof line, "PKSIGN%s%s",
|
|
|
|
|
cache_nonce? " -- ":"",
|
|
|
|
|
cache_nonce? cache_nonce:"");
|
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
2016-01-08 06:33:27 +01:00
|
|
|
|
put_membuf_cb, &data,
|
2013-02-07 20:37:58 +01:00
|
|
|
|
default_inq_cb, &dfltparm,
|
|
|
|
|
NULL, NULL);
|
2010-04-20 17:57:50 +00:00
|
|
|
|
if (err)
|
|
|
|
|
xfree (get_membuf (&data, NULL));
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
unsigned char *buf;
|
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
|
|
buf = get_membuf (&data, &len);
|
|
|
|
|
if (!buf)
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
err = gcry_sexp_sscan (r_sigval, NULL, buf, len);
|
|
|
|
|
xfree (buf);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-23 11:36:59 +00:00
|
|
|
|
|
|
|
|
|
/* Handle a CIPHERTEXT inquiry. Note, we only send the data,
|
|
|
|
|
assuan_transact takes care of flushing and writing the END. */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
inq_ciphertext_cb (void *opaque, const char *line)
|
|
|
|
|
{
|
2011-02-04 12:57:53 +01:00
|
|
|
|
struct cipher_parm_s *parm = opaque;
|
2010-04-23 11:36:59 +00:00
|
|
|
|
int rc;
|
|
|
|
|
|
Use has_leading_keyword in the assuan callbacks.
* agent/call-pinentry.c (inq_quality): Use has_leading_keyword.
* agent/call-scd.c (inq_needpin, inq_writekey_parms): Ditto.
* g10/call-agent.c (inq_writecert_parms, keyinfo_status_cb): Ditto.
(inq_genkey_parms, inq_ciphertext_cb, inq_import_key_parms): Ditto.
* g10/call-dirmngr.c (ks_put_inq_cb): Ditto.
* sm/call-agent.c (default_inq_cb, inq_ciphertext_cb): Ditto.
(inq_genkey_parms, istrusted_status_cb, learn_status_cb): Ditto.
(keyinfo_status_cb, inq_import_key_parms): Ditto.
* sm/call-dirmngr.c (inq_certificate, isvalid_status_cb): Ditto.
(lookup_status_cb, run_command_inq_cb, run_command_status_cb): Ditto.
2013-02-22 10:56:13 +01:00
|
|
|
|
if (has_leading_keyword (line, "CIPHERTEXT"))
|
2010-04-23 11:36:59 +00:00
|
|
|
|
{
|
|
|
|
|
assuan_begin_confidential (parm->ctx);
|
2013-02-07 20:37:58 +01:00
|
|
|
|
rc = assuan_send_data (parm->dflt->ctx,
|
|
|
|
|
parm->ciphertext, parm->ciphertextlen);
|
2010-04-23 11:36:59 +00:00
|
|
|
|
assuan_end_confidential (parm->ctx);
|
|
|
|
|
}
|
|
|
|
|
else
|
2013-02-07 20:37:58 +01:00
|
|
|
|
rc = default_inq_cb (parm->dflt, line);
|
2010-04-23 11:36:59 +00:00
|
|
|
|
|
2011-02-04 12:57:53 +01:00
|
|
|
|
return rc;
|
2010-04-23 11:36:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-08-26 17:29:54 +02:00
|
|
|
|
/* Check whether there is any padding info from the agent. */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
padding_info_cb (void *opaque, const char *line)
|
|
|
|
|
{
|
|
|
|
|
int *r_padding = opaque;
|
|
|
|
|
const char *s;
|
|
|
|
|
|
|
|
|
|
if ((s=has_leading_keyword (line, "PADDING")))
|
|
|
|
|
{
|
|
|
|
|
*r_padding = atoi (s);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-23 11:36:59 +00:00
|
|
|
|
/* Call the agent to do a decrypt operation using the key identified
|
|
|
|
|
by the hex string KEYGRIP and the input data S_CIPHERTEXT. On the
|
|
|
|
|
success the decoded value is stored verbatim at R_BUF and its
|
2013-02-07 20:37:58 +01:00
|
|
|
|
length at R_BUF; the callers needs to release it. KEYID, MAINKEYID
|
|
|
|
|
and PUBKEY_ALGO are used to construct additional promots or status
|
2013-08-26 17:29:54 +02:00
|
|
|
|
messages. The padding information is stored at R_PADDING with -1
|
|
|
|
|
for not known. */
|
2010-04-23 11:36:59 +00:00
|
|
|
|
gpg_error_t
|
|
|
|
|
agent_pkdecrypt (ctrl_t ctrl, const char *keygrip, const char *desc,
|
2013-02-07 20:37:58 +01:00
|
|
|
|
u32 *keyid, u32 *mainkeyid, int pubkey_algo,
|
2010-04-23 11:36:59 +00:00
|
|
|
|
gcry_sexp_t s_ciphertext,
|
2013-08-26 17:29:54 +02:00
|
|
|
|
unsigned char **r_buf, size_t *r_buflen, int *r_padding)
|
2010-04-23 11:36:59 +00:00
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
|
|
|
|
membuf_t data;
|
|
|
|
|
size_t n, len;
|
|
|
|
|
char *p, *buf, *endp;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
|
|
|
|
dfltparm.ctrl = ctrl;
|
|
|
|
|
dfltparm.keyinfo.keyid = keyid;
|
|
|
|
|
dfltparm.keyinfo.mainkeyid = mainkeyid;
|
|
|
|
|
dfltparm.keyinfo.pubkey_algo = pubkey_algo;
|
2011-01-05 17:33:17 -08:00
|
|
|
|
|
2013-08-26 17:29:54 +02:00
|
|
|
|
if (!keygrip || strlen(keygrip) != 40
|
|
|
|
|
|| !s_ciphertext || !r_buf || !r_buflen || !r_padding)
|
2010-04-23 11:36:59 +00:00
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
2013-08-26 17:29:54 +02:00
|
|
|
|
|
2010-04-23 11:36:59 +00:00
|
|
|
|
*r_buf = NULL;
|
2013-08-26 17:29:54 +02:00
|
|
|
|
*r_padding = -1;
|
2010-04-23 11:36:59 +00:00
|
|
|
|
|
|
|
|
|
err = start_agent (ctrl, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
2010-04-23 11:36:59 +00:00
|
|
|
|
|
|
|
|
|
err = assuan_transact (agent_ctx, "RESET",
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
snprintf (line, sizeof line, "SETKEY %s", keygrip);
|
|
|
|
|
err = assuan_transact (agent_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
if (desc)
|
|
|
|
|
{
|
|
|
|
|
snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
|
|
|
|
|
line[DIM(line)-1] = 0;
|
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
init_membuf_secure (&data, 1024);
|
|
|
|
|
{
|
|
|
|
|
struct cipher_parm_s parm;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2013-02-07 20:37:58 +01:00
|
|
|
|
parm.dflt = &dfltparm;
|
2010-04-23 11:36:59 +00:00
|
|
|
|
parm.ctx = agent_ctx;
|
|
|
|
|
err = make_canon_sexp (s_ciphertext, &parm.ciphertext, &parm.ciphertextlen);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
err = assuan_transact (agent_ctx, "PKDECRYPT",
|
2016-01-08 06:33:27 +01:00
|
|
|
|
put_membuf_cb, &data,
|
2013-08-26 17:29:54 +02:00
|
|
|
|
inq_ciphertext_cb, &parm,
|
|
|
|
|
padding_info_cb, r_padding);
|
2010-04-23 11:36:59 +00:00
|
|
|
|
xfree (parm.ciphertext);
|
|
|
|
|
}
|
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
xfree (get_membuf (&data, &len));
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
put_membuf (&data, "", 1); /* Make sure it is 0 terminated. */
|
|
|
|
|
buf = get_membuf (&data, &len);
|
|
|
|
|
if (!buf)
|
|
|
|
|
return gpg_error_from_syserror ();
|
2016-04-29 11:05:24 +02:00
|
|
|
|
log_assert (len); /* (we forced Nul termination.) */
|
2010-04-23 11:36:59 +00:00
|
|
|
|
|
|
|
|
|
if (*buf != '(')
|
|
|
|
|
{
|
|
|
|
|
xfree (buf);
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (len < 13 || memcmp (buf, "(5:value", 8) ) /* "(5:valueN:D)\0" */
|
|
|
|
|
{
|
|
|
|
|
xfree (buf);
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
}
|
2014-04-28 10:36:16 +09:00
|
|
|
|
len -= 10; /* Count only the data of the second part. */
|
2010-04-23 11:36:59 +00:00
|
|
|
|
p = buf + 8; /* Skip leading parenthesis and the value tag. */
|
|
|
|
|
|
|
|
|
|
n = strtoul (p, &endp, 10);
|
|
|
|
|
if (!n || *endp != ':')
|
|
|
|
|
{
|
|
|
|
|
xfree (buf);
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP);
|
|
|
|
|
}
|
|
|
|
|
endp++;
|
|
|
|
|
if (endp-p+n > len)
|
|
|
|
|
{
|
|
|
|
|
xfree (buf);
|
|
|
|
|
return gpg_error (GPG_ERR_INV_SEXP); /* Oops: Inconsistent S-Exp. */
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2010-04-23 11:36:59 +00:00
|
|
|
|
memmove (buf, endp, n);
|
|
|
|
|
|
|
|
|
|
*r_buflen = n;
|
|
|
|
|
*r_buf = buf;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2010-08-31 15:58:39 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Retrieve a key encryption key from the agent. With FOREXPORT true
|
|
|
|
|
the key shall be used for export, with false for import. On success
|
|
|
|
|
the new key is stored at R_KEY and its length at R_KEKLEN. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
agent_keywrap_key (ctrl_t ctrl, int forexport, void **r_kek, size_t *r_keklen)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
membuf_t data;
|
|
|
|
|
size_t len;
|
|
|
|
|
unsigned char *buf;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
|
|
|
|
dfltparm.ctrl = ctrl;
|
2010-08-31 15:58:39 +00:00
|
|
|
|
|
|
|
|
|
*r_kek = NULL;
|
|
|
|
|
err = start_agent (ctrl, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
2010-08-31 15:58:39 +00:00
|
|
|
|
|
|
|
|
|
snprintf (line, DIM(line)-1, "KEYWRAP_KEY %s",
|
|
|
|
|
forexport? "--export":"--import");
|
|
|
|
|
|
|
|
|
|
init_membuf_secure (&data, 64);
|
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
2016-01-08 06:33:27 +01:00
|
|
|
|
put_membuf_cb, &data,
|
2013-02-07 20:37:58 +01:00
|
|
|
|
default_inq_cb, &dfltparm,
|
|
|
|
|
NULL, NULL);
|
2010-08-31 15:58:39 +00:00
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
xfree (get_membuf (&data, &len));
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
buf = get_membuf (&data, &len);
|
|
|
|
|
if (!buf)
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
*r_kek = buf;
|
|
|
|
|
*r_keklen = len;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Handle the inquiry for an IMPORT_KEY command. */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
inq_import_key_parms (void *opaque, const char *line)
|
|
|
|
|
{
|
2011-02-04 12:57:53 +01:00
|
|
|
|
struct import_key_parm_s *parm = opaque;
|
2010-08-31 15:58:39 +00:00
|
|
|
|
gpg_error_t err;
|
|
|
|
|
|
Use has_leading_keyword in the assuan callbacks.
* agent/call-pinentry.c (inq_quality): Use has_leading_keyword.
* agent/call-scd.c (inq_needpin, inq_writekey_parms): Ditto.
* g10/call-agent.c (inq_writecert_parms, keyinfo_status_cb): Ditto.
(inq_genkey_parms, inq_ciphertext_cb, inq_import_key_parms): Ditto.
* g10/call-dirmngr.c (ks_put_inq_cb): Ditto.
* sm/call-agent.c (default_inq_cb, inq_ciphertext_cb): Ditto.
(inq_genkey_parms, istrusted_status_cb, learn_status_cb): Ditto.
(keyinfo_status_cb, inq_import_key_parms): Ditto.
* sm/call-dirmngr.c (inq_certificate, isvalid_status_cb): Ditto.
(lookup_status_cb, run_command_inq_cb, run_command_status_cb): Ditto.
2013-02-22 10:56:13 +01:00
|
|
|
|
if (has_leading_keyword (line, "KEYDATA"))
|
2010-08-31 15:58:39 +00:00
|
|
|
|
{
|
2013-02-07 20:37:58 +01:00
|
|
|
|
err = assuan_send_data (parm->dflt->ctx, parm->key, parm->keylen);
|
2010-08-31 15:58:39 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
2013-02-07 20:37:58 +01:00
|
|
|
|
err = default_inq_cb (parm->dflt, line);
|
2010-08-31 15:58:39 +00:00
|
|
|
|
|
2011-02-04 12:57:53 +01:00
|
|
|
|
return err;
|
2010-08-31 15:58:39 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Call the agent to import a key into the agent. */
|
|
|
|
|
gpg_error_t
|
2010-09-01 09:48:35 +00:00
|
|
|
|
agent_import_key (ctrl_t ctrl, const char *desc, char **cache_nonce_addr,
|
2015-12-24 14:15:58 +09:00
|
|
|
|
const void *key, size_t keylen, int unattended, int force)
|
2010-08-31 15:58:39 +00:00
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
struct import_key_parm_s parm;
|
2010-10-26 09:10:29 +00:00
|
|
|
|
struct cache_nonce_parm_s cn_parm;
|
2010-09-01 09:48:35 +00:00
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
|
|
|
|
dfltparm.ctrl = ctrl;
|
2010-08-31 15:58:39 +00:00
|
|
|
|
|
|
|
|
|
err = start_agent (ctrl, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
2010-08-31 15:58:39 +00:00
|
|
|
|
|
|
|
|
|
if (desc)
|
|
|
|
|
{
|
|
|
|
|
snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
|
|
|
|
|
line[DIM(line)-1] = 0;
|
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-07 20:37:58 +01:00
|
|
|
|
parm.dflt = &dfltparm;
|
2010-08-31 15:58:39 +00:00
|
|
|
|
parm.key = key;
|
|
|
|
|
parm.keylen = keylen;
|
|
|
|
|
|
2015-12-24 14:15:58 +09:00
|
|
|
|
snprintf (line, sizeof line, "IMPORT_KEY%s%s%s%s",
|
2013-05-22 09:50:12 +01:00
|
|
|
|
unattended? " --unattended":"",
|
2015-12-24 14:15:58 +09:00
|
|
|
|
force? " --force":"",
|
2010-09-01 09:48:35 +00:00
|
|
|
|
cache_nonce_addr && *cache_nonce_addr? " ":"",
|
|
|
|
|
cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"");
|
2010-10-26 09:10:29 +00:00
|
|
|
|
cn_parm.cache_nonce_addr = cache_nonce_addr;
|
|
|
|
|
cn_parm.passwd_nonce_addr = NULL;
|
2010-09-01 09:48:35 +00:00
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
2013-02-07 20:37:58 +01:00
|
|
|
|
NULL, NULL,
|
|
|
|
|
inq_import_key_parms, &parm,
|
2010-10-26 09:10:29 +00:00
|
|
|
|
cache_nonce_status_cb, &cn_parm);
|
2010-08-31 15:58:39 +00:00
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-10-01 20:33:53 +00:00
|
|
|
|
|
|
|
|
|
/* Receive a secret key from the agent. HEXKEYGRIP is the hexified
|
|
|
|
|
keygrip, DESC a prompt to be displayed with the agent's passphrase
|
2016-06-10 16:15:34 -04:00
|
|
|
|
question (needs to be plus+percent escaped). if OPENPGP_PROTECTED
|
|
|
|
|
is not zero, ensure that the key material is returned in RFC
|
|
|
|
|
4880-compatible passphrased-protected form. If CACHE_NONCE_ADDR is
|
|
|
|
|
not NULL the agent is advised to first try a passphrase associated
|
|
|
|
|
with that nonce. On success the key is stored as a canonical
|
|
|
|
|
S-expression at R_RESULT and R_RESULTLEN. */
|
2010-10-01 20:33:53 +00:00
|
|
|
|
gpg_error_t
|
|
|
|
|
agent_export_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
|
2016-06-10 16:15:34 -04:00
|
|
|
|
int openpgp_protected, char **cache_nonce_addr,
|
2010-10-01 20:33:53 +00:00
|
|
|
|
unsigned char **r_result, size_t *r_resultlen)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
2010-10-26 09:10:29 +00:00
|
|
|
|
struct cache_nonce_parm_s cn_parm;
|
2010-10-01 20:33:53 +00:00
|
|
|
|
membuf_t data;
|
|
|
|
|
size_t len;
|
|
|
|
|
unsigned char *buf;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
|
|
|
|
dfltparm.ctrl = ctrl;
|
2010-10-01 20:33:53 +00:00
|
|
|
|
|
|
|
|
|
*r_result = NULL;
|
|
|
|
|
|
|
|
|
|
err = start_agent (ctrl, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
2010-10-01 20:33:53 +00:00
|
|
|
|
|
|
|
|
|
if (desc)
|
|
|
|
|
{
|
|
|
|
|
snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
|
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-10 16:15:34 -04:00
|
|
|
|
snprintf (line, DIM(line)-1, "EXPORT_KEY %s%s%s %s",
|
|
|
|
|
openpgp_protected ? "--openpgp ":"",
|
2010-10-01 20:33:53 +00:00
|
|
|
|
cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
|
|
|
|
|
cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
|
|
|
|
|
hexkeygrip);
|
|
|
|
|
|
|
|
|
|
init_membuf_secure (&data, 1024);
|
2010-10-26 09:10:29 +00:00
|
|
|
|
cn_parm.cache_nonce_addr = cache_nonce_addr;
|
|
|
|
|
cn_parm.passwd_nonce_addr = NULL;
|
2010-10-01 20:33:53 +00:00
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
2016-01-08 06:33:27 +01:00
|
|
|
|
put_membuf_cb, &data,
|
2013-02-07 20:37:58 +01:00
|
|
|
|
default_inq_cb, &dfltparm,
|
2010-10-26 09:10:29 +00:00
|
|
|
|
cache_nonce_status_cb, &cn_parm);
|
2010-10-01 20:33:53 +00:00
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
xfree (get_membuf (&data, &len));
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
buf = get_membuf (&data, &len);
|
|
|
|
|
if (!buf)
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
*r_result = buf;
|
|
|
|
|
*r_resultlen = len;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2010-10-26 09:10:29 +00:00
|
|
|
|
|
|
|
|
|
|
2014-04-15 16:40:48 +02:00
|
|
|
|
|
|
|
|
|
/* Ask the agent to delete the key identified by HEXKEYGRIP. If DESC
|
|
|
|
|
is not NULL, display DESC instead of the default description
|
2016-05-10 11:01:42 +02:00
|
|
|
|
message. If FORCE is true the agent is advised not to ask for
|
|
|
|
|
confirmation. */
|
2014-04-15 16:40:48 +02:00
|
|
|
|
gpg_error_t
|
2016-05-10 11:01:42 +02:00
|
|
|
|
agent_delete_key (ctrl_t ctrl, const char *hexkeygrip, const char *desc,
|
|
|
|
|
int force)
|
2014-04-15 16:40:48 +02:00
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
|
|
|
|
dfltparm.ctrl = ctrl;
|
|
|
|
|
|
|
|
|
|
err = start_agent (ctrl, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
if (!hexkeygrip || strlen (hexkeygrip) != 40)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
|
|
|
|
|
if (desc)
|
|
|
|
|
{
|
|
|
|
|
snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
|
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-10 11:01:42 +02:00
|
|
|
|
snprintf (line, DIM(line)-1, "DELETE_KEY%s %s",
|
|
|
|
|
force? " --force":"", hexkeygrip);
|
2014-04-15 16:40:48 +02:00
|
|
|
|
err = assuan_transact (agent_ctx, line, NULL, NULL,
|
|
|
|
|
default_inq_cb, &dfltparm,
|
|
|
|
|
NULL, NULL);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-10-26 09:10:29 +00:00
|
|
|
|
|
|
|
|
|
/* Ask the agent to change the passphrase of the key identified by
|
2016-06-02 21:21:08 +02:00
|
|
|
|
* HEXKEYGRIP. If DESC is not NULL, display DESC instead of the
|
|
|
|
|
* default description message. If CACHE_NONCE_ADDR is not NULL the
|
|
|
|
|
* agent is advised to first try a passphrase associated with that
|
|
|
|
|
* nonce. If PASSWD_NONCE_ADDR is not NULL the agent will try to use
|
|
|
|
|
* the passphrase associated with that nonce for the new passphrase.
|
|
|
|
|
* If VERIFY is true the passphrase is only verified. */
|
2010-10-26 09:10:29 +00:00
|
|
|
|
gpg_error_t
|
2016-06-02 21:21:08 +02:00
|
|
|
|
agent_passwd (ctrl_t ctrl, const char *hexkeygrip, const char *desc, int verify,
|
2010-10-26 09:10:29 +00:00
|
|
|
|
char **cache_nonce_addr, char **passwd_nonce_addr)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
struct cache_nonce_parm_s cn_parm;
|
|
|
|
|
char line[ASSUAN_LINELENGTH];
|
2013-02-07 20:37:58 +01:00
|
|
|
|
struct default_inq_parm_s dfltparm;
|
|
|
|
|
|
|
|
|
|
memset (&dfltparm, 0, sizeof dfltparm);
|
|
|
|
|
dfltparm.ctrl = ctrl;
|
2010-10-26 09:10:29 +00:00
|
|
|
|
|
|
|
|
|
err = start_agent (ctrl, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2013-02-07 20:37:58 +01:00
|
|
|
|
dfltparm.ctx = agent_ctx;
|
2010-10-26 09:10:29 +00:00
|
|
|
|
|
|
|
|
|
if (!hexkeygrip || strlen (hexkeygrip) != 40)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
|
|
|
|
|
if (desc)
|
|
|
|
|
{
|
|
|
|
|
snprintf (line, DIM(line)-1, "SETKEYDESC %s", desc);
|
|
|
|
|
err = assuan_transact (agent_ctx, line,
|
|
|
|
|
NULL, NULL, NULL, NULL, NULL, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-02 21:21:08 +02:00
|
|
|
|
if (verify)
|
|
|
|
|
snprintf (line, DIM(line)-1, "PASSWD %s%s --verify %s",
|
|
|
|
|
cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
|
|
|
|
|
cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
|
|
|
|
|
hexkeygrip);
|
|
|
|
|
else
|
|
|
|
|
snprintf (line, DIM(line)-1, "PASSWD %s%s %s%s %s",
|
|
|
|
|
cache_nonce_addr && *cache_nonce_addr? "--cache-nonce=":"",
|
|
|
|
|
cache_nonce_addr && *cache_nonce_addr? *cache_nonce_addr:"",
|
|
|
|
|
passwd_nonce_addr && *passwd_nonce_addr? "--passwd-nonce=":"",
|
|
|
|
|
passwd_nonce_addr && *passwd_nonce_addr? *passwd_nonce_addr:"",
|
|
|
|
|
hexkeygrip);
|
2010-10-26 09:10:29 +00:00
|
|
|
|
cn_parm.cache_nonce_addr = cache_nonce_addr;
|
|
|
|
|
cn_parm.passwd_nonce_addr = passwd_nonce_addr;
|
|
|
|
|
err = assuan_transact (agent_ctx, line, NULL, NULL,
|
2013-02-07 20:37:58 +01:00
|
|
|
|
default_inq_cb, &dfltparm,
|
2010-10-26 09:10:29 +00:00
|
|
|
|
cache_nonce_status_cb, &cn_parm);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
2014-09-19 19:38:13 +02:00
|
|
|
|
|
2016-06-02 21:21:08 +02:00
|
|
|
|
|
2014-09-19 19:38:13 +02:00
|
|
|
|
/* Return the version reported by gpg-agent. */
|
|
|
|
|
gpg_error_t
|
|
|
|
|
agent_get_version (ctrl_t ctrl, char **r_version)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
|
|
|
|
|
err = start_agent (ctrl, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
2016-01-08 06:42:29 +01:00
|
|
|
|
err = get_assuan_server_version (agent_ctx, 0, r_version);
|
2014-09-19 19:38:13 +02:00
|
|
|
|
return err;
|
|
|
|
|
}
|