2003-08-05 19:11:04 +02:00
|
|
|
|
/* app-openpgp.c - The OpenPGP card application.
|
2009-03-05 20:19:37 +01:00
|
|
|
|
* Copyright (C) 2003, 2004, 2005, 2007, 2008,
|
2015-06-26 08:14:27 +02:00
|
|
|
|
* 2009, 2013, 2014, 2015 Free Software Foundation, Inc.
|
2003-08-05 19:11:04 +02:00
|
|
|
|
*
|
|
|
|
|
* This file is part of GnuPG.
|
|
|
|
|
*
|
|
|
|
|
* GnuPG is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
2007-07-04 21:49:40 +02:00
|
|
|
|
* the Free Software Foundation; either version 3 of the License, or
|
2003-08-05 19:11:04 +02:00
|
|
|
|
* (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* GnuPG is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2016-11-05 12:02:19 +01:00
|
|
|
|
* along with this program; if not, see <https://www.gnu.org/licenses/>.
|
2003-08-05 19:11:04 +02:00
|
|
|
|
*/
|
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
/* Some notes:
|
|
|
|
|
|
|
|
|
|
CHV means Card Holder Verification and is nothing else than a PIN
|
|
|
|
|
or password. That term seems to have been used originally with GSM
|
|
|
|
|
cards. Version v2 of the specs changes the term to the clearer
|
|
|
|
|
term PW for password. We use the terms here interchangeable
|
|
|
|
|
because we do not want to change existing strings i18n wise.
|
|
|
|
|
|
|
|
|
|
Version 2 of the specs also drops the separate PW2 which was
|
|
|
|
|
required in v1 due to ISO requirements. It is now possible to have
|
|
|
|
|
one physical PW but two reference to it so that they can be
|
|
|
|
|
individually be verified (e.g. to implement a forced verification
|
|
|
|
|
for one key). Thus you will noticed the use of PW2 with the verify
|
|
|
|
|
command but not with change_reference_data because the latter
|
|
|
|
|
operates directly on the physical PW.
|
|
|
|
|
|
|
|
|
|
The Reset Code (RC) as implemented by v2 cards uses the same error
|
|
|
|
|
counter as the PW2 of v1 cards. By default no RC is set and thus
|
|
|
|
|
that error counter is set to 0. After setting the RC the error
|
|
|
|
|
counter will be initialized to 3.
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
#include <config.h>
|
|
|
|
|
#include <errno.h>
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <stdlib.h>
|
2014-03-12 09:25:33 +01:00
|
|
|
|
#include <stdarg.h>
|
2003-08-05 19:11:04 +02:00
|
|
|
|
#include <string.h>
|
|
|
|
|
#include <assert.h>
|
2003-10-02 12:27:34 +02:00
|
|
|
|
#include <time.h>
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2003-10-02 12:27:34 +02:00
|
|
|
|
#if GNUPG_MAJOR_VERSION == 1
|
|
|
|
|
/* This is used with GnuPG version < 1.9. The code has been source
|
|
|
|
|
copied from the current GnuPG >= 1.9 and is maintained over
|
|
|
|
|
there. */
|
|
|
|
|
#include "options.h"
|
|
|
|
|
#include "errors.h"
|
|
|
|
|
#include "memory.h"
|
|
|
|
|
#include "cardglue.h"
|
|
|
|
|
#else /* GNUPG_MAJOR_VERSION != 1 */
|
2003-08-05 19:11:04 +02:00
|
|
|
|
#include "scdaemon.h"
|
2003-10-02 12:27:34 +02:00
|
|
|
|
#endif /* GNUPG_MAJOR_VERSION != 1 */
|
|
|
|
|
|
2017-03-07 12:21:23 +01:00
|
|
|
|
#include "../common/util.h"
|
|
|
|
|
#include "../common/i18n.h"
|
2003-08-05 19:11:04 +02:00
|
|
|
|
#include "iso7816.h"
|
2003-10-02 12:27:34 +02:00
|
|
|
|
#include "app-common.h"
|
2017-03-07 12:21:23 +01:00
|
|
|
|
#include "../common/tlv.h"
|
|
|
|
|
#include "../common/host2net.h"
|
|
|
|
|
#include "../common/openpgpdefs.h"
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
|
2020-02-17 09:44:59 +01:00
|
|
|
|
#define KDF_DATA_LENGTH_MIN 90
|
|
|
|
|
#define KDF_DATA_LENGTH_MAX 110
|
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
/* A table describing the DOs of the card. */
|
2003-08-05 19:11:04 +02:00
|
|
|
|
static struct {
|
|
|
|
|
int tag;
|
|
|
|
|
int constructed;
|
|
|
|
|
int get_from; /* Constructed DO with this DO or 0 for direct access. */
|
2017-07-24 09:10:22 +02:00
|
|
|
|
unsigned int binary:1;
|
|
|
|
|
unsigned int dont_cache:1;
|
|
|
|
|
unsigned int flush_on_error:1;
|
|
|
|
|
unsigned int get_immediate_in_v11:1; /* Enable a hack to bypass the cache of
|
2009-06-17 11:45:50 +02:00
|
|
|
|
this data object if it is used in 1.1
|
|
|
|
|
and later versions of the card. This
|
|
|
|
|
does not work with composite DO and
|
|
|
|
|
is currently only useful for the CHV
|
|
|
|
|
status bytes. */
|
2017-07-24 09:10:22 +02:00
|
|
|
|
unsigned int try_extlen:2; /* Large object; try to use an extended
|
2017-07-20 10:27:21 +02:00
|
|
|
|
length APDU when !=0. The size is
|
|
|
|
|
determined by extcap.max_certlen_3
|
|
|
|
|
when == 1, and by extcap.max_special_do
|
|
|
|
|
when == 2. */
|
2003-08-05 19:11:04 +02:00
|
|
|
|
char *desc;
|
|
|
|
|
} data_objects[] = {
|
2017-07-20 10:27:21 +02:00
|
|
|
|
{ 0x005E, 0, 0, 1, 0, 0, 0, 2, "Login Data" },
|
|
|
|
|
{ 0x5F50, 0, 0, 0, 0, 0, 0, 2, "URL" },
|
2009-06-17 11:45:50 +02:00
|
|
|
|
{ 0x5F52, 0, 0, 1, 0, 0, 0, 0, "Historical Bytes" },
|
|
|
|
|
{ 0x0065, 1, 0, 1, 0, 0, 0, 0, "Cardholder Related Data"},
|
|
|
|
|
{ 0x005B, 0, 0x65, 0, 0, 0, 0, 0, "Name" },
|
|
|
|
|
{ 0x5F2D, 0, 0x65, 0, 0, 0, 0, 0, "Language preferences" },
|
2017-11-15 11:34:30 +01:00
|
|
|
|
{ 0x5F35, 0, 0x65, 0, 0, 0, 0, 0, "Salutation" },
|
2009-06-17 11:45:50 +02:00
|
|
|
|
{ 0x006E, 1, 0, 1, 0, 0, 0, 0, "Application Related Data" },
|
|
|
|
|
{ 0x004F, 0, 0x6E, 1, 0, 0, 0, 0, "AID" },
|
|
|
|
|
{ 0x0073, 1, 0, 1, 0, 0, 0, 0, "Discretionary Data Objects" },
|
|
|
|
|
{ 0x0047, 0, 0x6E, 1, 1, 0, 0, 0, "Card Capabilities" },
|
|
|
|
|
{ 0x00C0, 0, 0x6E, 1, 1, 0, 0, 0, "Extended Card Capabilities" },
|
|
|
|
|
{ 0x00C1, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Signature" },
|
|
|
|
|
{ 0x00C2, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Decryption" },
|
|
|
|
|
{ 0x00C3, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Authentication" },
|
|
|
|
|
{ 0x00C4, 0, 0x6E, 1, 0, 1, 1, 0, "CHV Status Bytes" },
|
|
|
|
|
{ 0x00C5, 0, 0x6E, 1, 0, 0, 0, 0, "Fingerprints" },
|
|
|
|
|
{ 0x00C6, 0, 0x6E, 1, 0, 0, 0, 0, "CA Fingerprints" },
|
|
|
|
|
{ 0x00CD, 0, 0x6E, 1, 0, 0, 0, 0, "Generation time" },
|
|
|
|
|
{ 0x007A, 1, 0, 1, 0, 0, 0, 0, "Security Support Template" },
|
|
|
|
|
{ 0x0093, 0, 0x7A, 1, 1, 0, 0, 0, "Digital Signature Counter" },
|
2017-07-20 10:27:21 +02:00
|
|
|
|
{ 0x0101, 0, 0, 0, 0, 0, 0, 2, "Private DO 1"},
|
|
|
|
|
{ 0x0102, 0, 0, 0, 0, 0, 0, 2, "Private DO 2"},
|
|
|
|
|
{ 0x0103, 0, 0, 0, 0, 0, 0, 2, "Private DO 3"},
|
|
|
|
|
{ 0x0104, 0, 0, 0, 0, 0, 0, 2, "Private DO 4"},
|
2009-06-17 11:45:50 +02:00
|
|
|
|
{ 0x7F21, 1, 0, 1, 0, 0, 0, 1, "Cardholder certificate"},
|
2015-06-26 08:14:27 +02:00
|
|
|
|
/* V3.0 */
|
|
|
|
|
{ 0x7F74, 0, 0, 1, 0, 0, 0, 0, "General Feature Management"},
|
|
|
|
|
{ 0x00D5, 0, 0, 1, 0, 0, 0, 0, "AES key data"},
|
2018-01-22 11:46:14 +01:00
|
|
|
|
{ 0x00F9, 0, 0, 1, 0, 0, 0, 0, "KDF data object"},
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{ 0 }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2013-03-08 03:40:37 +01:00
|
|
|
|
/* Type of keys. */
|
|
|
|
|
typedef enum
|
|
|
|
|
{
|
2014-12-22 01:27:00 +01:00
|
|
|
|
KEY_TYPE_ECC,
|
2013-03-08 03:40:37 +01:00
|
|
|
|
KEY_TYPE_RSA,
|
|
|
|
|
}
|
|
|
|
|
key_type_t;
|
|
|
|
|
|
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
/* The format of RSA private keys. */
|
|
|
|
|
typedef enum
|
2011-02-04 12:57:53 +01:00
|
|
|
|
{
|
2008-09-25 12:06:02 +02:00
|
|
|
|
RSA_UNKNOWN_FMT,
|
|
|
|
|
RSA_STD,
|
|
|
|
|
RSA_STD_N,
|
|
|
|
|
RSA_CRT,
|
|
|
|
|
RSA_CRT_N
|
2011-02-04 12:57:53 +01:00
|
|
|
|
}
|
2008-09-25 12:06:02 +02:00
|
|
|
|
rsa_key_format_t;
|
|
|
|
|
|
|
|
|
|
|
2005-02-22 18:29:07 +01:00
|
|
|
|
/* One cache item for DOs. */
|
2004-04-26 20:28:06 +02:00
|
|
|
|
struct cache_s {
|
|
|
|
|
struct cache_s *next;
|
|
|
|
|
int tag;
|
|
|
|
|
size_t length;
|
|
|
|
|
unsigned char data[1];
|
|
|
|
|
};
|
|
|
|
|
|
2005-02-22 18:29:07 +01:00
|
|
|
|
|
|
|
|
|
/* Object with application (i.e. OpenPGP card) specific data. */
|
2004-04-26 20:28:06 +02:00
|
|
|
|
struct app_local_s {
|
2005-02-22 18:29:07 +01:00
|
|
|
|
/* A linked list with cached DOs. */
|
2004-04-26 20:28:06 +02:00
|
|
|
|
struct cache_s *cache;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2005-02-22 18:29:07 +01:00
|
|
|
|
/* Keep track of the public keys. */
|
|
|
|
|
struct
|
|
|
|
|
{
|
|
|
|
|
int read_done; /* True if we have at least tried to read them. */
|
2005-04-11 18:20:10 +02:00
|
|
|
|
unsigned char *key; /* This is a malloced buffer with a canonical
|
|
|
|
|
encoded S-expression encoding a public
|
|
|
|
|
key. Might be NULL if key is not
|
|
|
|
|
available. */
|
2006-04-11 15:53:21 +02:00
|
|
|
|
size_t keylen; /* The length of the above S-expression. This
|
2009-03-10 17:10:35 +01:00
|
|
|
|
is usually only required for cross checks
|
2005-04-11 18:20:10 +02:00
|
|
|
|
because the length of an S-expression is
|
|
|
|
|
implicitly available. */
|
2005-02-22 18:29:07 +01:00
|
|
|
|
} pk[3];
|
|
|
|
|
|
2008-09-23 11:57:45 +02:00
|
|
|
|
unsigned char status_indicator; /* The card status indicator. */
|
|
|
|
|
|
2012-11-06 12:02:25 +01:00
|
|
|
|
unsigned int manufacturer:16; /* Manufacturer ID from the s/n. */
|
|
|
|
|
|
2008-09-23 11:57:45 +02:00
|
|
|
|
/* Keep track of the ISO card capabilities. */
|
|
|
|
|
struct
|
|
|
|
|
{
|
|
|
|
|
unsigned int cmd_chaining:1; /* Command chaining is supported. */
|
|
|
|
|
unsigned int ext_lc_le:1; /* Extended Lc and Le are supported. */
|
|
|
|
|
} cardcap;
|
|
|
|
|
|
|
|
|
|
/* Keep track of extended card capabilities. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
struct
|
2004-09-30 15:24:33 +02:00
|
|
|
|
{
|
2017-07-20 10:27:21 +02:00
|
|
|
|
unsigned int is_v2:1; /* Compatible to v2 or later. */
|
|
|
|
|
unsigned int extcap_v3:1; /* Extcap is in v3 format. */
|
|
|
|
|
unsigned int has_button:1; /* Has confirmation button or not. */
|
|
|
|
|
|
|
|
|
|
unsigned int sm_supported:1; /* Secure Messaging is supported. */
|
2004-09-30 15:24:33 +02:00
|
|
|
|
unsigned int get_challenge:1;
|
|
|
|
|
unsigned int key_import:1;
|
|
|
|
|
unsigned int change_force_chv:1;
|
|
|
|
|
unsigned int private_dos:1;
|
2008-12-05 13:01:01 +01:00
|
|
|
|
unsigned int algo_attr_change:1; /* Algorithm attributes changeable. */
|
2017-07-20 10:27:21 +02:00
|
|
|
|
unsigned int has_decrypt:1; /* Support symmetric decryption. */
|
2020-02-17 09:44:59 +01:00
|
|
|
|
unsigned int kdf_do:1; /* Support KDF DO. */
|
2017-07-20 10:27:21 +02:00
|
|
|
|
|
|
|
|
|
unsigned int sm_algo:2; /* Symmetric crypto algo for SM. */
|
|
|
|
|
unsigned int pin_blk2:1; /* PIN block 2 format supported. */
|
|
|
|
|
unsigned int mse:1; /* MSE command supported. */
|
2008-07-17 21:40:53 +02:00
|
|
|
|
unsigned int max_certlen_3:16;
|
2017-07-20 10:27:21 +02:00
|
|
|
|
unsigned int max_get_challenge:16; /* Maximum size for get_challenge. */
|
|
|
|
|
unsigned int max_special_do:16; /* Maximum size for special DOs. */
|
2004-09-30 15:24:33 +02:00
|
|
|
|
} extcap;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
|
|
|
|
|
/* Flags used to control the application. */
|
2004-10-14 15:22:03 +02:00
|
|
|
|
struct
|
|
|
|
|
{
|
|
|
|
|
unsigned int no_sync:1; /* Do not sync CHV1 and CHV2 */
|
|
|
|
|
unsigned int def_chv2:1; /* Use 123456 for CHV2. */
|
|
|
|
|
} flags;
|
2008-09-25 12:06:02 +02:00
|
|
|
|
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
/* Pinpad request specified on card. */
|
2013-01-10 07:58:43 +01:00
|
|
|
|
struct
|
|
|
|
|
{
|
2020-02-17 09:44:59 +01:00
|
|
|
|
unsigned int disabled:1; /* No pinpad use because of KDF DO. */
|
2013-01-10 07:58:43 +01:00
|
|
|
|
unsigned int specified:1;
|
|
|
|
|
int fixedlen_user;
|
|
|
|
|
int fixedlen_admin;
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
} pinpad;
|
2013-01-10 07:58:43 +01:00
|
|
|
|
|
2013-03-08 03:40:37 +01:00
|
|
|
|
struct
|
|
|
|
|
{
|
|
|
|
|
key_type_t key_type;
|
|
|
|
|
union {
|
|
|
|
|
struct {
|
|
|
|
|
unsigned int n_bits; /* Size of the modulus in bits. The rest
|
|
|
|
|
of this strucuire is only valid if
|
|
|
|
|
this is not 0. */
|
|
|
|
|
unsigned int e_bits; /* Size of the public exponent in bits. */
|
|
|
|
|
rsa_key_format_t format;
|
|
|
|
|
} rsa;
|
|
|
|
|
struct {
|
2016-10-24 04:22:44 +02:00
|
|
|
|
const char *curve;
|
2015-07-25 05:09:23 +02:00
|
|
|
|
int flags;
|
2014-12-22 01:27:00 +01:00
|
|
|
|
} ecc;
|
2013-03-08 03:40:37 +01:00
|
|
|
|
};
|
|
|
|
|
} keyattr[3];
|
2004-04-26 20:28:06 +02:00
|
|
|
|
};
|
|
|
|
|
|
2015-08-06 10:00:41 +02:00
|
|
|
|
#define ECC_FLAG_DJB_TWEAK (1 << 0)
|
2016-09-16 08:20:32 +02:00
|
|
|
|
#define ECC_FLAG_PUBKEY (1 << 1)
|
2004-04-26 20:28:06 +02:00
|
|
|
|
|
2005-02-22 18:29:07 +01:00
|
|
|
|
|
|
|
|
|
/***** Local prototypes *****/
|
2003-09-30 19:35:05 +02:00
|
|
|
|
static unsigned long convert_sig_counter_value (const unsigned char *value,
|
|
|
|
|
size_t valuelen);
|
2005-02-22 18:29:07 +01:00
|
|
|
|
static unsigned long get_sig_counter (app_t app);
|
2006-10-11 19:52:15 +02:00
|
|
|
|
static gpg_error_t do_auth (app_t app, const char *keyidstr,
|
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
|
|
|
|
void *pincb_arg,
|
|
|
|
|
const void *indata, size_t indatalen,
|
|
|
|
|
unsigned char **outdata, size_t *outdatalen);
|
2009-07-09 16:54:18 +02:00
|
|
|
|
static void parse_algorithm_attribute (app_t app, int keyno);
|
2009-08-05 13:24:43 +02:00
|
|
|
|
static gpg_error_t change_keyattr_from_string
|
2011-02-04 12:57:53 +01:00
|
|
|
|
(app_t app,
|
2009-08-05 13:24:43 +02:00
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
|
|
|
|
void *pincb_arg,
|
|
|
|
|
const void *value, size_t valuelen);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2020-04-03 09:56:56 +02:00
|
|
|
|
|
|
|
|
|
/* Return the OpenPGP card manufacturer name. */
|
|
|
|
|
static const char *
|
|
|
|
|
get_manufacturer (unsigned int no)
|
|
|
|
|
{
|
|
|
|
|
/* Note: Make sure that there is no colon or linefeed in the string. */
|
|
|
|
|
switch (no)
|
|
|
|
|
{
|
|
|
|
|
case 0x0001: return "PPC Card Systems";
|
|
|
|
|
case 0x0002: return "Prism";
|
|
|
|
|
case 0x0003: return "OpenFortress";
|
|
|
|
|
case 0x0004: return "Wewid";
|
|
|
|
|
case 0x0005: return "ZeitControl";
|
|
|
|
|
case 0x0006: return "Yubico";
|
|
|
|
|
case 0x0007: return "OpenKMS";
|
|
|
|
|
case 0x0008: return "LogoEmail";
|
|
|
|
|
case 0x0009: return "Fidesmo";
|
|
|
|
|
case 0x000A: return "Dangerous Things";
|
|
|
|
|
case 0x000B: return "Feitian Technologies";
|
|
|
|
|
|
|
|
|
|
case 0x002A: return "Magrathea";
|
|
|
|
|
case 0x0042: return "GnuPG e.V.";
|
|
|
|
|
|
|
|
|
|
case 0x1337: return "Warsaw Hackerspace";
|
|
|
|
|
case 0x2342: return "warpzone"; /* hackerspace Muenster. */
|
|
|
|
|
case 0x4354: return "Confidential Technologies"; /* cotech.de */
|
|
|
|
|
case 0x5443: return "TIF-IT e.V.";
|
|
|
|
|
case 0x63AF: return "Trustica";
|
|
|
|
|
case 0xBA53: return "c-base e.V.";
|
|
|
|
|
case 0xBD0E: return "Paranoidlabs";
|
|
|
|
|
case 0xF517: return "FSIJ";
|
|
|
|
|
case 0xF5EC: return "F-Secure";
|
|
|
|
|
|
|
|
|
|
/* 0x0000 and 0xFFFF are defined as test cards per spec,
|
|
|
|
|
* 0xFF00 to 0xFFFE are assigned for use with randomly created
|
|
|
|
|
* serial numbers. */
|
|
|
|
|
case 0x0000:
|
|
|
|
|
case 0xffff: return "test card";
|
|
|
|
|
default: return (no & 0xff00) == 0xff00? "unmanaged S/N range":"unknown";
|
|
|
|
|
}
|
|
|
|
|
}
|
2005-02-22 18:29:07 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2004-04-26 20:28:06 +02:00
|
|
|
|
/* Deconstructor. */
|
|
|
|
|
static void
|
|
|
|
|
do_deinit (app_t app)
|
|
|
|
|
{
|
|
|
|
|
if (app && app->app_local)
|
|
|
|
|
{
|
|
|
|
|
struct cache_s *c, *c2;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
int i;
|
2004-04-26 20:28:06 +02:00
|
|
|
|
|
|
|
|
|
for (c = app->app_local->cache; c; c = c2)
|
|
|
|
|
{
|
|
|
|
|
c2 = c->next;
|
|
|
|
|
xfree (c);
|
|
|
|
|
}
|
2005-02-22 18:29:07 +01:00
|
|
|
|
|
|
|
|
|
for (i=0; i < DIM (app->app_local->pk); i++)
|
|
|
|
|
{
|
2005-04-11 18:20:10 +02:00
|
|
|
|
xfree (app->app_local->pk[i].key);
|
2005-02-22 18:29:07 +01:00
|
|
|
|
app->app_local->pk[i].read_done = 0;
|
|
|
|
|
}
|
2004-04-26 20:28:06 +02:00
|
|
|
|
xfree (app->app_local);
|
|
|
|
|
app->app_local = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Wrapper around iso7816_get_data which first tries to get the data
|
2005-02-03 14:20:57 +01:00
|
|
|
|
from the cache. With GET_IMMEDIATE passed as true, the cache is
|
2009-06-17 11:45:50 +02:00
|
|
|
|
bypassed. With TRY_EXTLEN extended lengths APDUs are use if
|
|
|
|
|
supported by the card. */
|
2004-04-26 20:28:06 +02:00
|
|
|
|
static gpg_error_t
|
2011-02-04 12:57:53 +01:00
|
|
|
|
get_cached_data (app_t app, int tag,
|
2005-02-03 14:20:57 +01:00
|
|
|
|
unsigned char **result, size_t *resultlen,
|
2009-06-17 11:45:50 +02:00
|
|
|
|
int get_immediate, int try_extlen)
|
2004-04-26 20:28:06 +02:00
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
int i;
|
|
|
|
|
unsigned char *p;
|
|
|
|
|
size_t len;
|
|
|
|
|
struct cache_s *c;
|
2009-06-17 11:45:50 +02:00
|
|
|
|
int exmode;
|
2004-04-26 20:28:06 +02:00
|
|
|
|
|
|
|
|
|
*result = NULL;
|
|
|
|
|
*resultlen = 0;
|
|
|
|
|
|
2005-02-03 14:20:57 +01:00
|
|
|
|
if (!get_immediate)
|
|
|
|
|
{
|
|
|
|
|
for (c=app->app_local->cache; c; c = c->next)
|
|
|
|
|
if (c->tag == tag)
|
2004-04-26 20:28:06 +02:00
|
|
|
|
{
|
2005-02-03 14:20:57 +01:00
|
|
|
|
if(c->length)
|
|
|
|
|
{
|
|
|
|
|
p = xtrymalloc (c->length);
|
|
|
|
|
if (!p)
|
|
|
|
|
return gpg_error (gpg_err_code_from_errno (errno));
|
|
|
|
|
memcpy (p, c->data, c->length);
|
|
|
|
|
*result = p;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2005-02-03 14:20:57 +01:00
|
|
|
|
*resultlen = c->length;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2005-02-03 14:20:57 +01:00
|
|
|
|
return 0;
|
2004-04-26 20:28:06 +02:00
|
|
|
|
}
|
2005-02-03 14:20:57 +01:00
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-06-17 11:45:50 +02:00
|
|
|
|
if (try_extlen && app->app_local->cardcap.ext_lc_le)
|
2017-07-20 10:27:21 +02:00
|
|
|
|
{
|
|
|
|
|
if (try_extlen == 1)
|
|
|
|
|
exmode = app->app_local->extcap.max_certlen_3;
|
|
|
|
|
else if (try_extlen == 2 && app->app_local->extcap.extcap_v3)
|
|
|
|
|
exmode = app->app_local->extcap.max_special_do;
|
|
|
|
|
else
|
|
|
|
|
exmode = 0;
|
|
|
|
|
}
|
2009-06-17 11:45:50 +02:00
|
|
|
|
else
|
|
|
|
|
exmode = 0;
|
|
|
|
|
|
|
|
|
|
err = iso7816_get_data (app->slot, exmode, tag, &p, &len);
|
2004-04-26 20:28:06 +02:00
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2018-02-12 10:56:58 +01:00
|
|
|
|
if (len)
|
|
|
|
|
*result = p;
|
2004-04-26 20:28:06 +02:00
|
|
|
|
*resultlen = len;
|
|
|
|
|
|
|
|
|
|
/* Check whether we should cache this object. */
|
2005-02-03 14:20:57 +01:00
|
|
|
|
if (get_immediate)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2004-04-26 20:28:06 +02:00
|
|
|
|
for (i=0; data_objects[i].tag; i++)
|
|
|
|
|
if (data_objects[i].tag == tag)
|
|
|
|
|
{
|
|
|
|
|
if (data_objects[i].dont_cache)
|
|
|
|
|
return 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2005-02-03 14:20:57 +01:00
|
|
|
|
/* Okay, cache it. */
|
2004-09-30 15:24:33 +02:00
|
|
|
|
for (c=app->app_local->cache; c; c = c->next)
|
|
|
|
|
assert (c->tag != tag);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2004-09-30 15:24:33 +02:00
|
|
|
|
c = xtrymalloc (sizeof *c + len);
|
|
|
|
|
if (c)
|
2004-04-26 20:28:06 +02:00
|
|
|
|
{
|
2018-02-12 10:56:58 +01:00
|
|
|
|
if (len)
|
|
|
|
|
memcpy (c->data, p, len);
|
|
|
|
|
else
|
|
|
|
|
xfree (p);
|
2004-09-30 15:24:33 +02:00
|
|
|
|
c->length = len;
|
|
|
|
|
c->tag = tag;
|
|
|
|
|
c->next = app->app_local->cache;
|
|
|
|
|
app->app_local->cache = c;
|
2004-04-26 20:28:06 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Remove DO at TAG from the cache. */
|
|
|
|
|
static void
|
|
|
|
|
flush_cache_item (app_t app, int tag)
|
|
|
|
|
{
|
|
|
|
|
struct cache_s *c, *cprev;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (!app->app_local)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
|
|
|
|
|
if (c->tag == tag)
|
|
|
|
|
{
|
|
|
|
|
if (cprev)
|
|
|
|
|
cprev->next = c->next;
|
|
|
|
|
else
|
|
|
|
|
app->app_local->cache = c->next;
|
|
|
|
|
xfree (c);
|
|
|
|
|
|
|
|
|
|
for (c=app->app_local->cache; c ; c = c->next)
|
2004-09-30 15:24:33 +02:00
|
|
|
|
{
|
|
|
|
|
assert (c->tag != tag); /* Oops: duplicated entry. */
|
|
|
|
|
}
|
2004-04-26 20:28:06 +02:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Try again if we have an outer tag. */
|
|
|
|
|
for (i=0; data_objects[i].tag; i++)
|
|
|
|
|
if (data_objects[i].tag == tag && data_objects[i].get_from
|
|
|
|
|
&& data_objects[i].get_from != tag)
|
|
|
|
|
flush_cache_item (app, data_objects[i].get_from);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Flush all entries from the cache which might be out of sync after
|
|
|
|
|
an error. */
|
|
|
|
|
static void
|
|
|
|
|
flush_cache_after_error (app_t app)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i=0; data_objects[i].tag; i++)
|
|
|
|
|
if (data_objects[i].flush_on_error)
|
|
|
|
|
flush_cache_item (app, data_objects[i].tag);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Flush the entire cache. */
|
|
|
|
|
static void
|
|
|
|
|
flush_cache (app_t app)
|
|
|
|
|
{
|
|
|
|
|
if (app && app->app_local)
|
|
|
|
|
{
|
|
|
|
|
struct cache_s *c, *c2;
|
|
|
|
|
|
|
|
|
|
for (c = app->app_local->cache; c; c = c2)
|
|
|
|
|
{
|
|
|
|
|
c2 = c->next;
|
|
|
|
|
xfree (c);
|
|
|
|
|
}
|
|
|
|
|
app->app_local->cache = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Get the DO identified by TAG from the card in SLOT and return a
|
|
|
|
|
buffer with its content in RESULT and NBYTES. The return value is
|
|
|
|
|
NULL if not found or a pointer which must be used to release the
|
|
|
|
|
buffer holding value. */
|
|
|
|
|
static void *
|
2005-02-24 18:36:11 +01:00
|
|
|
|
get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes,
|
|
|
|
|
int *r_rc)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
|
|
|
|
int rc, i;
|
|
|
|
|
unsigned char *buffer;
|
|
|
|
|
size_t buflen;
|
|
|
|
|
unsigned char *value;
|
|
|
|
|
size_t valuelen;
|
2005-02-24 18:36:11 +01:00
|
|
|
|
int dummyrc;
|
2009-06-17 11:45:50 +02:00
|
|
|
|
int exmode;
|
2005-02-24 18:36:11 +01:00
|
|
|
|
|
|
|
|
|
if (!r_rc)
|
|
|
|
|
r_rc = &dummyrc;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
*result = NULL;
|
|
|
|
|
*nbytes = 0;
|
2005-02-24 18:36:11 +01:00
|
|
|
|
*r_rc = 0;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
|
|
|
|
|
;
|
|
|
|
|
|
2004-09-30 15:24:33 +02:00
|
|
|
|
if (app->card_version > 0x0100 && data_objects[i].get_immediate_in_v11)
|
|
|
|
|
{
|
2016-11-25 08:12:26 +01:00
|
|
|
|
exmode = 0;
|
2009-06-17 11:45:50 +02:00
|
|
|
|
rc = iso7816_get_data (app->slot, exmode, tag, &buffer, &buflen);
|
2005-02-24 18:36:11 +01:00
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
*r_rc = rc;
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2004-09-30 15:24:33 +02:00
|
|
|
|
*result = buffer;
|
|
|
|
|
*nbytes = buflen;
|
|
|
|
|
return buffer;
|
|
|
|
|
}
|
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
value = NULL;
|
|
|
|
|
rc = -1;
|
|
|
|
|
if (data_objects[i].tag && data_objects[i].get_from)
|
|
|
|
|
{
|
2004-04-26 20:28:06 +02:00
|
|
|
|
rc = get_cached_data (app, data_objects[i].get_from,
|
2005-02-03 14:20:57 +01:00
|
|
|
|
&buffer, &buflen,
|
2011-02-04 12:57:53 +01:00
|
|
|
|
(data_objects[i].dont_cache
|
2009-06-17 11:45:50 +02:00
|
|
|
|
|| data_objects[i].get_immediate_in_v11),
|
|
|
|
|
data_objects[i].try_extlen);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (!rc)
|
|
|
|
|
{
|
|
|
|
|
const unsigned char *s;
|
|
|
|
|
|
2005-04-27 21:47:53 +02:00
|
|
|
|
s = find_tlv_unchecked (buffer, buflen, tag, &valuelen);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (!s)
|
|
|
|
|
value = NULL; /* not found */
|
|
|
|
|
else if (valuelen > buflen - (s - buffer))
|
|
|
|
|
{
|
|
|
|
|
log_error ("warning: constructed DO too short\n");
|
|
|
|
|
value = NULL;
|
|
|
|
|
xfree (buffer); buffer = NULL;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
value = buffer + (s - buffer);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!value) /* Not in a constructed DO, try simple. */
|
|
|
|
|
{
|
2005-02-03 14:20:57 +01:00
|
|
|
|
rc = get_cached_data (app, tag, &buffer, &buflen,
|
2011-02-04 12:57:53 +01:00
|
|
|
|
(data_objects[i].dont_cache
|
2009-06-17 11:45:50 +02:00
|
|
|
|
|| data_objects[i].get_immediate_in_v11),
|
|
|
|
|
data_objects[i].try_extlen);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (!rc)
|
|
|
|
|
{
|
|
|
|
|
value = buffer;
|
|
|
|
|
valuelen = buflen;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!rc)
|
|
|
|
|
{
|
|
|
|
|
*nbytes = valuelen;
|
|
|
|
|
*result = value;
|
|
|
|
|
return buffer;
|
|
|
|
|
}
|
2005-02-24 18:36:11 +01:00
|
|
|
|
*r_rc = rc;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
dump_all_do (int slot)
|
|
|
|
|
{
|
|
|
|
|
int rc, i, j;
|
|
|
|
|
unsigned char *buffer;
|
|
|
|
|
size_t buflen;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
for (i=0; data_objects[i].tag; i++)
|
|
|
|
|
{
|
|
|
|
|
if (data_objects[i].get_from)
|
|
|
|
|
continue;
|
|
|
|
|
|
2009-06-17 11:45:50 +02:00
|
|
|
|
/* We don't try extended length APDU because such large DO would
|
|
|
|
|
be pretty useless in a log file. */
|
|
|
|
|
rc = iso7816_get_data (slot, 0, data_objects[i].tag, &buffer, &buflen);
|
2003-09-30 15:22:33 +02:00
|
|
|
|
if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
else if (rc)
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_info ("DO '%s' not available: %s\n",
|
2003-08-05 19:11:04 +02:00
|
|
|
|
data_objects[i].desc, gpg_strerror (rc));
|
2003-08-05 19:11:04 +02:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (data_objects[i].binary)
|
|
|
|
|
{
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_info ("DO '%s': ", data_objects[i].desc);
|
2020-05-12 18:51:47 +02:00
|
|
|
|
log_printhex (buffer, buflen, "");
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_info ("DO '%s': '%.*s'\n",
|
2003-08-05 19:11:04 +02:00
|
|
|
|
data_objects[i].desc,
|
|
|
|
|
(int)buflen, buffer); /* FIXME: sanitize */
|
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (data_objects[i].constructed)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
2003-08-05 19:11:04 +02:00
|
|
|
|
for (j=0; data_objects[j].tag; j++)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
2003-08-05 19:11:04 +02:00
|
|
|
|
const unsigned char *value;
|
|
|
|
|
size_t valuelen;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (j==i || data_objects[i].tag != data_objects[j].get_from)
|
|
|
|
|
continue;
|
2005-04-27 21:47:53 +02:00
|
|
|
|
value = find_tlv_unchecked (buffer, buflen,
|
|
|
|
|
data_objects[j].tag, &valuelen);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (!value)
|
|
|
|
|
; /* not found */
|
|
|
|
|
else if (valuelen > buflen - (value - buffer))
|
|
|
|
|
log_error ("warning: constructed DO too short\n");
|
|
|
|
|
else
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (data_objects[j].binary)
|
|
|
|
|
{
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_info ("DO '%s': ", data_objects[j].desc);
|
2008-09-23 11:57:45 +02:00
|
|
|
|
if (valuelen > 200)
|
|
|
|
|
log_info ("[%u]\n", (unsigned int)valuelen);
|
|
|
|
|
else
|
2020-05-12 18:51:47 +02:00
|
|
|
|
log_printhex (value, valuelen, "");
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_info ("DO '%s': '%.*s'\n",
|
2003-08-05 19:11:04 +02:00
|
|
|
|
data_objects[j].desc,
|
|
|
|
|
(int)valuelen, value); /* FIXME: sanitize */
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
xfree (buffer); buffer = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Count the number of bits, assuming the A represents an unsigned big
|
|
|
|
|
integer of length LEN bytes. */
|
|
|
|
|
static unsigned int
|
|
|
|
|
count_bits (const unsigned char *a, size_t len)
|
|
|
|
|
{
|
|
|
|
|
unsigned int n = len * 8;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (; len && !*a; len--, a++, n -=8)
|
|
|
|
|
;
|
|
|
|
|
if (len)
|
|
|
|
|
{
|
|
|
|
|
for (i=7; i && !(*a & (1<<i)); i--)
|
|
|
|
|
n--;
|
|
|
|
|
}
|
|
|
|
|
return n;
|
|
|
|
|
}
|
|
|
|
|
|
2008-04-21 09:53:20 +02:00
|
|
|
|
/* GnuPG makes special use of the login-data DO, this function parses
|
2004-10-14 15:22:03 +02:00
|
|
|
|
the login data to store the flags for later use. It may be called
|
|
|
|
|
at any time and should be called after changing the login-data DO.
|
|
|
|
|
|
|
|
|
|
Everything up to a LF is considered a mailbox or account name. If
|
2005-02-03 14:20:57 +01:00
|
|
|
|
the first LF is followed by DC4 (0x14) control sequence are
|
2004-10-14 15:22:03 +02:00
|
|
|
|
expected up to the next LF. Control sequences are separated by FS
|
2013-01-10 07:58:43 +01:00
|
|
|
|
(0x18) and consist of key=value pairs. There are two keys defined:
|
2004-10-14 15:22:03 +02:00
|
|
|
|
|
|
|
|
|
F=<flags>
|
|
|
|
|
|
2013-01-10 07:58:43 +01:00
|
|
|
|
Where FLAGS is a plain hexadecimal number representing flag values.
|
2004-10-14 15:22:03 +02:00
|
|
|
|
The lsb is here the rightmost bit. Defined flags bits are:
|
|
|
|
|
|
2019-06-24 02:17:05 +02:00
|
|
|
|
Bit 0 = CHV1 and CHV2 are not synchronized
|
2017-02-20 22:19:50 +01:00
|
|
|
|
Bit 1 = CHV2 has been set to the default PIN of "123456"
|
2004-10-14 15:22:03 +02:00
|
|
|
|
(this implies that bit 0 is also set).
|
|
|
|
|
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
P=<pinpad-request>
|
2013-01-10 07:58:43 +01:00
|
|
|
|
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
Where PINPAD_REQUEST is in the format of: <n> or <n>,<m>.
|
2013-01-13 04:12:10 +01:00
|
|
|
|
N for user PIN, M for admin PIN. If M is missing it means M=N.
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
0 means to force not to use pinpad.
|
2013-01-10 07:58:43 +01:00
|
|
|
|
|
2004-10-14 15:22:03 +02:00
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
parse_login_data (app_t app)
|
|
|
|
|
{
|
|
|
|
|
unsigned char *buffer, *p;
|
|
|
|
|
size_t buflen, len;
|
|
|
|
|
void *relptr;
|
|
|
|
|
|
|
|
|
|
/* Set defaults. */
|
|
|
|
|
app->app_local->flags.no_sync = 0;
|
|
|
|
|
app->app_local->flags.def_chv2 = 0;
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
app->app_local->pinpad.specified = 0;
|
|
|
|
|
app->app_local->pinpad.fixedlen_user = -1;
|
|
|
|
|
app->app_local->pinpad.fixedlen_admin = -1;
|
2004-10-14 15:22:03 +02:00
|
|
|
|
|
|
|
|
|
/* Read the DO. */
|
2005-02-24 18:36:11 +01:00
|
|
|
|
relptr = get_one_do (app, 0x005E, &buffer, &buflen, NULL);
|
2004-10-14 15:22:03 +02:00
|
|
|
|
if (!relptr)
|
|
|
|
|
return; /* Ooops. */
|
|
|
|
|
for (; buflen; buflen--, buffer++)
|
|
|
|
|
if (*buffer == '\n')
|
|
|
|
|
break;
|
|
|
|
|
if (buflen < 2 || buffer[1] != '\x14')
|
2013-08-27 03:23:09 +02:00
|
|
|
|
{
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
return; /* No control sequences. */
|
|
|
|
|
}
|
|
|
|
|
|
2004-10-14 15:22:03 +02:00
|
|
|
|
buflen--;
|
|
|
|
|
buffer++;
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
buflen--;
|
|
|
|
|
buffer++;
|
|
|
|
|
if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
|
|
|
|
|
{
|
|
|
|
|
/* Flags control sequence found. */
|
|
|
|
|
int lastdig = 0;
|
|
|
|
|
|
|
|
|
|
/* For now we are only interested in the last digit, so skip
|
|
|
|
|
any leading digits but bail out on invalid characters. */
|
|
|
|
|
for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
|
|
|
|
|
lastdig = xtoi_1 (p);
|
2013-01-10 07:58:43 +01:00
|
|
|
|
buffer = p;
|
|
|
|
|
buflen = len;
|
2004-10-14 15:22:03 +02:00
|
|
|
|
if (len && !(*p == '\n' || *p == '\x18'))
|
|
|
|
|
goto next; /* Invalid characters in field. */
|
|
|
|
|
app->app_local->flags.no_sync = !!(lastdig & 1);
|
|
|
|
|
app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
|
|
|
|
|
}
|
2013-01-10 07:58:43 +01:00
|
|
|
|
else if (buflen > 1 && *buffer == 'P' && buffer[1] == '=')
|
|
|
|
|
{
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
/* Pinpad request control sequence found. */
|
2013-01-10 07:58:43 +01:00
|
|
|
|
buffer += 2;
|
|
|
|
|
buflen -= 2;
|
|
|
|
|
|
|
|
|
|
if (buflen)
|
|
|
|
|
{
|
2013-01-13 04:12:10 +01:00
|
|
|
|
if (digitp (buffer))
|
2013-01-10 07:58:43 +01:00
|
|
|
|
{
|
|
|
|
|
char *q;
|
|
|
|
|
int n, m;
|
|
|
|
|
|
|
|
|
|
n = strtol (buffer, &q, 10);
|
2013-01-13 04:12:10 +01:00
|
|
|
|
if (q >= (char *)buffer + buflen
|
|
|
|
|
|| *q == '\x18' || *q == '\n')
|
|
|
|
|
m = n;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (*q++ != ',' || !digitp (q))
|
|
|
|
|
goto next;
|
|
|
|
|
m = strtol (q, &q, 10);
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-10 07:58:43 +01:00
|
|
|
|
if (buflen < ((unsigned char *)q - buffer))
|
2013-08-27 03:23:09 +02:00
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
buflen -= ((unsigned char *)q - buffer);
|
|
|
|
|
buffer = q;
|
2013-01-10 07:58:43 +01:00
|
|
|
|
|
|
|
|
|
if (buflen && !(*buffer == '\n' || *buffer == '\x18'))
|
|
|
|
|
goto next;
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
app->app_local->pinpad.specified = 1;
|
|
|
|
|
app->app_local->pinpad.fixedlen_user = n;
|
|
|
|
|
app->app_local->pinpad.fixedlen_admin = m;
|
2013-01-10 07:58:43 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2004-10-14 15:22:03 +02:00
|
|
|
|
next:
|
2013-08-27 03:23:09 +02:00
|
|
|
|
/* Skip to FS (0x18) or LF (\n). */
|
|
|
|
|
for (; buflen && *buffer != '\x18' && *buffer != '\n'; buflen--)
|
|
|
|
|
buffer++;
|
2004-10-14 15:22:03 +02:00
|
|
|
|
}
|
2013-08-27 03:23:09 +02:00
|
|
|
|
while (buflen && *buffer != '\n');
|
2004-10-14 15:22:03 +02:00
|
|
|
|
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-12 09:25:33 +01:00
|
|
|
|
|
|
|
|
|
#define MAX_ARGS_STORE_FPR 3
|
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
/* Note, that FPR must be at least 20 bytes. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
static gpg_error_t
|
2015-01-28 03:24:29 +01:00
|
|
|
|
store_fpr (app_t app, int keynumber, u32 timestamp, unsigned char *fpr,
|
2015-07-25 05:09:23 +02:00
|
|
|
|
int algo, ...)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
|
|
|
|
unsigned int n, nbits;
|
|
|
|
|
unsigned char *buffer, *p;
|
2009-06-17 11:45:50 +02:00
|
|
|
|
int tag, tag2;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
int rc;
|
2014-03-12 09:25:33 +01:00
|
|
|
|
const unsigned char *m[MAX_ARGS_STORE_FPR];
|
|
|
|
|
size_t mlen[MAX_ARGS_STORE_FPR];
|
|
|
|
|
va_list ap;
|
|
|
|
|
int argc;
|
|
|
|
|
int i;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2014-03-12 09:25:33 +01:00
|
|
|
|
n = 6; /* key packet version, 4-byte timestamps, and algorithm */
|
2015-07-25 05:09:23 +02:00
|
|
|
|
if (algo == PUBKEY_ALGO_ECDH)
|
2014-03-12 09:25:33 +01:00
|
|
|
|
argc = 3;
|
|
|
|
|
else
|
2014-12-22 01:27:00 +01:00
|
|
|
|
argc = 2;
|
2014-03-12 09:25:33 +01:00
|
|
|
|
|
2015-07-25 05:09:23 +02:00
|
|
|
|
va_start (ap, algo);
|
2014-03-12 09:25:33 +01:00
|
|
|
|
for (i = 0; i < argc; i++)
|
|
|
|
|
{
|
|
|
|
|
m[i] = va_arg (ap, const unsigned char *);
|
|
|
|
|
mlen[i] = va_arg (ap, size_t);
|
2015-07-25 05:09:23 +02:00
|
|
|
|
if (algo == PUBKEY_ALGO_RSA || i == 1)
|
2014-03-12 09:25:33 +01:00
|
|
|
|
n += 2;
|
|
|
|
|
n += mlen[i];
|
|
|
|
|
}
|
|
|
|
|
va_end (ap);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
p = buffer = xtrymalloc (3 + n);
|
|
|
|
|
if (!buffer)
|
2006-09-14 18:50:33 +02:00
|
|
|
|
return gpg_error_from_syserror ();
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
*p++ = 0x99; /* ctb */
|
|
|
|
|
*p++ = n >> 8; /* 2 byte length header */
|
|
|
|
|
*p++ = n;
|
|
|
|
|
*p++ = 4; /* key packet version */
|
|
|
|
|
*p++ = timestamp >> 24;
|
|
|
|
|
*p++ = timestamp >> 16;
|
|
|
|
|
*p++ = timestamp >> 8;
|
|
|
|
|
*p++ = timestamp;
|
2015-07-25 05:09:23 +02:00
|
|
|
|
*p++ = algo;
|
2014-03-12 09:25:33 +01:00
|
|
|
|
|
|
|
|
|
for (i = 0; i < argc; i++)
|
|
|
|
|
{
|
2015-07-25 05:09:23 +02:00
|
|
|
|
if (algo == PUBKEY_ALGO_RSA || i == 1)
|
2014-03-12 09:25:33 +01:00
|
|
|
|
{
|
|
|
|
|
nbits = count_bits (m[i], mlen[i]);
|
|
|
|
|
*p++ = nbits >> 8;
|
|
|
|
|
*p++ = nbits;
|
|
|
|
|
}
|
|
|
|
|
memcpy (p, m[i], mlen[i]);
|
|
|
|
|
p += mlen[i];
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
|
|
|
|
|
|
|
|
|
|
xfree (buffer);
|
|
|
|
|
|
2015-01-28 03:24:29 +01:00
|
|
|
|
tag = (app->card_version > 0x0007? 0xC7 : 0xC6) + keynumber;
|
2012-12-13 05:36:23 +01:00
|
|
|
|
flush_cache_item (app, 0xC5);
|
2009-06-17 11:45:50 +02:00
|
|
|
|
tag2 = 0xCE + keynumber;
|
2012-12-13 05:36:23 +01:00
|
|
|
|
flush_cache_item (app, 0xCD);
|
2009-06-17 11:45:50 +02:00
|
|
|
|
|
|
|
|
|
rc = iso7816_put_data (app->slot, 0, tag, fpr, 20);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (rc)
|
2004-09-30 15:24:33 +02:00
|
|
|
|
log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
|
|
|
|
|
|
2015-01-28 03:24:29 +01:00
|
|
|
|
if (!rc && app->card_version > 0x0100)
|
2004-09-30 15:24:33 +02:00
|
|
|
|
{
|
|
|
|
|
unsigned char buf[4];
|
|
|
|
|
|
|
|
|
|
buf[0] = timestamp >> 24;
|
|
|
|
|
buf[1] = timestamp >> 16;
|
|
|
|
|
buf[2] = timestamp >> 8;
|
|
|
|
|
buf[3] = timestamp;
|
|
|
|
|
|
2009-06-17 11:45:50 +02:00
|
|
|
|
rc = iso7816_put_data (app->slot, 0, tag2, buf, 4);
|
2004-09-30 15:24:33 +02:00
|
|
|
|
if (rc)
|
|
|
|
|
log_error (_("failed to store the creation date: %s\n"),
|
|
|
|
|
gpg_strerror (rc));
|
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
static void
|
2004-10-14 15:22:03 +02:00
|
|
|
|
send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
|
2003-08-05 19:11:04 +02:00
|
|
|
|
int number, const unsigned char *fpr)
|
2011-02-04 12:57:53 +01:00
|
|
|
|
{
|
2003-08-05 19:11:04 +02:00
|
|
|
|
int i;
|
|
|
|
|
char buf[41];
|
|
|
|
|
char numbuf[25];
|
|
|
|
|
|
|
|
|
|
for (i=0; i < 20 && !fpr[i]; i++)
|
|
|
|
|
;
|
|
|
|
|
if (i==20)
|
|
|
|
|
return; /* All zero. */
|
2008-11-03 11:54:18 +01:00
|
|
|
|
bin2hex (fpr, 20, buf);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (number == -1)
|
|
|
|
|
*numbuf = 0; /* Don't print the key number */
|
|
|
|
|
else
|
|
|
|
|
sprintf (numbuf, "%d", number);
|
|
|
|
|
send_status_info (ctrl, keyword,
|
|
|
|
|
numbuf, (size_t)strlen(numbuf),
|
|
|
|
|
buf, (size_t)strlen (buf), NULL, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2005-02-03 14:20:57 +01:00
|
|
|
|
static void
|
|
|
|
|
send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
|
|
|
|
|
int number, const unsigned char *stamp)
|
2011-02-04 12:57:53 +01:00
|
|
|
|
{
|
2005-02-03 14:20:57 +01:00
|
|
|
|
char numbuf1[50], numbuf2[50];
|
|
|
|
|
unsigned long value;
|
|
|
|
|
|
2015-02-11 10:27:57 +01:00
|
|
|
|
value = buf32_to_ulong (stamp);
|
2005-02-03 14:20:57 +01:00
|
|
|
|
if (!value)
|
|
|
|
|
return;
|
|
|
|
|
sprintf (numbuf1, "%d", number);
|
|
|
|
|
sprintf (numbuf2, "%lu", value);
|
|
|
|
|
send_status_info (ctrl, keyword,
|
|
|
|
|
numbuf1, (size_t)strlen(numbuf1),
|
|
|
|
|
numbuf2, (size_t)strlen(numbuf2), NULL, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
static void
|
2011-02-04 12:57:53 +01:00
|
|
|
|
send_key_data (ctrl_t ctrl, const char *name,
|
2003-08-05 19:11:04 +02:00
|
|
|
|
const unsigned char *a, size_t alen)
|
|
|
|
|
{
|
2011-06-16 14:27:33 +02:00
|
|
|
|
char *buffer, *buf;
|
|
|
|
|
size_t buflen;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2011-06-16 14:27:33 +02:00
|
|
|
|
buffer = buf = bin2hex (a, alen, NULL);
|
|
|
|
|
if (!buffer)
|
2008-11-03 11:54:18 +01:00
|
|
|
|
{
|
|
|
|
|
log_error ("memory allocation error in send_key_data\n");
|
|
|
|
|
return;
|
|
|
|
|
}
|
2011-06-16 14:27:33 +02:00
|
|
|
|
buflen = strlen (buffer);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2011-06-16 14:27:33 +02:00
|
|
|
|
/* 768 is the hexified size for the modulus of an 3072 bit key. We
|
|
|
|
|
use extra chunks to transmit larger data (i.e for 4096 bit). */
|
|
|
|
|
for ( ;buflen > 768; buflen -= 768, buf += 768)
|
|
|
|
|
send_status_info (ctrl, "KEY-DATA",
|
|
|
|
|
"-", 1,
|
|
|
|
|
buf, 768,
|
|
|
|
|
NULL, 0);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
send_status_info (ctrl, "KEY-DATA",
|
2011-02-04 12:57:53 +01:00
|
|
|
|
name, (size_t)strlen(name),
|
2011-06-16 14:27:33 +02:00
|
|
|
|
buf, buflen,
|
2003-08-05 19:11:04 +02:00
|
|
|
|
NULL, 0);
|
2011-06-16 14:27:33 +02:00
|
|
|
|
xfree (buffer);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
2009-03-10 17:10:35 +01:00
|
|
|
|
|
2013-03-08 03:40:37 +01:00
|
|
|
|
static void
|
2015-07-25 05:09:23 +02:00
|
|
|
|
send_key_attr (ctrl_t ctrl, app_t app, const char *keyword, int keyno)
|
2011-02-04 12:57:53 +01:00
|
|
|
|
{
|
2009-03-10 17:10:35 +01:00
|
|
|
|
char buffer[200];
|
|
|
|
|
|
2015-07-25 05:09:23 +02:00
|
|
|
|
assert (keyno >=0 && keyno < DIM(app->app_local->keyattr));
|
2009-03-10 17:10:35 +01:00
|
|
|
|
|
2015-07-25 05:09:23 +02:00
|
|
|
|
if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
|
|
|
|
|
snprintf (buffer, sizeof buffer, "%d 1 rsa%u %u %d",
|
|
|
|
|
keyno+1,
|
|
|
|
|
app->app_local->keyattr[keyno].rsa.n_bits,
|
|
|
|
|
app->app_local->keyattr[keyno].rsa.e_bits,
|
|
|
|
|
app->app_local->keyattr[keyno].rsa.format);
|
|
|
|
|
else if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_ECC)
|
2014-04-09 02:30:19 +02:00
|
|
|
|
{
|
2015-07-25 05:09:23 +02:00
|
|
|
|
snprintf (buffer, sizeof buffer, "%d %d %s",
|
|
|
|
|
keyno+1,
|
2015-08-06 10:00:41 +02:00
|
|
|
|
keyno==1? PUBKEY_ALGO_ECDH :
|
2016-09-16 08:20:32 +02:00
|
|
|
|
(app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK)?
|
2015-08-06 10:00:41 +02:00
|
|
|
|
PUBKEY_ALGO_EDDSA : PUBKEY_ALGO_ECDSA,
|
2016-10-24 04:22:44 +02:00
|
|
|
|
app->app_local->keyattr[keyno].ecc.curve);
|
2014-04-09 02:30:19 +02:00
|
|
|
|
}
|
2013-03-08 03:40:37 +01:00
|
|
|
|
else
|
2015-08-05 00:59:50 +02:00
|
|
|
|
snprintf (buffer, sizeof buffer, "%d 0 0 UNKNOWN", keyno+1);
|
2013-03-08 03:40:37 +01:00
|
|
|
|
|
2009-03-10 17:10:35 +01:00
|
|
|
|
send_status_direct (ctrl, keyword, buffer);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-11-25 08:12:26 +01:00
|
|
|
|
#define RSA_SMALL_SIZE_KEY 1952
|
|
|
|
|
#define RSA_SMALL_SIZE_OP 2048
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
determine_rsa_response (app_t app, int keyno)
|
|
|
|
|
{
|
|
|
|
|
int size;
|
|
|
|
|
|
|
|
|
|
size = 2 + 3 /* header */
|
2017-08-27 16:42:52 +02:00
|
|
|
|
+ 4 /* tag+len */ + (app->app_local->keyattr[keyno].rsa.n_bits+7)/8
|
|
|
|
|
+ 2 /* tag+len */ + (app->app_local->keyattr[keyno].rsa.e_bits+7)/8;
|
2016-11-25 08:12:26 +01:00
|
|
|
|
|
|
|
|
|
return size;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-09-30 19:35:05 +02:00
|
|
|
|
/* Implement the GETATTR command. This is similar to the LEARN
|
|
|
|
|
command but returns just one value via the status interface. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
static gpg_error_t
|
2004-10-14 15:22:03 +02:00
|
|
|
|
do_getattr (app_t app, ctrl_t ctrl, const char *name)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
2003-09-30 19:35:05 +02:00
|
|
|
|
static struct {
|
|
|
|
|
const char *name;
|
|
|
|
|
int tag;
|
|
|
|
|
int special;
|
|
|
|
|
} table[] = {
|
|
|
|
|
{ "DISP-NAME", 0x005B },
|
|
|
|
|
{ "LOGIN-DATA", 0x005E },
|
|
|
|
|
{ "DISP-LANG", 0x5F2D },
|
|
|
|
|
{ "DISP-SEX", 0x5F35 },
|
|
|
|
|
{ "PUBKEY-URL", 0x5F50 },
|
|
|
|
|
{ "KEY-FPR", 0x00C5, 3 },
|
2005-02-03 14:20:57 +01:00
|
|
|
|
{ "KEY-TIME", 0x00CD, 4 },
|
2009-03-10 17:10:35 +01:00
|
|
|
|
{ "KEY-ATTR", 0x0000, -5 },
|
2003-09-30 19:35:05 +02:00
|
|
|
|
{ "CA-FPR", 0x00C6, 3 },
|
2011-02-04 12:57:53 +01:00
|
|
|
|
{ "CHV-STATUS", 0x00C4, 1 },
|
2003-09-30 19:35:05 +02:00
|
|
|
|
{ "SIG-COUNTER", 0x0093, 2 },
|
2003-10-08 12:46:58 +02:00
|
|
|
|
{ "SERIALNO", 0x004F, -1 },
|
|
|
|
|
{ "AID", 0x004F },
|
2004-09-30 15:24:33 +02:00
|
|
|
|
{ "EXTCAP", 0x0000, -2 },
|
2005-02-03 14:20:57 +01:00
|
|
|
|
{ "PRIVATE-DO-1", 0x0101 },
|
|
|
|
|
{ "PRIVATE-DO-2", 0x0102 },
|
|
|
|
|
{ "PRIVATE-DO-3", 0x0103 },
|
|
|
|
|
{ "PRIVATE-DO-4", 0x0104 },
|
2005-09-09 13:18:08 +02:00
|
|
|
|
{ "$AUTHKEYID", 0x0000, -3 },
|
2019-04-03 13:16:22 +02:00
|
|
|
|
{ "$ENCRKEYID", 0x0000, -6 },
|
|
|
|
|
{ "$SIGNKEYID", 0x0000, -7 },
|
2005-09-09 13:18:08 +02:00
|
|
|
|
{ "$DISPSERIALNO",0x0000, -4 },
|
2020-02-17 09:44:59 +01:00
|
|
|
|
{ "KDF", 0x00F9, 5 },
|
2020-04-03 09:56:56 +02:00
|
|
|
|
{ "MANUFACTURER", 0x0000, -8 },
|
2003-09-30 19:35:05 +02:00
|
|
|
|
{ NULL, 0 }
|
|
|
|
|
};
|
2005-02-24 18:36:11 +01:00
|
|
|
|
int idx, i, rc;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
void *relptr;
|
|
|
|
|
unsigned char *value;
|
|
|
|
|
size_t valuelen;
|
|
|
|
|
|
2003-09-30 19:35:05 +02:00
|
|
|
|
for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
|
|
|
|
|
;
|
|
|
|
|
if (!table[idx].name)
|
2011-02-04 12:57:53 +01:00
|
|
|
|
return gpg_error (GPG_ERR_INV_NAME);
|
|
|
|
|
|
2003-10-08 12:46:58 +02:00
|
|
|
|
if (table[idx].special == -1)
|
|
|
|
|
{
|
|
|
|
|
/* The serial number is very special. We could have used the
|
2017-01-18 07:48:50 +01:00
|
|
|
|
AID DO to retrieve it. The AID DO is available anyway but
|
|
|
|
|
not hex formatted. */
|
|
|
|
|
char *serial = app_get_serialno (app);
|
|
|
|
|
|
|
|
|
|
if (serial)
|
2003-10-08 12:46:58 +02:00
|
|
|
|
{
|
2017-01-18 07:48:50 +01:00
|
|
|
|
send_status_direct (ctrl, "SERIALNO", serial);
|
2003-10-08 12:46:58 +02:00
|
|
|
|
xfree (serial);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2004-09-30 15:24:33 +02:00
|
|
|
|
if (table[idx].special == -2)
|
|
|
|
|
{
|
2014-12-15 17:38:40 +01:00
|
|
|
|
char tmp[110];
|
2009-03-10 17:10:35 +01:00
|
|
|
|
|
|
|
|
|
snprintf (tmp, sizeof tmp,
|
2015-06-26 08:14:27 +02:00
|
|
|
|
"gc=%d ki=%d fc=%d pd=%d mcl3=%u aac=%d "
|
2018-03-22 07:50:31 +01:00
|
|
|
|
"sm=%d si=%u dec=%d bt=%d kdf=%d",
|
2009-03-10 17:10:35 +01:00
|
|
|
|
app->app_local->extcap.get_challenge,
|
|
|
|
|
app->app_local->extcap.key_import,
|
|
|
|
|
app->app_local->extcap.change_force_chv,
|
|
|
|
|
app->app_local->extcap.private_dos,
|
|
|
|
|
app->app_local->extcap.max_certlen_3,
|
2009-06-09 21:11:28 +02:00
|
|
|
|
app->app_local->extcap.algo_attr_change,
|
|
|
|
|
(app->app_local->extcap.sm_supported
|
2015-07-17 02:34:47 +02:00
|
|
|
|
? (app->app_local->extcap.sm_algo == 0? CIPHER_ALGO_3DES :
|
|
|
|
|
(app->app_local->extcap.sm_algo == 1?
|
|
|
|
|
CIPHER_ALGO_AES : CIPHER_ALGO_AES256))
|
2014-12-15 17:38:40 +01:00
|
|
|
|
: 0),
|
2015-06-26 08:14:27 +02:00
|
|
|
|
app->app_local->status_indicator,
|
|
|
|
|
app->app_local->extcap.has_decrypt,
|
2018-03-22 07:50:31 +01:00
|
|
|
|
app->app_local->extcap.has_button,
|
|
|
|
|
app->app_local->extcap.kdf_do);
|
2004-09-30 15:24:33 +02:00
|
|
|
|
send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2005-09-09 13:18:08 +02:00
|
|
|
|
if (table[idx].special == -3)
|
|
|
|
|
{
|
|
|
|
|
char const tmp[] = "OPENPGP.3";
|
|
|
|
|
send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (table[idx].special == -4)
|
|
|
|
|
{
|
2017-01-18 07:48:50 +01:00
|
|
|
|
char *serial = app_get_serialno (app);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2017-01-18 07:48:50 +01:00
|
|
|
|
if (serial)
|
2005-09-09 13:18:08 +02:00
|
|
|
|
{
|
|
|
|
|
if (strlen (serial) > 16+12)
|
|
|
|
|
{
|
|
|
|
|
send_status_info (ctrl, table[idx].name, serial+16, 12, NULL, 0);
|
|
|
|
|
xfree (serial);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
xfree (serial);
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
return gpg_error (GPG_ERR_INV_NAME);
|
2005-09-09 13:18:08 +02:00
|
|
|
|
}
|
2009-03-10 17:10:35 +01:00
|
|
|
|
if (table[idx].special == -5)
|
|
|
|
|
{
|
|
|
|
|
for (i=0; i < 3; i++)
|
|
|
|
|
send_key_attr (ctrl, app, table[idx].name, i);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2019-04-03 13:16:22 +02:00
|
|
|
|
if (table[idx].special == -6)
|
|
|
|
|
{
|
|
|
|
|
char const tmp[] = "OPENPGP.2";
|
|
|
|
|
send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (table[idx].special == -7)
|
|
|
|
|
{
|
|
|
|
|
char const tmp[] = "OPENPGP.1";
|
|
|
|
|
send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2020-04-03 09:56:56 +02:00
|
|
|
|
if (table[idx].special == -8)
|
|
|
|
|
{
|
|
|
|
|
return send_status_printf
|
|
|
|
|
(ctrl, table[idx].name, "%u %s",
|
|
|
|
|
app->app_local->manufacturer,
|
|
|
|
|
get_manufacturer (app->app_local->manufacturer));
|
|
|
|
|
}
|
2003-10-08 12:46:58 +02:00
|
|
|
|
|
2005-02-24 18:36:11 +01:00
|
|
|
|
relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (relptr)
|
|
|
|
|
{
|
2003-09-30 19:35:05 +02:00
|
|
|
|
if (table[idx].special == 1)
|
|
|
|
|
{
|
|
|
|
|
char numbuf[7*23];
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-09-30 19:35:05 +02:00
|
|
|
|
for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
|
2011-02-04 12:57:53 +01:00
|
|
|
|
sprintf (numbuf+strlen (numbuf), " %d", value[i]);
|
2003-09-30 19:35:05 +02:00
|
|
|
|
send_status_info (ctrl, table[idx].name,
|
|
|
|
|
numbuf, strlen (numbuf), NULL, 0);
|
|
|
|
|
}
|
|
|
|
|
else if (table[idx].special == 2)
|
|
|
|
|
{
|
|
|
|
|
char numbuf[50];
|
|
|
|
|
|
|
|
|
|
sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
|
|
|
|
|
send_status_info (ctrl, table[idx].name,
|
|
|
|
|
numbuf, strlen (numbuf), NULL, 0);
|
|
|
|
|
}
|
|
|
|
|
else if (table[idx].special == 3)
|
|
|
|
|
{
|
|
|
|
|
if (valuelen >= 60)
|
|
|
|
|
for (i=0; i < 3; i++)
|
2004-07-01 19:41:33 +02:00
|
|
|
|
send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
|
2003-09-30 19:35:05 +02:00
|
|
|
|
}
|
2005-02-03 14:20:57 +01:00
|
|
|
|
else if (table[idx].special == 4)
|
|
|
|
|
{
|
|
|
|
|
if (valuelen >= 12)
|
|
|
|
|
for (i=0; i < 3; i++)
|
|
|
|
|
send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
|
|
|
|
|
}
|
2020-02-17 09:44:59 +01:00
|
|
|
|
else if (table[idx].special == 5)
|
|
|
|
|
{
|
|
|
|
|
if ((valuelen == KDF_DATA_LENGTH_MIN
|
|
|
|
|
|| valuelen == KDF_DATA_LENGTH_MAX)
|
|
|
|
|
&& (value[2] == 0x03))
|
|
|
|
|
app->app_local->pinpad.disabled = 1;
|
|
|
|
|
else
|
|
|
|
|
app->app_local->pinpad.disabled = 0;
|
2020-02-28 07:56:53 +01:00
|
|
|
|
|
|
|
|
|
send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
|
2020-02-17 09:44:59 +01:00
|
|
|
|
}
|
2003-09-30 19:35:05 +02:00
|
|
|
|
else
|
|
|
|
|
send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
|
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
xfree (relptr);
|
|
|
|
|
}
|
2020-02-17 09:44:59 +01:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (table[idx].special == 5)
|
|
|
|
|
app->app_local->pinpad.disabled = 0;
|
|
|
|
|
}
|
2005-02-24 18:36:11 +01:00
|
|
|
|
return rc;
|
2003-09-30 19:35:05 +02:00
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2017-02-22 13:03:52 +01:00
|
|
|
|
|
|
|
|
|
/* Return the DISP-NAME without any padding characters. Caller must
|
|
|
|
|
* free the result. If not found or empty NULL is returned. */
|
|
|
|
|
static char *
|
|
|
|
|
get_disp_name (app_t app)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
void *relptr;
|
|
|
|
|
unsigned char *value;
|
|
|
|
|
size_t valuelen;
|
|
|
|
|
char *string;
|
|
|
|
|
char *p, *given;
|
|
|
|
|
char *result;
|
|
|
|
|
|
|
|
|
|
relptr = get_one_do (app, 0x005B, &value, &valuelen, &rc);
|
|
|
|
|
if (!relptr)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
string = xtrymalloc (valuelen + 1);
|
|
|
|
|
if (!string)
|
|
|
|
|
{
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
memcpy (string, value, valuelen);
|
|
|
|
|
string[valuelen] = 0;
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
|
|
|
|
|
/* Swap surname and given name. */
|
|
|
|
|
given = strstr (string, "<<");
|
|
|
|
|
for (p = string; *p; p++)
|
|
|
|
|
if (*p == '<')
|
|
|
|
|
*p = ' ';
|
|
|
|
|
|
|
|
|
|
if (given && given[2])
|
|
|
|
|
{
|
|
|
|
|
*given = 0;
|
|
|
|
|
given += 2;
|
|
|
|
|
result = strconcat (given, " ", string, NULL);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
result = string;
|
|
|
|
|
string = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
xfree (string);
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return the pretty formatted serialnumber. On error NULL is
|
|
|
|
|
* returned. */
|
|
|
|
|
static char *
|
|
|
|
|
get_disp_serialno (app_t app)
|
|
|
|
|
{
|
|
|
|
|
char *serial = app_get_serialno (app);
|
|
|
|
|
|
|
|
|
|
/* For our OpenPGP cards we do not want to show the entire serial
|
|
|
|
|
* number but a nicely reformatted actual serial number. */
|
|
|
|
|
if (serial && strlen (serial) > 16+12)
|
|
|
|
|
{
|
|
|
|
|
memmove (serial, serial+16, 4);
|
|
|
|
|
serial[4] = ' ';
|
|
|
|
|
/* memmove (serial+5, serial+20, 4); */
|
|
|
|
|
/* serial[9] = ' '; */
|
|
|
|
|
/* memmove (serial+10, serial+24, 4); */
|
|
|
|
|
/* serial[14] = 0; */
|
|
|
|
|
memmove (serial+5, serial+20, 8);
|
|
|
|
|
serial[13] = 0;
|
|
|
|
|
}
|
|
|
|
|
return serial;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return the number of remaining tries for the standard or the admin
|
|
|
|
|
* pw. Returns -1 on card error. */
|
|
|
|
|
static int
|
|
|
|
|
get_remaining_tries (app_t app, int adminpw)
|
|
|
|
|
{
|
|
|
|
|
void *relptr;
|
|
|
|
|
unsigned char *value;
|
|
|
|
|
size_t valuelen;
|
|
|
|
|
int remaining;
|
|
|
|
|
|
|
|
|
|
relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
|
|
|
|
|
if (!relptr || valuelen < 7)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("error retrieving CHV status from card\n"));
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
remaining = value[adminpw? 6 : 4];
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
return remaining;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-03-29 22:46:18 +02:00
|
|
|
|
/* Retrieve the fingerprint from the card inserted in SLOT and write
|
2005-04-14 19:25:43 +02:00
|
|
|
|
the according hex representation to FPR. Caller must have provide
|
|
|
|
|
a buffer at FPR of least 41 bytes. Returns 0 on success or an
|
|
|
|
|
error code. */
|
|
|
|
|
#if GNUPG_MAJOR_VERSION > 1
|
2005-03-29 22:46:18 +02:00
|
|
|
|
static gpg_error_t
|
2005-04-14 19:25:43 +02:00
|
|
|
|
retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
|
2005-03-29 22:46:18 +02:00
|
|
|
|
{
|
2005-04-14 19:25:43 +02:00
|
|
|
|
gpg_error_t err = 0;
|
|
|
|
|
void *relptr;
|
|
|
|
|
unsigned char *value;
|
|
|
|
|
size_t valuelen;
|
2005-03-29 22:46:18 +02:00
|
|
|
|
|
2005-04-14 19:25:43 +02:00
|
|
|
|
assert (keyno >=0 && keyno <= 2);
|
2005-03-29 22:46:18 +02:00
|
|
|
|
|
2005-04-14 19:25:43 +02:00
|
|
|
|
relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
|
|
|
|
|
if (relptr && valuelen >= 60)
|
2008-11-03 11:54:18 +01:00
|
|
|
|
bin2hex (value+keyno*20, 20, fpr);
|
2005-04-14 19:25:43 +02:00
|
|
|
|
else
|
|
|
|
|
err = gpg_error (GPG_ERR_NOT_FOUND);
|
|
|
|
|
xfree (relptr);
|
2005-03-29 22:46:18 +02:00
|
|
|
|
return err;
|
|
|
|
|
}
|
2005-04-14 19:25:43 +02:00
|
|
|
|
#endif /*GNUPG_MAJOR_VERSION > 1*/
|
2005-03-29 22:46:18 +02:00
|
|
|
|
|
|
|
|
|
|
2005-04-14 19:25:43 +02:00
|
|
|
|
/* Retrieve the public key material for the RSA key, whose fingerprint
|
|
|
|
|
is FPR, from gpg output, which can be read through the stream FP.
|
|
|
|
|
The RSA modulus will be stored at the address of M and MLEN, the
|
|
|
|
|
public exponent at E and ELEN. Returns zero on success, an error
|
|
|
|
|
code on failure. Caller must release the allocated buffers at M
|
|
|
|
|
and E if the function returns success. */
|
|
|
|
|
#if GNUPG_MAJOR_VERSION > 1
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
retrieve_key_material (FILE *fp, const char *hexkeyid,
|
2016-11-04 05:45:57 +01:00
|
|
|
|
const unsigned char **m, size_t *mlen,
|
|
|
|
|
const unsigned char **e, size_t *elen)
|
2005-03-29 22:46:18 +02:00
|
|
|
|
{
|
2005-04-14 19:25:43 +02:00
|
|
|
|
gcry_error_t err = 0;
|
|
|
|
|
char *line = NULL; /* read_line() buffer. */
|
|
|
|
|
size_t line_size = 0; /* Helper for for read_line. */
|
|
|
|
|
int found_key = 0; /* Helper to find a matching key. */
|
|
|
|
|
unsigned char *m_new = NULL;
|
|
|
|
|
unsigned char *e_new = NULL;
|
|
|
|
|
size_t m_new_n = 0;
|
|
|
|
|
size_t e_new_n = 0;
|
|
|
|
|
|
|
|
|
|
/* Loop over all records until we have found the subkey
|
2008-09-23 17:42:11 +02:00
|
|
|
|
corresponding to the fingerprint. Inm general the first record
|
2005-04-14 19:25:43 +02:00
|
|
|
|
should be the pub record, but we don't rely on that. Given that
|
|
|
|
|
we only need to look at one key, it is sufficient to compare the
|
|
|
|
|
keyid so that we don't need to look at "fpr" records. */
|
|
|
|
|
for (;;)
|
2005-03-29 22:46:18 +02:00
|
|
|
|
{
|
2005-04-14 19:25:43 +02:00
|
|
|
|
char *p;
|
2014-12-22 01:27:00 +01:00
|
|
|
|
char *fields[6] = { NULL, NULL, NULL, NULL, NULL, NULL };
|
2005-04-14 19:25:43 +02:00
|
|
|
|
int nfields;
|
|
|
|
|
size_t max_length;
|
|
|
|
|
gcry_mpi_t mpi;
|
|
|
|
|
int i;
|
2005-03-29 22:46:18 +02:00
|
|
|
|
|
2005-04-14 19:25:43 +02:00
|
|
|
|
max_length = 4096;
|
|
|
|
|
i = read_line (fp, &line, &line_size, &max_length);
|
|
|
|
|
if (!i)
|
|
|
|
|
break; /* EOF. */
|
|
|
|
|
if (i < 0)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave; /* Error. */
|
|
|
|
|
}
|
2005-04-14 19:25:43 +02:00
|
|
|
|
if (!max_length)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_TRUNCATED);
|
|
|
|
|
goto leave; /* Line truncated - we better stop processing. */
|
|
|
|
|
}
|
2005-03-29 22:46:18 +02:00
|
|
|
|
|
2005-04-14 19:25:43 +02:00
|
|
|
|
/* Parse the line into fields. */
|
|
|
|
|
for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
|
|
|
|
|
{
|
|
|
|
|
fields[nfields] = p;
|
|
|
|
|
p = strchr (p, ':');
|
|
|
|
|
if (p)
|
|
|
|
|
*(p++) = 0;
|
|
|
|
|
}
|
|
|
|
|
if (!nfields)
|
|
|
|
|
continue; /* No fields at all - skip line. */
|
2005-03-29 22:46:18 +02:00
|
|
|
|
|
2005-04-14 19:25:43 +02:00
|
|
|
|
if (!found_key)
|
|
|
|
|
{
|
|
|
|
|
if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
|
|
|
|
|
&& nfields > 4 && !strcmp (fields[4], hexkeyid))
|
|
|
|
|
found_key = 1;
|
|
|
|
|
continue;
|
2016-11-04 05:45:57 +01:00
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2005-04-14 19:25:43 +02:00
|
|
|
|
if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
|
|
|
|
|
break; /* Next key - stop. */
|
|
|
|
|
|
|
|
|
|
if ( strcmp (fields[0], "pkd") )
|
|
|
|
|
continue; /* Not a key data record. */
|
|
|
|
|
if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
|
|
|
|
|
|| (!i && m_new) || (i && e_new))
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_GENERAL);
|
|
|
|
|
goto leave; /* Error: Invalid key data record or not an RSA key. */
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2005-04-14 19:25:43 +02:00
|
|
|
|
err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
mpi = NULL;
|
|
|
|
|
else if (!i)
|
|
|
|
|
err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
|
|
|
|
|
else
|
|
|
|
|
err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
|
|
|
|
|
gcry_mpi_release (mpi);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2005-04-14 19:25:43 +02:00
|
|
|
|
if (m_new && e_new)
|
2005-03-29 22:46:18 +02:00
|
|
|
|
{
|
2005-04-14 19:25:43 +02:00
|
|
|
|
*m = m_new;
|
|
|
|
|
*mlen = m_new_n;
|
|
|
|
|
m_new = NULL;
|
|
|
|
|
*e = e_new;
|
|
|
|
|
*elen = e_new_n;
|
|
|
|
|
e_new = NULL;
|
2005-03-29 22:46:18 +02:00
|
|
|
|
}
|
2005-04-14 19:25:43 +02:00
|
|
|
|
else
|
|
|
|
|
err = gpg_error (GPG_ERR_GENERAL);
|
2005-03-29 22:46:18 +02:00
|
|
|
|
|
2005-04-14 19:25:43 +02:00
|
|
|
|
leave:
|
|
|
|
|
xfree (m_new);
|
|
|
|
|
xfree (e_new);
|
|
|
|
|
xfree (line);
|
|
|
|
|
return err;
|
2005-03-29 22:46:18 +02:00
|
|
|
|
}
|
2005-04-14 19:25:43 +02:00
|
|
|
|
#endif /*GNUPG_MAJOR_VERSION > 1*/
|
|
|
|
|
|
2003-09-30 19:35:05 +02:00
|
|
|
|
|
2016-10-20 09:25:47 +02:00
|
|
|
|
static gpg_error_t
|
|
|
|
|
rsa_read_pubkey (app_t app, ctrl_t ctrl, u32 created_at, int keyno,
|
|
|
|
|
const unsigned char *data, size_t datalen, gcry_sexp_t *r_sexp)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
const unsigned char *m, *e;
|
|
|
|
|
size_t mlen, elen;
|
|
|
|
|
unsigned char *mbuf = NULL, *ebuf = NULL;
|
|
|
|
|
|
|
|
|
|
m = find_tlv (data, datalen, 0x0081, &mlen);
|
|
|
|
|
if (!m)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("response does not contain the RSA modulus\n"));
|
|
|
|
|
return gpg_error (GPG_ERR_CARD);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
e = find_tlv (data, datalen, 0x0082, &elen);
|
|
|
|
|
if (!e)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("response does not contain the RSA public exponent\n"));
|
|
|
|
|
return gpg_error (GPG_ERR_CARD);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ctrl)
|
|
|
|
|
{
|
|
|
|
|
send_key_data (ctrl, "n", m, mlen);
|
|
|
|
|
send_key_data (ctrl, "e", e, elen);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
|
|
|
|
|
;
|
|
|
|
|
for (; elen && !*e; elen--, e++) /* strip leading zeroes */
|
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
if (ctrl)
|
|
|
|
|
{
|
|
|
|
|
unsigned char fprbuf[20];
|
|
|
|
|
|
|
|
|
|
err = store_fpr (app, keyno, created_at, fprbuf, PUBKEY_ALGO_RSA,
|
|
|
|
|
m, mlen, e, elen);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mbuf = xtrymalloc (mlen + 1);
|
|
|
|
|
if (!mbuf)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
/* Prepend numbers with a 0 if needed. */
|
|
|
|
|
if (mlen && (*m & 0x80))
|
|
|
|
|
{
|
|
|
|
|
*mbuf = 0;
|
|
|
|
|
memcpy (mbuf+1, m, mlen);
|
|
|
|
|
mlen++;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
memcpy (mbuf, m, mlen);
|
|
|
|
|
|
|
|
|
|
ebuf = xtrymalloc (elen + 1);
|
|
|
|
|
if (!ebuf)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
/* Prepend numbers with a 0 if needed. */
|
|
|
|
|
if (elen && (*e & 0x80))
|
|
|
|
|
{
|
|
|
|
|
*ebuf = 0;
|
|
|
|
|
memcpy (ebuf+1, e, elen);
|
|
|
|
|
elen++;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
memcpy (ebuf, e, elen);
|
|
|
|
|
|
|
|
|
|
err = gcry_sexp_build (r_sexp, NULL, "(public-key(rsa(n%b)(e%b)))",
|
|
|
|
|
(int)mlen, mbuf, (int)elen, ebuf);
|
|
|
|
|
leave:
|
|
|
|
|
xfree (mbuf);
|
|
|
|
|
xfree (ebuf);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-24 04:22:44 +02:00
|
|
|
|
|
|
|
|
|
/* Determine KDF hash algorithm and KEK encryption algorithm by CURVE. */
|
|
|
|
|
static const unsigned char*
|
|
|
|
|
ecdh_params (const char *curve)
|
|
|
|
|
{
|
|
|
|
|
unsigned int nbits;
|
|
|
|
|
|
|
|
|
|
openpgp_curve_to_oid (curve, &nbits);
|
|
|
|
|
|
|
|
|
|
/* See RFC-6637 for those constants.
|
|
|
|
|
0x03: Number of bytes
|
|
|
|
|
0x01: Version for this parameter format
|
2019-03-13 01:12:14 +01:00
|
|
|
|
KDF hash algo
|
|
|
|
|
KEK symmetric cipher algo
|
2016-10-24 04:22:44 +02:00
|
|
|
|
*/
|
|
|
|
|
if (nbits <= 256)
|
|
|
|
|
return (const unsigned char*)"\x03\x01\x08\x07";
|
|
|
|
|
else if (nbits <= 384)
|
|
|
|
|
return (const unsigned char*)"\x03\x01\x09\x08";
|
|
|
|
|
else
|
|
|
|
|
return (const unsigned char*)"\x03\x01\x0a\x09";
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-20 09:25:47 +02:00
|
|
|
|
static gpg_error_t
|
|
|
|
|
ecc_read_pubkey (app_t app, ctrl_t ctrl, u32 created_at, int keyno,
|
|
|
|
|
const unsigned char *data, size_t datalen, gcry_sexp_t *r_sexp)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
2016-10-21 14:37:04 +02:00
|
|
|
|
unsigned char *qbuf = NULL;
|
2016-10-20 09:25:47 +02:00
|
|
|
|
const unsigned char *ecc_q;
|
|
|
|
|
size_t ecc_q_len;
|
2016-10-21 14:37:04 +02:00
|
|
|
|
gcry_mpi_t oid = NULL;
|
2016-10-20 09:25:47 +02:00
|
|
|
|
int n;
|
2016-10-24 04:22:44 +02:00
|
|
|
|
const char *curve;
|
|
|
|
|
const char *oidstr;
|
2016-10-20 09:25:47 +02:00
|
|
|
|
const unsigned char *oidbuf;
|
|
|
|
|
size_t oid_len;
|
|
|
|
|
int algo;
|
|
|
|
|
const char *format;
|
|
|
|
|
|
|
|
|
|
ecc_q = find_tlv (data, datalen, 0x0086, &ecc_q_len);
|
|
|
|
|
if (!ecc_q)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("response does not contain the EC public key\n"));
|
|
|
|
|
return gpg_error (GPG_ERR_CARD);
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-24 04:22:44 +02:00
|
|
|
|
curve = app->app_local->keyattr[keyno].ecc.curve;
|
|
|
|
|
oidstr = openpgp_curve_to_oid (curve, NULL);
|
|
|
|
|
err = openpgp_oid_from_str (oidstr, &oid);
|
2016-10-20 09:25:47 +02:00
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
oidbuf = gcry_mpi_get_opaque (oid, &n);
|
|
|
|
|
if (!oidbuf)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
2016-10-21 14:37:04 +02:00
|
|
|
|
goto leave;
|
2016-10-20 09:25:47 +02:00
|
|
|
|
}
|
|
|
|
|
oid_len = (n+7)/8;
|
|
|
|
|
|
|
|
|
|
qbuf = xtrymalloc (ecc_q_len + 1);
|
|
|
|
|
if (!qbuf)
|
2016-10-21 14:37:04 +02:00
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2016-10-20 09:25:47 +02:00
|
|
|
|
|
|
|
|
|
if ((app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
|
|
|
|
|
{ /* Prepend 0x40 prefix. */
|
|
|
|
|
*qbuf = 0x40;
|
|
|
|
|
memcpy (qbuf+1, ecc_q, ecc_q_len);
|
|
|
|
|
ecc_q_len++;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
memcpy (qbuf, ecc_q, ecc_q_len);
|
|
|
|
|
|
|
|
|
|
if (ctrl)
|
|
|
|
|
{
|
2016-10-21 14:37:04 +02:00
|
|
|
|
send_key_data (ctrl, "q", qbuf, ecc_q_len);
|
2016-10-20 09:25:47 +02:00
|
|
|
|
send_key_data (ctrl, "curve", oidbuf, oid_len);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (keyno == 1)
|
|
|
|
|
{
|
|
|
|
|
if (ctrl)
|
2016-10-24 04:22:44 +02:00
|
|
|
|
send_key_data (ctrl, "kdf/kek", ecdh_params (curve), (size_t)4);
|
2016-10-20 09:25:47 +02:00
|
|
|
|
algo = PUBKEY_ALGO_ECDH;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if ((app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
|
|
|
|
|
algo = PUBKEY_ALGO_EDDSA;
|
|
|
|
|
else
|
|
|
|
|
algo = PUBKEY_ALGO_ECDSA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ctrl)
|
|
|
|
|
{
|
|
|
|
|
unsigned char fprbuf[20];
|
|
|
|
|
|
|
|
|
|
err = store_fpr (app, keyno, created_at, fprbuf, algo, oidbuf, oid_len,
|
2016-10-24 04:22:44 +02:00
|
|
|
|
qbuf, ecc_q_len, ecdh_params (curve), (size_t)4);
|
2016-10-20 09:25:47 +02:00
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!(app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
|
|
|
|
|
format = "(public-key(ecc(curve%s)(q%b)))";
|
|
|
|
|
else if (keyno == 1)
|
|
|
|
|
format = "(public-key(ecc(curve%s)(flags djb-tweak)(q%b)))";
|
|
|
|
|
else
|
|
|
|
|
format = "(public-key(ecc(curve%s)(flags eddsa)(q%b)))";
|
|
|
|
|
|
2016-10-24 04:22:44 +02:00
|
|
|
|
err = gcry_sexp_build (r_sexp, NULL, format,
|
|
|
|
|
app->app_local->keyattr[keyno].ecc.curve,
|
|
|
|
|
(int)ecc_q_len, qbuf);
|
2016-10-20 09:25:47 +02:00
|
|
|
|
leave:
|
2016-10-21 14:37:04 +02:00
|
|
|
|
gcry_mpi_release (oid);
|
2016-10-20 09:25:47 +02:00
|
|
|
|
xfree (qbuf);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Parse tag-length-value data for public key in BUFFER of BUFLEN
|
|
|
|
|
length. Key of KEYNO in APP is updated with an S-expression of
|
|
|
|
|
public key. When CTRL is not NULL, fingerprint is computed with
|
|
|
|
|
CREATED_AT, and fingerprint is written to the card, and key data
|
|
|
|
|
and fingerprint are send back to the client side.
|
|
|
|
|
*/
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
read_public_key (app_t app, ctrl_t ctrl, u32 created_at, int keyno,
|
|
|
|
|
const unsigned char *buffer, size_t buflen)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
const unsigned char *data;
|
|
|
|
|
size_t datalen;
|
|
|
|
|
gcry_sexp_t s_pkey = NULL;
|
|
|
|
|
|
|
|
|
|
data = find_tlv (buffer, buflen, 0x7F49, &datalen);
|
|
|
|
|
if (!data)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("response does not contain the public key data\n"));
|
|
|
|
|
return gpg_error (GPG_ERR_CARD);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
|
|
|
|
|
err = rsa_read_pubkey (app, ctrl, created_at, keyno,
|
|
|
|
|
data, datalen, &s_pkey);
|
|
|
|
|
else if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_ECC)
|
|
|
|
|
err = ecc_read_pubkey (app, ctrl, created_at, keyno,
|
|
|
|
|
data, datalen, &s_pkey);
|
|
|
|
|
else
|
|
|
|
|
err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
|
|
|
|
|
|
|
|
|
|
if (!err)
|
|
|
|
|
{
|
|
|
|
|
unsigned char *keybuf;
|
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
|
|
len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
|
|
|
|
|
keybuf = xtrymalloc (len);
|
|
|
|
|
if (!data)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
gcry_sexp_release (s_pkey);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, keybuf, len);
|
|
|
|
|
gcry_sexp_release (s_pkey);
|
|
|
|
|
|
|
|
|
|
app->app_local->pk[keyno].key = keybuf;
|
|
|
|
|
/* Decrement for trailing '\0' */
|
|
|
|
|
app->app_local->pk[keyno].keylen = len - 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-04-28 03:06:33 +02:00
|
|
|
|
/* Get the public key for KEYNO and store it as an S-expression with
|
2005-02-22 18:29:07 +01:00
|
|
|
|
the APP handle. On error that field gets cleared. If we already
|
|
|
|
|
know about the public key we will just return. Note that this does
|
2015-11-16 12:41:46 +01:00
|
|
|
|
not mean a key is available; this is solely indicated by the
|
2015-09-07 06:09:01 +02:00
|
|
|
|
presence of the app->app_local->pk[KEYNO].key field.
|
2005-02-22 18:29:07 +01:00
|
|
|
|
|
|
|
|
|
Note that GnuPG 1.x does not need this and it would be too time
|
2005-04-11 18:20:10 +02:00
|
|
|
|
consuming to send it just for the fun of it. However, given that we
|
2017-04-28 03:06:33 +02:00
|
|
|
|
use the same code in gpg 1.4, we can't use the gcry S-expression
|
2005-04-11 18:20:10 +02:00
|
|
|
|
here but need to open encode it. */
|
2005-02-22 18:29:07 +01:00
|
|
|
|
#if GNUPG_MAJOR_VERSION > 1
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
get_public_key (app_t app, int keyno)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err = 0;
|
|
|
|
|
unsigned char *buffer;
|
2016-10-20 09:25:47 +02:00
|
|
|
|
const unsigned char *m, *e;
|
|
|
|
|
size_t buflen;
|
2013-03-08 03:40:37 +01:00
|
|
|
|
size_t mlen = 0;
|
|
|
|
|
size_t elen = 0;
|
2005-06-16 10:12:03 +02:00
|
|
|
|
char *keybuf = NULL;
|
2013-03-08 03:40:37 +01:00
|
|
|
|
gcry_sexp_t s_pkey;
|
|
|
|
|
size_t len;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
|
2015-09-07 06:09:01 +02:00
|
|
|
|
if (keyno < 0 || keyno > 2)
|
2005-02-22 18:29:07 +01:00
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
|
|
|
|
|
/* Already cached? */
|
|
|
|
|
if (app->app_local->pk[keyno].read_done)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2005-04-11 18:20:10 +02:00
|
|
|
|
xfree (app->app_local->pk[keyno].key);
|
2005-02-22 18:29:07 +01:00
|
|
|
|
app->app_local->pk[keyno].key = NULL;
|
2005-04-11 18:20:10 +02:00
|
|
|
|
app->app_local->pk[keyno].keylen = 0;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
|
2005-06-16 10:12:03 +02:00
|
|
|
|
m = e = NULL; /* (avoid cc warning) */
|
|
|
|
|
|
2005-02-22 18:29:07 +01:00
|
|
|
|
if (app->card_version > 0x0100)
|
|
|
|
|
{
|
2009-06-29 12:43:57 +02:00
|
|
|
|
int exmode, le_value;
|
|
|
|
|
|
2005-02-22 18:29:07 +01:00
|
|
|
|
/* We may simply read the public key out of these cards. */
|
2016-11-25 08:12:26 +01:00
|
|
|
|
if (app->app_local->cardcap.ext_lc_le
|
|
|
|
|
&& app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA
|
|
|
|
|
&& app->app_local->keyattr[keyno].rsa.n_bits > RSA_SMALL_SIZE_KEY)
|
2009-06-29 12:43:57 +02:00
|
|
|
|
{
|
|
|
|
|
exmode = 1; /* Use extended length. */
|
2016-11-25 08:12:26 +01:00
|
|
|
|
le_value = determine_rsa_response (app, keyno);
|
2009-06-29 12:43:57 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
exmode = 0;
|
|
|
|
|
le_value = 256; /* Use legacy value. */
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-18 13:40:09 +02:00
|
|
|
|
err = iso7816_read_public_key (app->slot, exmode,
|
|
|
|
|
(keyno == 0? "\xB6" :
|
|
|
|
|
keyno == 1? "\xB8" : "\xA4"),
|
|
|
|
|
2, le_value, &buffer, &buflen);
|
2005-02-22 18:29:07 +01:00
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-20 09:25:47 +02:00
|
|
|
|
err = read_public_key (app, NULL, 0U, keyno, buffer, buflen);
|
2005-02-22 18:29:07 +01:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Due to a design problem in v1.0 cards we can't get the public
|
|
|
|
|
key out of these cards without doing a verify on CHV3.
|
|
|
|
|
Clearly that is not an option and thus we try to locate the
|
2005-03-29 22:46:18 +02:00
|
|
|
|
key using an external helper.
|
|
|
|
|
|
2016-11-04 05:45:57 +01:00
|
|
|
|
The helper we use here is gpg itself, which should know about
|
|
|
|
|
the key in any case. */
|
2005-03-29 22:46:18 +02:00
|
|
|
|
|
2005-04-14 19:25:43 +02:00
|
|
|
|
char fpr[41];
|
|
|
|
|
char *hexkeyid;
|
|
|
|
|
char *command = NULL;
|
2005-03-29 22:46:18 +02:00
|
|
|
|
FILE *fp;
|
|
|
|
|
int ret;
|
|
|
|
|
|
2005-04-14 19:25:43 +02:00
|
|
|
|
buffer = NULL; /* We don't need buffer. */
|
2005-03-29 22:46:18 +02:00
|
|
|
|
|
2005-04-14 19:25:43 +02:00
|
|
|
|
err = retrieve_fpr_from_card (app, keyno, fpr);
|
2005-03-29 22:46:18 +02:00
|
|
|
|
if (err)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
{
|
|
|
|
|
log_error ("error while retrieving fpr from card: %s\n",
|
|
|
|
|
gpg_strerror (err));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2005-04-14 19:25:43 +02:00
|
|
|
|
hexkeyid = fpr + 24;
|
2005-03-29 22:46:18 +02:00
|
|
|
|
|
2014-08-26 17:47:22 +02:00
|
|
|
|
ret = gpgrt_asprintf
|
|
|
|
|
(&command, "gpg --list-keys --with-colons --with-key-data '%s'", fpr);
|
2005-03-29 22:46:18 +02:00
|
|
|
|
if (ret < 0)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2005-03-29 22:46:18 +02:00
|
|
|
|
|
|
|
|
|
fp = popen (command, "r");
|
2008-08-31 13:55:09 +02:00
|
|
|
|
xfree (command);
|
2005-04-14 19:25:43 +02:00
|
|
|
|
if (!fp)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
log_error ("running gpg failed: %s\n", gpg_strerror (err));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2005-03-29 22:46:18 +02:00
|
|
|
|
|
2005-04-14 19:25:43 +02:00
|
|
|
|
err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
|
2014-12-20 01:38:53 +01:00
|
|
|
|
pclose (fp);
|
2005-04-14 19:25:43 +02:00
|
|
|
|
if (err)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
{
|
|
|
|
|
log_error ("error while retrieving key material through pipe: %s\n",
|
2005-04-14 19:25:43 +02:00
|
|
|
|
gpg_strerror (err));
|
2016-11-04 05:45:57 +01:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2005-02-22 18:29:07 +01:00
|
|
|
|
|
2016-10-20 09:25:47 +02:00
|
|
|
|
err = gcry_sexp_build (&s_pkey, NULL, "(public-key(rsa(n%b)(e%b)))",
|
|
|
|
|
(int)mlen, m, (int)elen, e);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
2015-08-06 10:00:41 +02:00
|
|
|
|
|
2016-10-20 09:25:47 +02:00
|
|
|
|
len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2016-10-20 09:25:47 +02:00
|
|
|
|
keybuf = xtrymalloc (len);
|
|
|
|
|
if (!keybuf)
|
2013-03-08 03:40:37 +01:00
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
2016-10-20 09:25:47 +02:00
|
|
|
|
gcry_sexp_release (s_pkey);
|
2013-03-08 03:40:37 +01:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2015-08-06 10:00:41 +02:00
|
|
|
|
|
2016-10-20 09:25:47 +02:00
|
|
|
|
gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, keybuf, len);
|
2015-08-06 10:00:41 +02:00
|
|
|
|
gcry_sexp_release (s_pkey);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2016-10-20 09:25:47 +02:00
|
|
|
|
app->app_local->pk[keyno].key = (unsigned char*)keybuf;
|
|
|
|
|
/* Decrement for trailing '\0' */
|
|
|
|
|
app->app_local->pk[keyno].keylen = len - 1;
|
|
|
|
|
}
|
2005-02-22 18:29:07 +01:00
|
|
|
|
|
|
|
|
|
leave:
|
|
|
|
|
/* Set a flag to indicate that we tried to read the key. */
|
|
|
|
|
app->app_local->pk[keyno].read_done = 1;
|
|
|
|
|
|
|
|
|
|
xfree (buffer);
|
2015-11-17 18:05:51 +01:00
|
|
|
|
return err;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
}
|
|
|
|
|
#endif /* GNUPG_MAJOR_VERSION > 1 */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2015-09-07 06:09:01 +02:00
|
|
|
|
/* Send the KEYPAIRINFO back. KEY needs to be in the range [1,3].
|
2005-02-22 18:29:07 +01:00
|
|
|
|
This is used by the LEARN command. */
|
|
|
|
|
static gpg_error_t
|
2015-09-07 06:09:01 +02:00
|
|
|
|
send_keypair_info (app_t app, ctrl_t ctrl, int key)
|
2005-02-22 18:29:07 +01:00
|
|
|
|
{
|
2015-09-07 06:09:01 +02:00
|
|
|
|
int keyno = key - 1;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
gpg_error_t err = 0;
|
|
|
|
|
/* Note that GnuPG 1.x does not need this and it would be too time
|
|
|
|
|
consuming to send it just for the fun of it. */
|
|
|
|
|
#if GNUPG_MAJOR_VERSION > 1
|
|
|
|
|
unsigned char grip[20];
|
|
|
|
|
char gripstr[41];
|
|
|
|
|
char idbuf[50];
|
2019-08-21 11:58:12 +02:00
|
|
|
|
const char *usage;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
|
|
|
|
|
err = get_public_key (app, keyno);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2015-09-07 06:09:01 +02:00
|
|
|
|
assert (keyno >= 0 && keyno <= 2);
|
|
|
|
|
if (!app->app_local->pk[keyno].key)
|
2005-04-11 18:20:10 +02:00
|
|
|
|
goto leave; /* No such key - ignore. */
|
2005-02-22 18:29:07 +01:00
|
|
|
|
|
2015-09-07 06:09:01 +02:00
|
|
|
|
err = keygrip_from_canon_sexp (app->app_local->pk[keyno].key,
|
|
|
|
|
app->app_local->pk[keyno].keylen,
|
2005-04-11 18:20:10 +02:00
|
|
|
|
grip);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2008-11-03 11:54:18 +01:00
|
|
|
|
bin2hex (grip, 20, gripstr);
|
2005-02-22 18:29:07 +01:00
|
|
|
|
|
2019-08-21 11:58:12 +02:00
|
|
|
|
switch (keyno)
|
|
|
|
|
{
|
|
|
|
|
case 0: usage = "sc"; break;
|
|
|
|
|
case 1: usage = "e"; break;
|
|
|
|
|
case 2: usage = "sa"; break;
|
|
|
|
|
default: usage = ""; break;
|
|
|
|
|
}
|
|
|
|
|
|
2015-09-07 06:09:01 +02:00
|
|
|
|
sprintf (idbuf, "OPENPGP.%d", keyno+1);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
send_status_info (ctrl, "KEYPAIRINFO",
|
|
|
|
|
gripstr, 40,
|
|
|
|
|
idbuf, strlen (idbuf),
|
2019-08-21 11:58:12 +02:00
|
|
|
|
usage, strlen (usage),
|
2005-02-22 18:29:07 +01:00
|
|
|
|
NULL, (size_t)0);
|
|
|
|
|
|
|
|
|
|
leave:
|
|
|
|
|
#endif /* GNUPG_MAJOR_VERSION > 1 */
|
|
|
|
|
|
2011-02-04 12:57:53 +01:00
|
|
|
|
return err;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Handle the LEARN command for OpenPGP. */
|
2005-05-18 12:48:06 +02:00
|
|
|
|
static gpg_error_t
|
2009-03-18 12:18:56 +01:00
|
|
|
|
do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
|
2003-09-30 19:35:05 +02:00
|
|
|
|
{
|
2020-09-30 03:48:49 +02:00
|
|
|
|
gpg_error_t err = 0;
|
|
|
|
|
|
2009-03-18 12:18:56 +01:00
|
|
|
|
(void)flags;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2020-09-30 03:48:49 +02:00
|
|
|
|
err = do_getattr (app, ctrl, "EXTCAP");
|
|
|
|
|
if (!err)
|
|
|
|
|
err = do_getattr (app, ctrl, "MANUFACTURER");
|
|
|
|
|
if (!err)
|
|
|
|
|
err = do_getattr (app, ctrl, "DISP-NAME");
|
|
|
|
|
if (!err)
|
|
|
|
|
err = do_getattr (app, ctrl, "DISP-LANG");
|
|
|
|
|
if (!err)
|
|
|
|
|
err = do_getattr (app, ctrl, "DISP-SEX");
|
|
|
|
|
if (!err)
|
|
|
|
|
err = do_getattr (app, ctrl, "PUBKEY-URL");
|
|
|
|
|
if (!err)
|
|
|
|
|
err = do_getattr (app, ctrl, "LOGIN-DATA");
|
|
|
|
|
if (!err)
|
|
|
|
|
err = do_getattr (app, ctrl, "KEY-FPR");
|
|
|
|
|
if (!err && app->card_version > 0x0100)
|
|
|
|
|
err = do_getattr (app, ctrl, "KEY-TIME");
|
|
|
|
|
if (!err)
|
|
|
|
|
err = do_getattr (app, ctrl, "CA-FPR");
|
|
|
|
|
if (!err)
|
|
|
|
|
err = do_getattr (app, ctrl, "CHV-STATUS");
|
|
|
|
|
if (!err)
|
|
|
|
|
err = do_getattr (app, ctrl, "SIG-COUNTER");
|
|
|
|
|
if (!err && app->app_local->extcap.kdf_do)
|
|
|
|
|
{
|
|
|
|
|
err = do_getattr (app, ctrl, "KDF");
|
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_NO_OBJ)
|
|
|
|
|
err = 0;
|
|
|
|
|
}
|
|
|
|
|
if (!err && app->app_local->extcap.private_dos)
|
2005-02-03 14:20:57 +01:00
|
|
|
|
{
|
2020-09-30 03:48:49 +02:00
|
|
|
|
if (!err)
|
|
|
|
|
err = do_getattr (app, ctrl, "PRIVATE-DO-1");
|
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_NO_OBJ)
|
|
|
|
|
err = 0;
|
|
|
|
|
if (!err)
|
|
|
|
|
err = do_getattr (app, ctrl, "PRIVATE-DO-2");
|
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_NO_OBJ)
|
|
|
|
|
err = 0;
|
|
|
|
|
if (!err && app->did_chv2)
|
|
|
|
|
err = do_getattr (app, ctrl, "PRIVATE-DO-3");
|
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_NO_OBJ)
|
|
|
|
|
err = 0;
|
|
|
|
|
if (!err && app->did_chv3)
|
|
|
|
|
err = do_getattr (app, ctrl, "PRIVATE-DO-4");
|
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_NO_OBJ)
|
|
|
|
|
err = 0;
|
2005-02-03 14:20:57 +01:00
|
|
|
|
}
|
2020-09-30 03:48:49 +02:00
|
|
|
|
if (!err)
|
|
|
|
|
err = send_keypair_info (app, ctrl, 1);
|
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_NO_OBJ)
|
|
|
|
|
err = 0;
|
|
|
|
|
if (!err)
|
|
|
|
|
err = send_keypair_info (app, ctrl, 2);
|
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_NO_OBJ)
|
|
|
|
|
err = 0;
|
|
|
|
|
if (!err)
|
|
|
|
|
err = send_keypair_info (app, ctrl, 3);
|
|
|
|
|
if (gpg_err_code (err) == GPG_ERR_NO_OBJ)
|
|
|
|
|
err = 0;
|
2008-09-23 17:42:11 +02:00
|
|
|
|
/* Note: We do not send the Cardholder Certificate, because that is
|
2015-11-16 12:41:46 +01:00
|
|
|
|
relatively long and for OpenPGP applications not really needed. */
|
2020-09-30 03:48:49 +02:00
|
|
|
|
return err;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Handle the READKEY command for OpenPGP. On success a canonical
|
|
|
|
|
encoded S-expression with the public key will get stored at PK and
|
|
|
|
|
its length (for assertions) at PKLEN; the caller must release that
|
|
|
|
|
buffer. On error PK and PKLEN are not changed and an error code is
|
|
|
|
|
returned. */
|
2005-05-18 12:48:06 +02:00
|
|
|
|
static gpg_error_t
|
2016-11-04 05:45:57 +01:00
|
|
|
|
do_readkey (app_t app, int advanced, const char *keyid,
|
|
|
|
|
unsigned char **pk, size_t *pklen)
|
2005-02-22 18:29:07 +01:00
|
|
|
|
{
|
2005-05-20 22:39:36 +02:00
|
|
|
|
#if GNUPG_MAJOR_VERSION > 1
|
2005-02-22 18:29:07 +01:00
|
|
|
|
gpg_error_t err;
|
|
|
|
|
int keyno;
|
|
|
|
|
unsigned char *buf;
|
|
|
|
|
|
|
|
|
|
if (!strcmp (keyid, "OPENPGP.1"))
|
2015-09-07 06:09:01 +02:00
|
|
|
|
keyno = 0;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
else if (!strcmp (keyid, "OPENPGP.2"))
|
2015-09-07 06:09:01 +02:00
|
|
|
|
keyno = 1;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
else if (!strcmp (keyid, "OPENPGP.3"))
|
2015-09-07 06:09:01 +02:00
|
|
|
|
keyno = 2;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
else
|
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
2003-09-30 19:35:05 +02:00
|
|
|
|
|
2005-02-22 18:29:07 +01:00
|
|
|
|
err = get_public_key (app, keyno);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
2015-09-07 06:09:01 +02:00
|
|
|
|
buf = app->app_local->pk[keyno].key;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
if (!buf)
|
2005-04-11 18:20:10 +02:00
|
|
|
|
return gpg_error (GPG_ERR_NO_PUBKEY);
|
2016-11-04 05:45:57 +01:00
|
|
|
|
|
|
|
|
|
if (advanced)
|
2005-07-20 17:05:05 +02:00
|
|
|
|
{
|
2016-11-04 05:45:57 +01:00
|
|
|
|
gcry_sexp_t s_key;
|
|
|
|
|
|
|
|
|
|
err = gcry_sexp_new (&s_key, buf, app->app_local->pk[keyno].keylen, 0);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
*pklen = gcry_sexp_sprint (s_key, GCRYSEXP_FMT_ADVANCED, NULL, 0);
|
|
|
|
|
*pk = xtrymalloc (*pklen);
|
|
|
|
|
if (!*pk)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
*pklen = 0;
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
gcry_sexp_sprint (s_key, GCRYSEXP_FMT_ADVANCED, *pk, *pklen);
|
|
|
|
|
gcry_sexp_release (s_key);
|
2016-11-04 07:34:35 +01:00
|
|
|
|
/* Decrement for trailing '\0' */
|
|
|
|
|
*pklen = *pklen - 1;
|
2016-11-04 05:45:57 +01:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
*pklen = app->app_local->pk[keyno].keylen;
|
|
|
|
|
*pk = xtrymalloc (*pklen);
|
|
|
|
|
if (!*pk)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
*pklen = 0;
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
memcpy (*pk, buf, *pklen);
|
2005-07-20 17:05:05 +02:00
|
|
|
|
}
|
2016-11-04 05:45:57 +01:00
|
|
|
|
|
2003-09-30 19:35:05 +02:00
|
|
|
|
return 0;
|
2005-05-20 22:39:36 +02:00
|
|
|
|
#else
|
|
|
|
|
return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
|
|
|
|
|
#endif
|
2003-09-30 19:35:05 +02:00
|
|
|
|
}
|
|
|
|
|
|
2008-09-23 11:57:45 +02:00
|
|
|
|
/* Read the standard certificate of an OpenPGP v2 card. It is
|
2008-07-17 21:40:53 +02:00
|
|
|
|
returned in a freshly allocated buffer with that address stored at
|
|
|
|
|
CERT and the length of the certificate stored at CERTLEN. CERTID
|
2008-09-23 11:57:45 +02:00
|
|
|
|
needs to be set to "OPENPGP.3". */
|
2008-07-17 21:40:53 +02:00
|
|
|
|
static gpg_error_t
|
|
|
|
|
do_readcert (app_t app, const char *certid,
|
|
|
|
|
unsigned char **cert, size_t *certlen)
|
|
|
|
|
{
|
|
|
|
|
#if GNUPG_MAJOR_VERSION > 1
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
unsigned char *buffer;
|
|
|
|
|
size_t buflen;
|
|
|
|
|
void *relptr;
|
|
|
|
|
|
|
|
|
|
*cert = NULL;
|
|
|
|
|
*certlen = 0;
|
|
|
|
|
if (strcmp (certid, "OPENPGP.3"))
|
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
2008-09-23 11:57:45 +02:00
|
|
|
|
if (!app->app_local->extcap.is_v2)
|
2008-07-17 21:40:53 +02:00
|
|
|
|
return gpg_error (GPG_ERR_NOT_FOUND);
|
|
|
|
|
|
2008-09-23 11:57:45 +02:00
|
|
|
|
relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
|
2008-07-17 21:40:53 +02:00
|
|
|
|
if (!relptr)
|
|
|
|
|
return gpg_error (GPG_ERR_NOT_FOUND);
|
|
|
|
|
|
2009-06-09 21:11:28 +02:00
|
|
|
|
if (!buflen)
|
|
|
|
|
err = gpg_error (GPG_ERR_NOT_FOUND);
|
|
|
|
|
else if (!(*cert = xtrymalloc (buflen)))
|
2008-07-17 21:40:53 +02:00
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
memcpy (*cert, buffer, buflen);
|
|
|
|
|
*certlen = buflen;
|
|
|
|
|
err = 0;
|
|
|
|
|
}
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
return err;
|
|
|
|
|
#else
|
|
|
|
|
return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2003-09-30 19:35:05 +02:00
|
|
|
|
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
/* Decide if we use the pinpad of the reader for PIN input according
|
2013-01-11 02:41:38 +01:00
|
|
|
|
to the user preference on the card, and the capability of the
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
reader. This routine is only called when the reader has pinpad.
|
|
|
|
|
Returns 0 if we use pinpad, 1 otherwise. */
|
2013-01-10 07:58:43 +01:00
|
|
|
|
static int
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
check_pinpad_request (app_t app, pininfo_t *pininfo, int admin_pin)
|
2013-01-10 07:58:43 +01:00
|
|
|
|
{
|
2020-02-17 09:44:59 +01:00
|
|
|
|
if (app->app_local->pinpad.disabled)
|
|
|
|
|
return 1;
|
|
|
|
|
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
if (app->app_local->pinpad.specified == 0) /* No preference on card. */
|
2013-01-13 04:12:10 +01:00
|
|
|
|
{
|
|
|
|
|
if (pininfo->fixedlen == 0) /* Reader has varlen capability. */
|
|
|
|
|
return 0; /* Then, use pinpad. */
|
|
|
|
|
else
|
|
|
|
|
/*
|
|
|
|
|
* Reader has limited capability, and it may not match PIN of
|
|
|
|
|
* the card.
|
|
|
|
|
*/
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
2013-01-11 02:41:38 +01:00
|
|
|
|
|
|
|
|
|
if (admin_pin)
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
pininfo->fixedlen = app->app_local->pinpad.fixedlen_admin;
|
2013-01-10 07:58:43 +01:00
|
|
|
|
else
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
pininfo->fixedlen = app->app_local->pinpad.fixedlen_user;
|
2013-01-10 07:58:43 +01:00
|
|
|
|
|
2013-02-05 06:59:29 +01:00
|
|
|
|
if (pininfo->fixedlen == 0 /* User requests disable pinpad. */
|
2013-01-11 02:41:38 +01:00
|
|
|
|
|| pininfo->fixedlen < pininfo->minlen
|
|
|
|
|
|| pininfo->fixedlen > pininfo->maxlen
|
|
|
|
|
/* Reader doesn't have the capability to input a PIN which
|
|
|
|
|
* length is FIXEDLEN. */)
|
|
|
|
|
return 1;
|
2013-01-10 07:58:43 +01:00
|
|
|
|
|
2013-01-11 02:41:38 +01:00
|
|
|
|
return 0;
|
2013-01-10 07:58:43 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-02-22 13:03:52 +01:00
|
|
|
|
/* Return a string with information about the card for use in a
|
|
|
|
|
* prompt. Returns NULL on memory failure. */
|
|
|
|
|
static char *
|
|
|
|
|
get_prompt_info (app_t app, int chvno, unsigned long sigcount, int remaining)
|
|
|
|
|
{
|
|
|
|
|
char *serial, *disp_name, *rembuf, *tmpbuf, *result;
|
|
|
|
|
|
|
|
|
|
serial = get_disp_serialno (app);
|
|
|
|
|
if (!serial)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
disp_name = get_disp_name (app);
|
|
|
|
|
if (chvno == 1)
|
|
|
|
|
{
|
2017-02-22 16:54:32 +01:00
|
|
|
|
/* TRANSLATORS: Put a \x1f right before a colon. This can be
|
|
|
|
|
* used by pinentry to nicely align the names and values. Keep
|
|
|
|
|
* the %s at the start and end of the string. */
|
|
|
|
|
result = xtryasprintf (_("%s"
|
|
|
|
|
"Number\x1f: %s%%0A"
|
|
|
|
|
"Holder\x1f: %s%%0A"
|
|
|
|
|
"Counter\x1f: %lu"
|
|
|
|
|
"%s"),
|
|
|
|
|
"\x1e",
|
2017-02-22 13:03:52 +01:00
|
|
|
|
serial,
|
2017-02-22 16:54:32 +01:00
|
|
|
|
disp_name? disp_name:"",
|
2017-02-22 18:49:43 +01:00
|
|
|
|
sigcount,
|
2017-02-22 16:54:32 +01:00
|
|
|
|
"");
|
2017-02-22 13:03:52 +01:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2017-02-22 16:54:32 +01:00
|
|
|
|
result = xtryasprintf (_("%s"
|
|
|
|
|
"Number\x1f: %s%%0A"
|
|
|
|
|
"Holder\x1f: %s"
|
|
|
|
|
"%s"),
|
|
|
|
|
"\x1e",
|
2017-02-22 13:03:52 +01:00
|
|
|
|
serial,
|
2017-02-22 16:54:32 +01:00
|
|
|
|
disp_name? disp_name:"",
|
|
|
|
|
"");
|
2017-02-22 13:03:52 +01:00
|
|
|
|
}
|
|
|
|
|
xfree (disp_name);
|
|
|
|
|
xfree (serial);
|
|
|
|
|
|
|
|
|
|
if (remaining != -1)
|
|
|
|
|
{
|
|
|
|
|
/* TRANSLATORS: This is the number of remaining attempts to
|
|
|
|
|
* enter a PIN. Use %%0A (double-percent,0A) for a linefeed. */
|
|
|
|
|
rembuf = xtryasprintf (_("Remaining attempts: %d"), remaining);
|
|
|
|
|
if (!rembuf)
|
|
|
|
|
{
|
|
|
|
|
xfree (result);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
tmpbuf = strconcat (result, "%0A%0A", rembuf, NULL);
|
|
|
|
|
xfree (rembuf);
|
|
|
|
|
if (!tmpbuf)
|
|
|
|
|
{
|
|
|
|
|
xfree (result);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
xfree (result);
|
|
|
|
|
result = tmpbuf;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-22 11:46:14 +01:00
|
|
|
|
/* Compute hash if KDF-DO is available. CHVNO must be 0 for reset
|
|
|
|
|
code, 1 or 2 for user pin and 3 for admin pin.
|
|
|
|
|
*/
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
pin2hash_if_kdf (app_t app, int chvno, char *pinvalue, int *r_pinlen)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err = 0;
|
2018-03-30 05:48:04 +02:00
|
|
|
|
void *relptr = NULL;
|
2018-01-22 11:46:14 +01:00
|
|
|
|
unsigned char *buffer;
|
|
|
|
|
size_t buflen;
|
|
|
|
|
|
|
|
|
|
if (app->app_local->extcap.kdf_do
|
2018-02-08 19:03:08 +01:00
|
|
|
|
&& (relptr = get_one_do (app, 0x00F9, &buffer, &buflen, NULL))
|
2018-03-30 05:48:04 +02:00
|
|
|
|
&& buflen >= KDF_DATA_LENGTH_MIN && (buffer[2] == 0x03))
|
2018-01-22 11:46:14 +01:00
|
|
|
|
{
|
2018-03-30 05:48:04 +02:00
|
|
|
|
const char *salt;
|
2018-01-22 11:46:14 +01:00
|
|
|
|
unsigned long s2k_count;
|
|
|
|
|
char dek[32];
|
2018-03-30 05:48:04 +02:00
|
|
|
|
int salt_index;
|
2018-01-22 11:46:14 +01:00
|
|
|
|
|
|
|
|
|
s2k_count = (((unsigned int)buffer[8] << 24)
|
|
|
|
|
| (buffer[9] << 16) | (buffer[10] << 8) | buffer[11]);
|
2018-03-30 05:48:04 +02:00
|
|
|
|
|
|
|
|
|
if (buflen == KDF_DATA_LENGTH_MIN)
|
|
|
|
|
salt_index =14;
|
|
|
|
|
else if (buflen == KDF_DATA_LENGTH_MAX)
|
|
|
|
|
salt_index = (chvno==3 ? 34 : (chvno==0 ? 24 : 14));
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_INV_DATA);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
salt = &buffer[salt_index];
|
2018-01-22 11:46:14 +01:00
|
|
|
|
err = gcry_kdf_derive (pinvalue, strlen (pinvalue),
|
|
|
|
|
GCRY_KDF_ITERSALTED_S2K,
|
|
|
|
|
DIGEST_ALGO_SHA256, salt, 8,
|
|
|
|
|
s2k_count, sizeof (dek), dek);
|
|
|
|
|
if (!err)
|
|
|
|
|
{
|
|
|
|
|
/* pinvalue has a buffer of MAXLEN_PIN+1, 32 is OK. */
|
|
|
|
|
*r_pinlen = 32;
|
|
|
|
|
memcpy (pinvalue, dek, *r_pinlen);
|
|
|
|
|
wipememory (dek, *r_pinlen);
|
|
|
|
|
}
|
2018-03-30 05:48:04 +02:00
|
|
|
|
}
|
2018-01-22 11:46:14 +01:00
|
|
|
|
else
|
|
|
|
|
*r_pinlen = strlen (pinvalue);
|
|
|
|
|
|
2018-03-30 05:48:04 +02:00
|
|
|
|
leave:
|
|
|
|
|
xfree (relptr);
|
2018-01-22 11:46:14 +01:00
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-22 13:03:52 +01:00
|
|
|
|
|
2017-02-20 22:19:50 +01:00
|
|
|
|
/* Verify a CHV either using the pinentry or if possible by
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
using a pinpad. PINCB and PINCB_ARG describe the usual callback
|
2006-12-21 13:13:44 +01:00
|
|
|
|
for the pinentry. CHVNO must be either 1 or 2. SIGCOUNT is only
|
2008-03-26 10:20:40 +01:00
|
|
|
|
used with CHV1. PINVALUE is the address of a pointer which will
|
2006-12-21 13:13:44 +01:00
|
|
|
|
receive a newly allocated block with the actual PIN (this is useful
|
2009-05-20 18:12:25 +02:00
|
|
|
|
in case that PIN shall be used for another verify operation). The
|
2006-12-21 13:13:44 +01:00
|
|
|
|
caller needs to free this value. If the function returns with
|
|
|
|
|
success and NULL is stored at PINVALUE, the caller should take this
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
as an indication that the pinpad has been used.
|
2006-12-21 13:13:44 +01:00
|
|
|
|
*/
|
2005-05-18 12:48:06 +02:00
|
|
|
|
static gpg_error_t
|
2006-12-21 13:13:44 +01:00
|
|
|
|
verify_a_chv (app_t app,
|
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
2018-01-22 11:46:14 +01:00
|
|
|
|
void *pincb_arg, int chvno, unsigned long sigcount,
|
|
|
|
|
char **pinvalue, int *pinlen)
|
2003-09-30 19:35:05 +02:00
|
|
|
|
{
|
|
|
|
|
int rc = 0;
|
2009-03-05 20:19:37 +01:00
|
|
|
|
char *prompt_buffer = NULL;
|
|
|
|
|
const char *prompt;
|
SCD: API cleanup for keypad handling.
* scd/iso7816.h (struct pininfo_s): Rename from iso7816_pininfo_s.
Change meaning of MODE.
(pininfo_t): Rename from iso7816_pininfo_t.
* scd/sc-copykeys.c: Include "iso7816.h".
* scd/scdaemon.c, scd/command.c: Likewise.
* scd/ccid-driver.c: Include "scdaemon.h" and "iso7816.h".
(ccid_transceive_secure): Follow the change of PININFO_T.
* scd/app.c: Include "apdu.h" after "iso7816.h".
* scd/iso7816.c (iso7816_check_keypad, iso7816_verify_kp)
(iso7816_change_reference_data_kp): Follow the change of API.
* scd/apdu.c (struct reader_table_s): Change API of CHECK_KEYPAD,
KEYPAD_VERIFY, KEYPAD_MODIFY to have arg of PININFO_T.
(check_pcsc_keypad, check_ccid_keypad): Likewise.
(apdu_check_keypad, apdu_keypad_verify, apdu_keypad_modify): Likewise.
(pcsc_keypad_verify, pcsc_keypad_modify, ct_send_apdu)
(pcsc_send_apdu_direct, pcsc_send_apdu_wrapped, pcsc_send_apdu)
(send_apdu_ccid, ccid_keypad_operation, my_rapdu_send_apdu, send_apdu)
(send_le): Follow the change of API.
* scd/apdu.h (apdu_check_keypad, apdu_keypad_verify)
(apdu_keypad_modify): Change the API.
* scd/app-dinsig.c, scd/app-nks.c, scd/app-openpgp.c: Follow the
change.
2013-01-09 06:10:08 +01:00
|
|
|
|
pininfo_t pininfo;
|
2006-12-21 13:13:44 +01:00
|
|
|
|
int minlen = 6;
|
2017-02-22 13:03:52 +01:00
|
|
|
|
int remaining;
|
2003-09-30 19:35:05 +02:00
|
|
|
|
|
2017-02-22 13:03:52 +01:00
|
|
|
|
log_assert (chvno == 1 || chvno == 2);
|
2005-11-28 12:52:25 +01:00
|
|
|
|
|
2006-12-21 13:13:44 +01:00
|
|
|
|
*pinvalue = NULL;
|
2018-01-22 11:46:14 +01:00
|
|
|
|
*pinlen = 0;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2017-02-22 13:03:52 +01:00
|
|
|
|
remaining = get_remaining_tries (app, 0);
|
|
|
|
|
if (remaining == -1)
|
|
|
|
|
return gpg_error (GPG_ERR_CARD);
|
|
|
|
|
|
2008-04-21 09:53:20 +02:00
|
|
|
|
if (chvno == 2 && app->app_local->flags.def_chv2)
|
|
|
|
|
{
|
|
|
|
|
/* Special case for def_chv2 mechanism. */
|
|
|
|
|
if (opt.verbose)
|
|
|
|
|
log_info (_("using default PIN as %s\n"), "CHV2");
|
|
|
|
|
rc = iso7816_verify (app->slot, 0x82, "123456", 6);
|
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
/* Verification of CHV2 with the default PIN failed,
|
|
|
|
|
although the card pretends to have the default PIN set as
|
|
|
|
|
CHV2. We better disable the def_chv2 flag now. */
|
|
|
|
|
log_info (_("failed to use default PIN as %s: %s"
|
|
|
|
|
" - disabling further default use\n"),
|
|
|
|
|
"CHV2", gpg_strerror (rc));
|
|
|
|
|
app->app_local->flags.def_chv2 = 0;
|
|
|
|
|
}
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2006-12-21 13:13:44 +01:00
|
|
|
|
memset (&pininfo, 0, sizeof pininfo);
|
2013-01-09 08:23:55 +01:00
|
|
|
|
pininfo.fixedlen = -1;
|
2006-12-21 13:13:44 +01:00
|
|
|
|
pininfo.minlen = minlen;
|
2009-03-05 20:19:37 +01:00
|
|
|
|
|
2017-02-22 13:03:52 +01:00
|
|
|
|
{
|
|
|
|
|
const char *firstline = _("||Please unlock the card");
|
|
|
|
|
char *infoblock = get_prompt_info (app, chvno, sigcount,
|
|
|
|
|
remaining < 3? remaining : -1);
|
2009-03-05 20:19:37 +01:00
|
|
|
|
|
2017-02-22 13:03:52 +01:00
|
|
|
|
prompt_buffer = strconcat (firstline, "%0A%0A", infoblock, NULL);
|
|
|
|
|
if (prompt_buffer)
|
2009-03-05 20:19:37 +01:00
|
|
|
|
prompt = prompt_buffer;
|
2017-02-22 13:03:52 +01:00
|
|
|
|
else
|
|
|
|
|
prompt = firstline; /* ENOMEM fallback. */
|
2009-03-05 20:19:37 +01:00
|
|
|
|
|
2017-02-22 13:03:52 +01:00
|
|
|
|
xfree (infoblock);
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
if (!opt.disable_pinpad
|
|
|
|
|
&& !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
|
|
|
|
|
&& !check_pinpad_request (app, &pininfo, 0))
|
2006-12-21 13:13:44 +01:00
|
|
|
|
{
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
/* The reader supports the verify command through the pinpad.
|
2009-03-05 20:19:37 +01:00
|
|
|
|
Note that the pincb appends a text to the prompt telling the
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
user to use the pinpad. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
rc = pincb (pincb_arg, prompt, NULL);
|
2009-03-05 20:19:37 +01:00
|
|
|
|
prompt = NULL;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
xfree (prompt_buffer);
|
2009-03-05 20:19:37 +01:00
|
|
|
|
prompt_buffer = NULL;
|
2006-12-21 13:13:44 +01:00
|
|
|
|
if (rc)
|
2003-12-23 11:25:24 +01:00
|
|
|
|
{
|
2006-12-21 13:13:44 +01:00
|
|
|
|
log_info (_("PIN callback returned error: %s\n"),
|
|
|
|
|
gpg_strerror (rc));
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
2011-11-28 08:16:38 +01:00
|
|
|
|
rc = iso7816_verify_kp (app->slot, 0x80+chvno, &pininfo);
|
2006-12-21 13:13:44 +01:00
|
|
|
|
/* Dismiss the prompt. */
|
|
|
|
|
pincb (pincb_arg, NULL, NULL);
|
2006-11-20 17:49:41 +01:00
|
|
|
|
|
2017-02-22 13:03:52 +01:00
|
|
|
|
log_assert (!*pinvalue);
|
2006-12-21 13:13:44 +01:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
/* The reader has no pinpad or we don't want to use it. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
rc = pincb (pincb_arg, prompt, pinvalue);
|
2009-03-05 20:19:37 +01:00
|
|
|
|
prompt = NULL;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
xfree (prompt_buffer);
|
2009-03-05 20:19:37 +01:00
|
|
|
|
prompt_buffer = NULL;
|
2003-09-30 19:35:05 +02:00
|
|
|
|
if (rc)
|
|
|
|
|
{
|
2006-12-21 13:13:44 +01:00
|
|
|
|
log_info (_("PIN callback returned error: %s\n"),
|
|
|
|
|
gpg_strerror (rc));
|
2003-09-30 19:35:05 +02:00
|
|
|
|
return rc;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2006-12-21 13:13:44 +01:00
|
|
|
|
if (strlen (*pinvalue) < minlen)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("PIN for CHV%d is too short;"
|
|
|
|
|
" minimum length is %d\n"), chvno, minlen);
|
|
|
|
|
xfree (*pinvalue);
|
|
|
|
|
*pinvalue = NULL;
|
|
|
|
|
return gpg_error (GPG_ERR_BAD_PIN);
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-22 11:46:14 +01:00
|
|
|
|
rc = pin2hash_if_kdf (app, chvno, *pinvalue, pinlen);
|
|
|
|
|
if (!rc)
|
|
|
|
|
rc = iso7816_verify (app->slot, 0x80+chvno, *pinvalue, *pinlen);
|
2006-12-21 13:13:44 +01:00
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2006-12-21 13:13:44 +01:00
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
|
|
|
|
|
xfree (*pinvalue);
|
|
|
|
|
*pinvalue = NULL;
|
|
|
|
|
flush_cache_after_error (app);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
2003-09-30 19:35:05 +02:00
|
|
|
|
|
2006-12-21 13:13:44 +01:00
|
|
|
|
|
|
|
|
|
/* Verify CHV2 if required. Depending on the configuration of the
|
|
|
|
|
card CHV1 will also be verified. */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
verify_chv2 (app_t app,
|
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
|
|
|
|
void *pincb_arg)
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
char *pinvalue;
|
2018-01-22 11:46:14 +01:00
|
|
|
|
int pinlen;
|
2020-09-01 08:23:59 +02:00
|
|
|
|
int i;
|
2006-12-21 13:13:44 +01:00
|
|
|
|
|
2011-02-04 12:57:53 +01:00
|
|
|
|
if (app->did_chv2)
|
2009-06-29 12:43:57 +02:00
|
|
|
|
return 0; /* We already verified CHV2. */
|
2006-12-21 13:13:44 +01:00
|
|
|
|
|
2020-09-01 08:23:59 +02:00
|
|
|
|
/* Make sure we have load the public keys. */
|
|
|
|
|
for (i = 0; i < 3; i++)
|
|
|
|
|
get_public_key (app, i);
|
|
|
|
|
|
2020-08-27 03:41:51 +02:00
|
|
|
|
if (app->app_local->pk[1].key || app->app_local->pk[2].key)
|
|
|
|
|
{
|
|
|
|
|
rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue, &pinlen);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
app->did_chv2 = 1;
|
2020-09-16 05:46:50 +02:00
|
|
|
|
|
|
|
|
|
if (!app->did_chv1 && !app->force_chv1 && pinvalue)
|
|
|
|
|
{
|
|
|
|
|
/* For convenience we verify CHV1 here too. We do this only if
|
|
|
|
|
the card is not configured to require a verification before
|
|
|
|
|
each CHV1 controlled operation (force_chv1) and if we are not
|
|
|
|
|
using the pinpad (PINVALUE == NULL). */
|
|
|
|
|
rc = iso7816_verify (app->slot, 0x81, pinvalue, pinlen);
|
|
|
|
|
if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
|
|
|
|
|
rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
|
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
|
|
|
|
|
flush_cache_after_error (app);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
app->did_chv1 = 1;
|
|
|
|
|
}
|
2020-08-27 03:41:51 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
2006-12-21 13:13:44 +01:00
|
|
|
|
{
|
2020-09-16 05:46:50 +02:00
|
|
|
|
rc = verify_a_chv (app, pincb, pincb_arg, 1, 0, &pinvalue, &pinlen);
|
2006-12-21 13:13:44 +01:00
|
|
|
|
if (rc)
|
2020-09-16 05:46:50 +02:00
|
|
|
|
return rc;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
2009-06-29 12:43:57 +02:00
|
|
|
|
|
2006-12-21 13:13:44 +01:00
|
|
|
|
xfree (pinvalue);
|
|
|
|
|
|
2003-09-30 19:35:05 +02:00
|
|
|
|
return rc;
|
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2006-12-21 13:13:44 +01:00
|
|
|
|
|
2009-05-20 18:12:25 +02:00
|
|
|
|
/* Build the prompt to enter the Admin PIN. The prompt depends on the
|
|
|
|
|
current sdtate of the card. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
static gpg_error_t
|
2009-05-20 18:12:25 +02:00
|
|
|
|
build_enter_admin_pin_prompt (app_t app, char **r_prompt)
|
|
|
|
|
{
|
|
|
|
|
int remaining;
|
|
|
|
|
char *prompt;
|
2017-02-22 13:03:52 +01:00
|
|
|
|
char *infoblock;
|
2009-05-20 18:12:25 +02:00
|
|
|
|
|
|
|
|
|
*r_prompt = NULL;
|
|
|
|
|
|
2017-02-22 13:03:52 +01:00
|
|
|
|
remaining = get_remaining_tries (app, 1);
|
|
|
|
|
if (remaining == -1)
|
|
|
|
|
return gpg_error (GPG_ERR_CARD);
|
|
|
|
|
if (!remaining)
|
2009-05-20 18:12:25 +02:00
|
|
|
|
{
|
|
|
|
|
log_info (_("card is permanently locked!\n"));
|
|
|
|
|
return gpg_error (GPG_ERR_BAD_PIN);
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2016-01-18 11:20:15 +01:00
|
|
|
|
log_info (ngettext("%d Admin PIN attempt remaining before card"
|
|
|
|
|
" is permanently locked\n",
|
|
|
|
|
"%d Admin PIN attempts remaining before card"
|
|
|
|
|
" is permanently locked\n",
|
|
|
|
|
remaining), remaining);
|
2009-05-20 18:12:25 +02:00
|
|
|
|
|
2017-02-22 13:03:52 +01:00
|
|
|
|
infoblock = get_prompt_info (app, 3, 0, remaining < 3? remaining : -1);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2017-02-22 13:03:52 +01:00
|
|
|
|
/* TRANSLATORS: Do not translate the "|A|" prefix but keep it at
|
|
|
|
|
the start of the string. Use %0A (single percent) for a linefeed. */
|
|
|
|
|
prompt = strconcat (_("|A|Please enter the Admin PIN"),
|
|
|
|
|
"%0A%0A", infoblock, NULL);
|
|
|
|
|
xfree (infoblock);
|
2009-05-20 18:12:25 +02:00
|
|
|
|
if (!prompt)
|
|
|
|
|
return gpg_error_from_syserror ();
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-05-20 18:12:25 +02:00
|
|
|
|
*r_prompt = prompt;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-09-30 19:35:05 +02:00
|
|
|
|
/* Verify CHV3 if required. */
|
2005-05-18 12:48:06 +02:00
|
|
|
|
static gpg_error_t
|
2004-10-14 15:22:03 +02:00
|
|
|
|
verify_chv3 (app_t app,
|
2005-05-18 12:48:06 +02:00
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
2003-09-30 19:35:05 +02:00
|
|
|
|
void *pincb_arg)
|
|
|
|
|
{
|
|
|
|
|
int rc = 0;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2004-09-30 15:24:33 +02:00
|
|
|
|
#if GNUPG_MAJOR_VERSION != 1
|
2003-12-01 11:54:09 +01:00
|
|
|
|
if (!opt.allow_admin)
|
|
|
|
|
{
|
2004-09-30 15:24:33 +02:00
|
|
|
|
log_info (_("access to admin commands is not configured\n"));
|
2003-12-01 11:54:09 +01:00
|
|
|
|
return gpg_error (GPG_ERR_EACCES);
|
|
|
|
|
}
|
2004-09-30 15:24:33 +02:00
|
|
|
|
#endif
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
|
|
|
|
if (!app->did_chv3)
|
2003-09-30 19:35:05 +02:00
|
|
|
|
{
|
SCD: API cleanup for keypad handling.
* scd/iso7816.h (struct pininfo_s): Rename from iso7816_pininfo_s.
Change meaning of MODE.
(pininfo_t): Rename from iso7816_pininfo_t.
* scd/sc-copykeys.c: Include "iso7816.h".
* scd/scdaemon.c, scd/command.c: Likewise.
* scd/ccid-driver.c: Include "scdaemon.h" and "iso7816.h".
(ccid_transceive_secure): Follow the change of PININFO_T.
* scd/app.c: Include "apdu.h" after "iso7816.h".
* scd/iso7816.c (iso7816_check_keypad, iso7816_verify_kp)
(iso7816_change_reference_data_kp): Follow the change of API.
* scd/apdu.c (struct reader_table_s): Change API of CHECK_KEYPAD,
KEYPAD_VERIFY, KEYPAD_MODIFY to have arg of PININFO_T.
(check_pcsc_keypad, check_ccid_keypad): Likewise.
(apdu_check_keypad, apdu_keypad_verify, apdu_keypad_modify): Likewise.
(pcsc_keypad_verify, pcsc_keypad_modify, ct_send_apdu)
(pcsc_send_apdu_direct, pcsc_send_apdu_wrapped, pcsc_send_apdu)
(send_apdu_ccid, ccid_keypad_operation, my_rapdu_send_apdu, send_apdu)
(send_le): Follow the change of API.
* scd/apdu.h (apdu_check_keypad, apdu_keypad_verify)
(apdu_keypad_modify): Change the API.
* scd/app-dinsig.c, scd/app-nks.c, scd/app-openpgp.c: Follow the
change.
2013-01-09 06:10:08 +01:00
|
|
|
|
pininfo_t pininfo;
|
2008-03-26 10:20:40 +01:00
|
|
|
|
int minlen = 8;
|
2009-05-20 18:12:25 +02:00
|
|
|
|
char *prompt;
|
2008-03-26 10:20:40 +01:00
|
|
|
|
|
|
|
|
|
memset (&pininfo, 0, sizeof pininfo);
|
2013-01-09 08:23:55 +01:00
|
|
|
|
pininfo.fixedlen = -1;
|
2008-03-26 10:20:40 +01:00
|
|
|
|
pininfo.minlen = minlen;
|
2003-09-30 19:35:05 +02:00
|
|
|
|
|
2009-05-20 18:12:25 +02:00
|
|
|
|
rc = build_enter_admin_pin_prompt (app, &prompt);
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
2003-09-30 19:35:05 +02:00
|
|
|
|
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
if (!opt.disable_pinpad
|
|
|
|
|
&& !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
|
|
|
|
|
&& !check_pinpad_request (app, &pininfo, 1))
|
2009-03-05 20:19:37 +01:00
|
|
|
|
{
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
/* The reader supports the verify command through the pinpad. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
rc = pincb (pincb_arg, prompt, NULL);
|
2009-05-20 18:12:25 +02:00
|
|
|
|
xfree (prompt);
|
2009-03-05 20:19:37 +01:00
|
|
|
|
prompt = NULL;
|
2008-03-26 10:20:40 +01:00
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
log_info (_("PIN callback returned error: %s\n"),
|
|
|
|
|
gpg_strerror (rc));
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
2011-11-28 08:16:38 +01:00
|
|
|
|
rc = iso7816_verify_kp (app->slot, 0x83, &pininfo);
|
2008-03-26 10:20:40 +01:00
|
|
|
|
/* Dismiss the prompt. */
|
|
|
|
|
pincb (pincb_arg, NULL, NULL);
|
|
|
|
|
}
|
|
|
|
|
else
|
2003-12-23 11:25:24 +01:00
|
|
|
|
{
|
2008-03-26 10:20:40 +01:00
|
|
|
|
char *pinvalue;
|
2018-01-22 11:46:14 +01:00
|
|
|
|
int pinlen;
|
2008-03-26 10:20:40 +01:00
|
|
|
|
|
2011-02-04 12:57:53 +01:00
|
|
|
|
rc = pincb (pincb_arg, prompt, &pinvalue);
|
2009-05-20 18:12:25 +02:00
|
|
|
|
xfree (prompt);
|
2009-03-05 20:19:37 +01:00
|
|
|
|
prompt = NULL;
|
2008-03-26 10:20:40 +01:00
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
log_info (_("PIN callback returned error: %s\n"),
|
|
|
|
|
gpg_strerror (rc));
|
|
|
|
|
return rc;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2008-03-26 10:20:40 +01:00
|
|
|
|
if (strlen (pinvalue) < minlen)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("PIN for CHV%d is too short;"
|
|
|
|
|
" minimum length is %d\n"), 3, minlen);
|
|
|
|
|
xfree (pinvalue);
|
|
|
|
|
return gpg_error (GPG_ERR_BAD_PIN);
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2018-01-22 11:46:14 +01:00
|
|
|
|
rc = pin2hash_if_kdf (app, 3, pinvalue, &pinlen);
|
|
|
|
|
if (!rc)
|
|
|
|
|
rc = iso7816_verify (app->slot, 0x83, pinvalue, pinlen);
|
2003-12-23 11:25:24 +01:00
|
|
|
|
xfree (pinvalue);
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-09-30 19:35:05 +02:00
|
|
|
|
if (rc)
|
|
|
|
|
{
|
2004-09-30 15:24:33 +02:00
|
|
|
|
log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
|
2004-04-26 20:28:06 +02:00
|
|
|
|
flush_cache_after_error (app);
|
2003-09-30 19:35:05 +02:00
|
|
|
|
return rc;
|
|
|
|
|
}
|
2008-09-25 12:06:02 +02:00
|
|
|
|
app->did_chv3 = 1;
|
2003-09-30 19:35:05 +02:00
|
|
|
|
}
|
|
|
|
|
return rc;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Handle the SETATTR operation. All arguments are already basically
|
|
|
|
|
checked. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
static gpg_error_t
|
2004-10-14 15:22:03 +02:00
|
|
|
|
do_setattr (app_t app, const char *name,
|
2005-05-18 12:48:06 +02:00
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
2003-08-05 19:11:04 +02:00
|
|
|
|
void *pincb_arg,
|
|
|
|
|
const unsigned char *value, size_t valuelen)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t rc;
|
|
|
|
|
int idx;
|
|
|
|
|
static struct {
|
|
|
|
|
const char *name;
|
|
|
|
|
int tag;
|
2019-01-25 09:37:19 +01:00
|
|
|
|
int flush_tag; /* The tag which needs to be flushed or 0. */
|
2005-02-03 14:20:57 +01:00
|
|
|
|
int need_chv;
|
2004-04-29 19:25:57 +02:00
|
|
|
|
int special;
|
2008-07-17 21:40:53 +02:00
|
|
|
|
unsigned int need_v2:1;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
} table[] = {
|
2019-01-25 09:37:19 +01:00
|
|
|
|
{ "DISP-NAME", 0x005B, 0, 3 },
|
|
|
|
|
{ "LOGIN-DATA", 0x005E, 0, 3, 2 },
|
|
|
|
|
{ "DISP-LANG", 0x5F2D, 0, 3 },
|
|
|
|
|
{ "DISP-SEX", 0x5F35, 0, 3 },
|
|
|
|
|
{ "PUBKEY-URL", 0x5F50, 0, 3 },
|
|
|
|
|
{ "CHV-STATUS-1", 0x00C4, 0, 3, 1 },
|
|
|
|
|
{ "CA-FPR-1", 0x00CA, 0x00C6, 3 },
|
|
|
|
|
{ "CA-FPR-2", 0x00CB, 0x00C6, 3 },
|
|
|
|
|
{ "CA-FPR-3", 0x00CC, 0x00C6, 3 },
|
|
|
|
|
{ "PRIVATE-DO-1", 0x0101, 0, 2 },
|
|
|
|
|
{ "PRIVATE-DO-2", 0x0102, 0, 3 },
|
|
|
|
|
{ "PRIVATE-DO-3", 0x0103, 0, 2 },
|
|
|
|
|
{ "PRIVATE-DO-4", 0x0104, 0, 3 },
|
|
|
|
|
{ "CERT-3", 0x7F21, 0, 3, 0, 1 },
|
|
|
|
|
{ "SM-KEY-ENC", 0x00D1, 0, 3, 0, 1 },
|
|
|
|
|
{ "SM-KEY-MAC", 0x00D2, 0, 3, 0, 1 },
|
|
|
|
|
{ "KEY-ATTR", 0, 0, 0, 3, 1 },
|
|
|
|
|
{ "AESKEY", 0x00D5, 0, 3, 0, 1 },
|
|
|
|
|
{ "KDF", 0x00F9, 0, 3, 4, 1 },
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{ NULL, 0 }
|
|
|
|
|
};
|
2008-09-23 11:57:45 +02:00
|
|
|
|
int exmode;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
|
|
|
|
|
;
|
|
|
|
|
if (!table[idx].name)
|
2011-02-04 12:57:53 +01:00
|
|
|
|
return gpg_error (GPG_ERR_INV_NAME);
|
2008-09-23 11:57:45 +02:00
|
|
|
|
if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
|
2008-08-18 13:08:04 +02:00
|
|
|
|
return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported. */
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2009-08-05 13:24:43 +02:00
|
|
|
|
if (table[idx].special == 3)
|
|
|
|
|
return change_keyattr_from_string (app, pincb, pincb_arg, value, valuelen);
|
|
|
|
|
|
2005-02-03 14:20:57 +01:00
|
|
|
|
switch (table[idx].need_chv)
|
|
|
|
|
{
|
|
|
|
|
case 2:
|
|
|
|
|
rc = verify_chv2 (app, pincb, pincb_arg);
|
|
|
|
|
break;
|
|
|
|
|
case 3:
|
|
|
|
|
rc = verify_chv3 (app, pincb, pincb_arg);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
rc = 0;
|
|
|
|
|
}
|
2003-09-30 19:35:05 +02:00
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2004-04-26 20:28:06 +02:00
|
|
|
|
/* Flush the cache before writing it, so that the next get operation
|
|
|
|
|
will reread the data from the card and thus get synced in case of
|
|
|
|
|
errors (e.g. data truncated by the card). */
|
2019-01-25 09:37:19 +01:00
|
|
|
|
flush_cache_item (app, table[idx].flush_tag? table[idx].flush_tag
|
|
|
|
|
/* */ : table[idx].tag);
|
2009-04-01 16:38:22 +02:00
|
|
|
|
|
|
|
|
|
if (app->app_local->cardcap.ext_lc_le && valuelen > 254)
|
|
|
|
|
exmode = 1; /* Use extended length w/o a limit. */
|
|
|
|
|
else if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
|
|
|
|
|
exmode = -254; /* Command chaining with max. 254 bytes. */
|
2008-09-23 11:57:45 +02:00
|
|
|
|
else
|
|
|
|
|
exmode = 0;
|
|
|
|
|
rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (rc)
|
2012-06-05 19:29:22 +02:00
|
|
|
|
log_error ("failed to set '%s': %s\n", table[idx].name, gpg_strerror (rc));
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2004-04-29 19:25:57 +02:00
|
|
|
|
if (table[idx].special == 1)
|
|
|
|
|
app->force_chv1 = (valuelen && *value == 0);
|
2004-10-14 15:22:03 +02:00
|
|
|
|
else if (table[idx].special == 2)
|
|
|
|
|
parse_login_data (app);
|
2018-04-03 13:30:29 +02:00
|
|
|
|
else if (table[idx].special == 4)
|
|
|
|
|
{
|
|
|
|
|
app->did_chv1 = 0;
|
|
|
|
|
app->did_chv2 = 0;
|
|
|
|
|
app->did_chv3 = 0;
|
2020-02-17 09:44:59 +01:00
|
|
|
|
|
|
|
|
|
if ((valuelen == KDF_DATA_LENGTH_MIN || valuelen == KDF_DATA_LENGTH_MAX)
|
|
|
|
|
&& (value[2] == 0x03))
|
|
|
|
|
app->app_local->pinpad.disabled = 1;
|
|
|
|
|
else
|
|
|
|
|
app->app_local->pinpad.disabled = 0;
|
2018-04-03 13:30:29 +02:00
|
|
|
|
}
|
2004-04-29 19:25:57 +02:00
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
2003-09-30 19:35:05 +02:00
|
|
|
|
|
2008-09-23 11:57:45 +02:00
|
|
|
|
/* Handle the WRITECERT command for OpenPGP. This rites the standard
|
|
|
|
|
certifciate to the card; CERTID needs to be set to "OPENPGP.3".
|
|
|
|
|
PINCB and PINCB_ARG are the usual arguments for the pinentry
|
|
|
|
|
callback. */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
do_writecert (app_t app, ctrl_t ctrl,
|
2011-02-04 12:57:53 +01:00
|
|
|
|
const char *certidstr,
|
2008-09-23 11:57:45 +02:00
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
|
|
|
|
void *pincb_arg,
|
|
|
|
|
const unsigned char *certdata, size_t certdatalen)
|
|
|
|
|
{
|
2008-10-20 15:53:23 +02:00
|
|
|
|
(void)ctrl;
|
2008-09-23 11:57:45 +02:00
|
|
|
|
#if GNUPG_MAJOR_VERSION > 1
|
|
|
|
|
if (strcmp (certidstr, "OPENPGP.3"))
|
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
if (!certdata || !certdatalen)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_ARG);
|
|
|
|
|
if (!app->app_local->extcap.is_v2)
|
|
|
|
|
return gpg_error (GPG_ERR_NOT_SUPPORTED);
|
|
|
|
|
if (certdatalen > app->app_local->extcap.max_certlen_3)
|
|
|
|
|
return gpg_error (GPG_ERR_TOO_LARGE);
|
|
|
|
|
return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
|
|
|
|
|
#else
|
|
|
|
|
return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2009-05-20 18:12:25 +02:00
|
|
|
|
/* Handle the PASSWD command. The following combinations are
|
|
|
|
|
possible:
|
|
|
|
|
|
|
|
|
|
Flags CHVNO Vers. Description
|
|
|
|
|
RESET 1 1 Verify CHV3 and set a new CHV1 and CHV2
|
|
|
|
|
RESET 1 2 Verify PW3 and set a new PW1.
|
|
|
|
|
RESET 2 1 Verify CHV3 and set a new CHV1 and CHV2.
|
|
|
|
|
RESET 2 2 Verify PW3 and set a new Reset Code.
|
|
|
|
|
RESET 3 any Returns GPG_ERR_INV_ID.
|
|
|
|
|
- 1 1 Verify CHV2 and set a new CHV1 and CHV2.
|
|
|
|
|
- 1 2 Verify PW1 and set a new PW1.
|
|
|
|
|
- 2 1 Verify CHV2 and set a new CHV1 and CHV2.
|
|
|
|
|
- 2 2 Verify Reset Code and set a new PW1.
|
|
|
|
|
- 3 any Verify CHV3/PW3 and set a new CHV3/PW3.
|
2019-02-05 14:48:49 +01:00
|
|
|
|
|
|
|
|
|
The CHVNO can be prefixed with "OPENPGP.".
|
2009-05-20 18:12:25 +02:00
|
|
|
|
*/
|
2011-02-04 12:57:53 +01:00
|
|
|
|
static gpg_error_t
|
|
|
|
|
do_change_pin (app_t app, ctrl_t ctrl, const char *chvnostr,
|
2008-06-24 18:00:29 +02:00
|
|
|
|
unsigned int flags,
|
2005-05-18 12:48:06 +02:00
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
2003-08-05 19:11:04 +02:00
|
|
|
|
void *pincb_arg)
|
|
|
|
|
{
|
|
|
|
|
int rc = 0;
|
2019-02-05 14:48:49 +01:00
|
|
|
|
int chvno;
|
2008-09-25 12:06:02 +02:00
|
|
|
|
char *resetcode = NULL;
|
2009-05-20 18:12:25 +02:00
|
|
|
|
char *oldpinvalue = NULL;
|
2011-11-29 03:59:32 +01:00
|
|
|
|
char *pinvalue = NULL;
|
2008-06-24 18:00:29 +02:00
|
|
|
|
int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
|
2008-09-25 12:06:02 +02:00
|
|
|
|
int set_resetcode = 0;
|
SCD: API cleanup for keypad handling.
* scd/iso7816.h (struct pininfo_s): Rename from iso7816_pininfo_s.
Change meaning of MODE.
(pininfo_t): Rename from iso7816_pininfo_t.
* scd/sc-copykeys.c: Include "iso7816.h".
* scd/scdaemon.c, scd/command.c: Likewise.
* scd/ccid-driver.c: Include "scdaemon.h" and "iso7816.h".
(ccid_transceive_secure): Follow the change of PININFO_T.
* scd/app.c: Include "apdu.h" after "iso7816.h".
* scd/iso7816.c (iso7816_check_keypad, iso7816_verify_kp)
(iso7816_change_reference_data_kp): Follow the change of API.
* scd/apdu.c (struct reader_table_s): Change API of CHECK_KEYPAD,
KEYPAD_VERIFY, KEYPAD_MODIFY to have arg of PININFO_T.
(check_pcsc_keypad, check_ccid_keypad): Likewise.
(apdu_check_keypad, apdu_keypad_verify, apdu_keypad_modify): Likewise.
(pcsc_keypad_verify, pcsc_keypad_modify, ct_send_apdu)
(pcsc_send_apdu_direct, pcsc_send_apdu_wrapped, pcsc_send_apdu)
(send_apdu_ccid, ccid_keypad_operation, my_rapdu_send_apdu, send_apdu)
(send_le): Follow the change of API.
* scd/apdu.h (apdu_check_keypad, apdu_keypad_verify)
(apdu_keypad_modify): Change the API.
* scd/app-dinsig.c, scd/app-nks.c, scd/app-openpgp.c: Follow the
change.
2013-01-09 06:10:08 +01:00
|
|
|
|
pininfo_t pininfo;
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
int use_pinpad = 0;
|
2011-11-29 03:59:32 +01:00
|
|
|
|
int minlen = 6;
|
2018-01-22 11:46:14 +01:00
|
|
|
|
int pinlen0 = 0;
|
|
|
|
|
int pinlen = 0;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2008-10-20 15:53:23 +02:00
|
|
|
|
(void)ctrl;
|
2019-01-21 14:06:51 +01:00
|
|
|
|
|
2019-02-05 14:48:49 +01:00
|
|
|
|
if (digitp (chvnostr))
|
|
|
|
|
chvno = atoi (chvnostr);
|
|
|
|
|
else if (!ascii_strcasecmp (chvnostr, "OPENPGP.1"))
|
|
|
|
|
chvno = 1;
|
|
|
|
|
else if (!ascii_strcasecmp (chvnostr, "OPENPGP.2"))
|
|
|
|
|
chvno = 2;
|
|
|
|
|
else if (!ascii_strcasecmp (chvnostr, "OPENPGP.3"))
|
|
|
|
|
chvno = 3;
|
|
|
|
|
else
|
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
|
2011-11-29 03:59:32 +01:00
|
|
|
|
memset (&pininfo, 0, sizeof pininfo);
|
2013-01-09 08:23:55 +01:00
|
|
|
|
pininfo.fixedlen = -1;
|
2011-11-29 03:59:32 +01:00
|
|
|
|
pininfo.minlen = minlen;
|
2008-10-20 15:53:23 +02:00
|
|
|
|
|
2019-01-21 14:06:51 +01:00
|
|
|
|
if ((flags & APP_CHANGE_FLAG_CLEAR))
|
|
|
|
|
return gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
|
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (reset_mode && chvno == 3)
|
|
|
|
|
{
|
|
|
|
|
rc = gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2009-05-20 18:12:25 +02:00
|
|
|
|
|
|
|
|
|
if (!app->app_local->extcap.is_v2)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
2009-05-20 18:12:25 +02:00
|
|
|
|
/* Version 1 cards. */
|
|
|
|
|
|
|
|
|
|
if (reset_mode || chvno == 3)
|
|
|
|
|
{
|
|
|
|
|
/* We always require that the PIN is entered. */
|
|
|
|
|
app->did_chv3 = 0;
|
|
|
|
|
rc = verify_chv3 (app, pincb, pincb_arg);
|
|
|
|
|
if (rc)
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
else if (chvno == 1 || chvno == 2)
|
|
|
|
|
{
|
|
|
|
|
/* On a v1.x card CHV1 and CVH2 should always have the same
|
|
|
|
|
value, thus we enforce it here. */
|
|
|
|
|
int save_force = app->force_chv1;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-05-20 18:12:25 +02:00
|
|
|
|
app->force_chv1 = 0;
|
|
|
|
|
app->did_chv1 = 0;
|
|
|
|
|
app->did_chv2 = 0;
|
|
|
|
|
rc = verify_chv2 (app, pincb, pincb_arg);
|
|
|
|
|
app->force_chv1 = save_force;
|
|
|
|
|
if (rc)
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
rc = gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2008-09-25 12:06:02 +02:00
|
|
|
|
}
|
2009-05-20 18:12:25 +02:00
|
|
|
|
else
|
2008-09-25 12:06:02 +02:00
|
|
|
|
{
|
2009-05-20 18:12:25 +02:00
|
|
|
|
/* Version 2 cards. */
|
|
|
|
|
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
if (!opt.disable_pinpad
|
|
|
|
|
&& !iso7816_check_pinpad (app->slot,
|
2013-01-10 07:58:43 +01:00
|
|
|
|
ISO7816_CHANGE_REFERENCE_DATA, &pininfo)
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
&& !check_pinpad_request (app, &pininfo, chvno == 3))
|
|
|
|
|
use_pinpad = 1;
|
2011-11-29 03:59:32 +01:00
|
|
|
|
|
2009-05-20 18:12:25 +02:00
|
|
|
|
if (reset_mode)
|
2008-09-25 12:06:02 +02:00
|
|
|
|
{
|
2009-05-20 18:12:25 +02:00
|
|
|
|
/* To reset a PIN the Admin PIN is required. */
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
use_pinpad = 0;
|
2009-05-20 18:12:25 +02:00
|
|
|
|
app->did_chv3 = 0;
|
|
|
|
|
rc = verify_chv3 (app, pincb, pincb_arg);
|
|
|
|
|
if (rc)
|
|
|
|
|
goto leave;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-05-20 18:12:25 +02:00
|
|
|
|
if (chvno == 2)
|
|
|
|
|
set_resetcode = 1;
|
2008-09-25 12:06:02 +02:00
|
|
|
|
}
|
2011-12-02 05:57:12 +01:00
|
|
|
|
else if (chvno == 1 || chvno == 3)
|
2008-09-25 12:06:02 +02:00
|
|
|
|
{
|
2016-11-04 05:45:57 +01:00
|
|
|
|
if (!use_pinpad)
|
2009-05-20 18:12:25 +02:00
|
|
|
|
{
|
2011-12-02 05:57:12 +01:00
|
|
|
|
char *promptbuf = NULL;
|
|
|
|
|
const char *prompt;
|
|
|
|
|
|
|
|
|
|
if (chvno == 3)
|
|
|
|
|
{
|
|
|
|
|
minlen = 8;
|
|
|
|
|
rc = build_enter_admin_pin_prompt (app, &promptbuf);
|
|
|
|
|
if (rc)
|
|
|
|
|
goto leave;
|
|
|
|
|
prompt = promptbuf;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
prompt = _("||Please enter the PIN");
|
|
|
|
|
rc = pincb (pincb_arg, prompt, &oldpinvalue);
|
|
|
|
|
xfree (promptbuf);
|
|
|
|
|
promptbuf = NULL;
|
2009-05-20 18:12:25 +02:00
|
|
|
|
if (rc)
|
2011-12-02 05:57:12 +01:00
|
|
|
|
{
|
|
|
|
|
log_info (_("PIN callback returned error: %s\n"),
|
|
|
|
|
gpg_strerror (rc));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2009-05-20 18:12:25 +02:00
|
|
|
|
|
2011-12-02 05:57:12 +01:00
|
|
|
|
if (strlen (oldpinvalue) < minlen)
|
|
|
|
|
{
|
|
|
|
|
log_info (_("PIN for CHV%d is too short;"
|
|
|
|
|
" minimum length is %d\n"), chvno, minlen);
|
|
|
|
|
rc = gpg_error (GPG_ERR_BAD_PIN);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2009-05-20 18:12:25 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (chvno == 2)
|
2008-09-25 12:06:02 +02:00
|
|
|
|
{
|
2009-05-20 18:12:25 +02:00
|
|
|
|
/* There is no PW2 for v2 cards. We use this condition to
|
|
|
|
|
allow a PW reset using the Reset Code. */
|
|
|
|
|
void *relptr;
|
|
|
|
|
unsigned char *value;
|
|
|
|
|
size_t valuelen;
|
|
|
|
|
int remaining;
|
|
|
|
|
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
use_pinpad = 0;
|
2011-11-29 03:59:32 +01:00
|
|
|
|
minlen = 8;
|
2009-05-20 18:12:25 +02:00
|
|
|
|
relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
|
|
|
|
|
if (!relptr || valuelen < 7)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("error retrieving CHV status from card\n"));
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
rc = gpg_error (GPG_ERR_CARD);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
remaining = value[5];
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
if (!remaining)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("Reset Code not or not anymore available\n"));
|
|
|
|
|
rc = gpg_error (GPG_ERR_BAD_PIN);
|
|
|
|
|
goto leave;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
}
|
|
|
|
|
|
2011-12-02 05:57:12 +01:00
|
|
|
|
rc = pincb (pincb_arg,
|
|
|
|
|
_("||Please enter the Reset Code for the card"),
|
|
|
|
|
&resetcode);
|
|
|
|
|
if (rc)
|
2009-05-20 18:12:25 +02:00
|
|
|
|
{
|
2011-12-02 05:57:12 +01:00
|
|
|
|
log_info (_("PIN callback returned error: %s\n"),
|
|
|
|
|
gpg_strerror (rc));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
if (strlen (resetcode) < minlen)
|
|
|
|
|
{
|
|
|
|
|
log_info (_("Reset Code is too short; minimum length is %d\n"),
|
|
|
|
|
minlen);
|
|
|
|
|
rc = gpg_error (GPG_ERR_BAD_PIN);
|
|
|
|
|
goto leave;
|
2009-05-20 18:12:25 +02:00
|
|
|
|
}
|
2008-09-25 12:06:02 +02:00
|
|
|
|
}
|
2009-05-20 18:12:25 +02:00
|
|
|
|
else
|
2008-09-25 12:06:02 +02:00
|
|
|
|
{
|
2009-05-20 18:12:25 +02:00
|
|
|
|
rc = gpg_error (GPG_ERR_INV_ID);
|
2008-09-25 12:06:02 +02:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
2003-09-30 19:35:05 +02:00
|
|
|
|
if (chvno == 3)
|
|
|
|
|
app->did_chv3 = 0;
|
|
|
|
|
else
|
|
|
|
|
app->did_chv1 = app->did_chv2 = 0;
|
|
|
|
|
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
if (!use_pinpad)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
2011-11-29 03:59:32 +01:00
|
|
|
|
/* TRANSLATORS: Do not translate the "|*|" prefixes but
|
|
|
|
|
keep it at the start of the string. We need this elsewhere
|
|
|
|
|
to get some infos on the string. */
|
2012-08-22 18:54:37 +02:00
|
|
|
|
rc = pincb (pincb_arg, set_resetcode? _("|RN|New Reset Code") :
|
2011-11-29 03:59:32 +01:00
|
|
|
|
chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"),
|
|
|
|
|
&pinvalue);
|
2017-03-06 07:14:18 +01:00
|
|
|
|
if (rc || pinvalue == NULL)
|
2011-11-29 03:59:32 +01:00
|
|
|
|
{
|
|
|
|
|
log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
2009-05-20 18:12:25 +02:00
|
|
|
|
|
2011-12-02 05:57:12 +01:00
|
|
|
|
if (resetcode)
|
2008-09-25 12:06:02 +02:00
|
|
|
|
{
|
2011-12-02 05:57:12 +01:00
|
|
|
|
char *buffer;
|
|
|
|
|
|
|
|
|
|
buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
|
|
|
|
|
if (!buffer)
|
|
|
|
|
rc = gpg_error_from_syserror ();
|
2008-09-25 12:06:02 +02:00
|
|
|
|
else
|
|
|
|
|
{
|
2018-01-22 11:46:14 +01:00
|
|
|
|
strcpy (buffer, resetcode);
|
|
|
|
|
rc = pin2hash_if_kdf (app, 0, buffer, &pinlen0);
|
|
|
|
|
if (!rc)
|
|
|
|
|
{
|
|
|
|
|
strcpy (buffer+pinlen0, pinvalue);
|
|
|
|
|
rc = pin2hash_if_kdf (app, 0, buffer+pinlen0, &pinlen);
|
|
|
|
|
}
|
|
|
|
|
if (!rc)
|
|
|
|
|
rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
|
|
|
|
|
buffer, pinlen0+pinlen);
|
|
|
|
|
wipememory (buffer, pinlen0 + pinlen);
|
2011-12-02 05:57:12 +01:00
|
|
|
|
xfree (buffer);
|
2008-09-25 12:06:02 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (set_resetcode)
|
|
|
|
|
{
|
2011-12-02 05:57:12 +01:00
|
|
|
|
if (strlen (pinvalue) < 8)
|
2008-09-25 12:06:02 +02:00
|
|
|
|
{
|
2011-12-02 05:57:12 +01:00
|
|
|
|
log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
|
|
|
|
|
rc = gpg_error (GPG_ERR_BAD_PIN);
|
2008-09-25 12:06:02 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
2018-01-22 11:46:14 +01:00
|
|
|
|
{
|
|
|
|
|
rc = pin2hash_if_kdf (app, 0, pinvalue, &pinlen);
|
|
|
|
|
if (!rc)
|
|
|
|
|
rc = iso7816_put_data (app->slot, 0, 0xD3, pinvalue, pinlen);
|
|
|
|
|
}
|
2008-09-25 12:06:02 +02:00
|
|
|
|
}
|
|
|
|
|
else if (reset_mode)
|
2003-09-30 19:35:05 +02:00
|
|
|
|
{
|
2018-01-22 11:46:14 +01:00
|
|
|
|
rc = pin2hash_if_kdf (app, 1, pinvalue, &pinlen);
|
|
|
|
|
if (!rc)
|
|
|
|
|
rc = iso7816_reset_retry_counter (app->slot, 0x81, pinvalue, pinlen);
|
2011-12-02 05:57:12 +01:00
|
|
|
|
if (!rc && !app->app_local->extcap.is_v2)
|
2018-01-22 11:46:14 +01:00
|
|
|
|
rc = iso7816_reset_retry_counter (app->slot, 0x82, pinvalue, pinlen);
|
2003-09-30 19:35:05 +02:00
|
|
|
|
}
|
2009-05-20 18:12:25 +02:00
|
|
|
|
else if (!app->app_local->extcap.is_v2)
|
2003-09-30 19:35:05 +02:00
|
|
|
|
{
|
2009-05-20 18:12:25 +02:00
|
|
|
|
/* Version 1 cards. */
|
2003-09-30 19:35:05 +02:00
|
|
|
|
if (chvno == 1 || chvno == 2)
|
|
|
|
|
{
|
|
|
|
|
rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
|
|
|
|
|
pinvalue, strlen (pinvalue));
|
2009-05-20 18:12:25 +02:00
|
|
|
|
if (!rc)
|
2003-09-30 19:35:05 +02:00
|
|
|
|
rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
|
|
|
|
|
pinvalue, strlen (pinvalue));
|
|
|
|
|
}
|
2009-05-20 18:12:25 +02:00
|
|
|
|
else /* CHVNO == 3 */
|
|
|
|
|
{
|
|
|
|
|
rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
|
|
|
|
|
pinvalue, strlen (pinvalue));
|
|
|
|
|
}
|
2003-09-30 19:35:05 +02:00
|
|
|
|
}
|
2009-05-20 18:12:25 +02:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Version 2 cards. */
|
|
|
|
|
assert (chvno == 1 || chvno == 3);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
if (use_pinpad)
|
2011-11-29 03:59:32 +01:00
|
|
|
|
{
|
2011-12-01 03:09:51 +01:00
|
|
|
|
rc = pincb (pincb_arg,
|
|
|
|
|
chvno == 3 ?
|
|
|
|
|
_("||Please enter the Admin PIN and New Admin PIN") :
|
|
|
|
|
_("||Please enter the PIN and New PIN"), NULL);
|
|
|
|
|
if (rc)
|
|
|
|
|
{
|
|
|
|
|
log_info (_("PIN callback returned error: %s\n"),
|
|
|
|
|
gpg_strerror (rc));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2011-12-02 05:57:12 +01:00
|
|
|
|
rc = iso7816_change_reference_data_kp (app->slot, 0x80 + chvno, 0,
|
2011-11-29 03:59:32 +01:00
|
|
|
|
&pininfo);
|
2011-11-29 09:56:22 +01:00
|
|
|
|
pincb (pincb_arg, NULL, NULL); /* Dismiss the prompt. */
|
2011-11-29 03:59:32 +01:00
|
|
|
|
}
|
|
|
|
|
else
|
2018-01-22 11:46:14 +01:00
|
|
|
|
{
|
|
|
|
|
rc = pin2hash_if_kdf (app, chvno, oldpinvalue, &pinlen0);
|
|
|
|
|
if (!rc)
|
|
|
|
|
rc = pin2hash_if_kdf (app, chvno, pinvalue, &pinlen);
|
|
|
|
|
if (!rc)
|
|
|
|
|
rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
|
|
|
|
|
oldpinvalue, pinlen0,
|
|
|
|
|
pinvalue, pinlen);
|
|
|
|
|
}
|
2009-05-20 18:12:25 +02:00
|
|
|
|
}
|
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
if (pinvalue)
|
|
|
|
|
{
|
2018-01-22 11:46:14 +01:00
|
|
|
|
wipememory (pinvalue, pinlen);
|
2008-09-25 12:06:02 +02:00
|
|
|
|
xfree (pinvalue);
|
|
|
|
|
}
|
2004-04-26 20:28:06 +02:00
|
|
|
|
if (rc)
|
|
|
|
|
flush_cache_after_error (app);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
leave:
|
2008-09-25 12:06:02 +02:00
|
|
|
|
if (resetcode)
|
|
|
|
|
{
|
|
|
|
|
wipememory (resetcode, strlen (resetcode));
|
|
|
|
|
xfree (resetcode);
|
|
|
|
|
}
|
2009-05-20 18:12:25 +02:00
|
|
|
|
if (oldpinvalue)
|
|
|
|
|
{
|
2018-01-22 11:46:14 +01:00
|
|
|
|
wipememory (oldpinvalue, pinlen0);
|
2009-05-20 18:12:25 +02:00
|
|
|
|
xfree (oldpinvalue);
|
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-05-20 22:39:36 +02:00
|
|
|
|
/* Check whether a key already exists. KEYIDX is the index of the key
|
2005-05-24 14:37:36 +02:00
|
|
|
|
(0..2). If FORCE is TRUE a diagnositic will be printed but no
|
2009-07-09 16:54:18 +02:00
|
|
|
|
error returned if the key already exists. The flag GENERATING is
|
|
|
|
|
only used to print correct messages. */
|
2005-05-20 22:39:36 +02:00
|
|
|
|
static gpg_error_t
|
2009-07-09 16:54:18 +02:00
|
|
|
|
does_key_exist (app_t app, int keyidx, int generating, int force)
|
2005-05-20 22:39:36 +02:00
|
|
|
|
{
|
|
|
|
|
const unsigned char *fpr;
|
|
|
|
|
unsigned char *buffer;
|
|
|
|
|
size_t buflen, n;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
assert (keyidx >=0 && keyidx <= 2);
|
|
|
|
|
|
2009-06-17 11:45:50 +02:00
|
|
|
|
if (iso7816_get_data (app->slot, 0, 0x006E, &buffer, &buflen))
|
2005-05-20 22:39:36 +02:00
|
|
|
|
{
|
|
|
|
|
log_error (_("error reading application data\n"));
|
|
|
|
|
return gpg_error (GPG_ERR_GENERAL);
|
|
|
|
|
}
|
|
|
|
|
fpr = find_tlv (buffer, buflen, 0x00C5, &n);
|
|
|
|
|
if (!fpr || n < 60)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("error reading fingerprint DO\n"));
|
|
|
|
|
xfree (buffer);
|
|
|
|
|
return gpg_error (GPG_ERR_GENERAL);
|
|
|
|
|
}
|
|
|
|
|
fpr += 20*keyidx;
|
|
|
|
|
for (i=0; i < 20 && !fpr[i]; i++)
|
|
|
|
|
;
|
|
|
|
|
xfree (buffer);
|
|
|
|
|
if (i!=20 && !force)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("key already exists\n"));
|
|
|
|
|
return gpg_error (GPG_ERR_EEXIST);
|
|
|
|
|
}
|
|
|
|
|
else if (i!=20)
|
|
|
|
|
log_info (_("existing key will be replaced\n"));
|
2009-07-09 16:54:18 +02:00
|
|
|
|
else if (generating)
|
2005-05-20 22:39:36 +02:00
|
|
|
|
log_info (_("generating new key\n"));
|
2009-07-09 16:54:18 +02:00
|
|
|
|
else
|
|
|
|
|
log_info (_("writing new key\n"));
|
2005-05-20 22:39:36 +02:00
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
/* Create a TLV tag and value and store it at BUFFER. Return the length
|
|
|
|
|
of tag and length. A LENGTH greater than 65535 is truncated. */
|
|
|
|
|
static size_t
|
|
|
|
|
add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
|
2011-02-04 12:57:53 +01:00
|
|
|
|
{
|
2008-09-25 12:06:02 +02:00
|
|
|
|
unsigned char *p = buffer;
|
|
|
|
|
|
|
|
|
|
assert (tag <= 0xffff);
|
|
|
|
|
if ( tag > 0xff )
|
|
|
|
|
*p++ = tag >> 8;
|
|
|
|
|
*p++ = tag;
|
|
|
|
|
if (length < 128)
|
|
|
|
|
*p++ = length;
|
|
|
|
|
else if (length < 256)
|
|
|
|
|
{
|
|
|
|
|
*p++ = 0x81;
|
|
|
|
|
*p++ = length;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (length > 0xffff)
|
|
|
|
|
length = 0xffff;
|
|
|
|
|
*p++ = 0x82;
|
|
|
|
|
*p++ = length >> 8;
|
|
|
|
|
*p++ = length;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return p - buffer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
build_privkey_template (app_t app, int keyno,
|
|
|
|
|
const unsigned char *rsa_n, size_t rsa_n_len,
|
|
|
|
|
const unsigned char *rsa_e, size_t rsa_e_len,
|
|
|
|
|
const unsigned char *rsa_p, size_t rsa_p_len,
|
|
|
|
|
const unsigned char *rsa_q, size_t rsa_q_len,
|
2013-08-28 11:21:10 +02:00
|
|
|
|
const unsigned char *rsa_u, size_t rsa_u_len,
|
|
|
|
|
const unsigned char *rsa_dp, size_t rsa_dp_len,
|
|
|
|
|
const unsigned char *rsa_dq, size_t rsa_dq_len,
|
2008-09-25 12:06:02 +02:00
|
|
|
|
unsigned char **result, size_t *resultlen)
|
|
|
|
|
{
|
|
|
|
|
size_t rsa_e_reqlen;
|
2013-08-28 11:21:10 +02:00
|
|
|
|
unsigned char privkey[7*(1+3+3)];
|
2008-09-25 12:06:02 +02:00
|
|
|
|
size_t privkey_len;
|
|
|
|
|
unsigned char exthdr[2+2+3];
|
|
|
|
|
size_t exthdr_len;
|
|
|
|
|
unsigned char suffix[2+3];
|
|
|
|
|
size_t suffix_len;
|
|
|
|
|
unsigned char *tp;
|
|
|
|
|
size_t datalen;
|
|
|
|
|
unsigned char *template;
|
|
|
|
|
size_t template_size;
|
|
|
|
|
|
|
|
|
|
*result = NULL;
|
|
|
|
|
*resultlen = 0;
|
|
|
|
|
|
2013-03-08 03:40:37 +01:00
|
|
|
|
switch (app->app_local->keyattr[keyno].rsa.format)
|
2008-09-25 12:06:02 +02:00
|
|
|
|
{
|
|
|
|
|
case RSA_STD:
|
|
|
|
|
case RSA_STD_N:
|
|
|
|
|
case RSA_CRT:
|
|
|
|
|
case RSA_CRT_N:
|
2013-08-28 11:21:10 +02:00
|
|
|
|
break;
|
2008-09-25 12:06:02 +02:00
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-28 11:21:10 +02:00
|
|
|
|
/* Get the required length for E. Rounded up to the nearest byte */
|
|
|
|
|
rsa_e_reqlen = (app->app_local->keyattr[keyno].rsa.e_bits + 7) / 8;
|
2008-09-25 12:06:02 +02:00
|
|
|
|
assert (rsa_e_len <= rsa_e_reqlen);
|
|
|
|
|
|
|
|
|
|
/* Build the 7f48 cardholder private key template. */
|
|
|
|
|
datalen = 0;
|
|
|
|
|
tp = privkey;
|
|
|
|
|
|
|
|
|
|
tp += add_tlv (tp, 0x91, rsa_e_reqlen);
|
|
|
|
|
datalen += rsa_e_reqlen;
|
|
|
|
|
|
|
|
|
|
tp += add_tlv (tp, 0x92, rsa_p_len);
|
|
|
|
|
datalen += rsa_p_len;
|
|
|
|
|
|
|
|
|
|
tp += add_tlv (tp, 0x93, rsa_q_len);
|
|
|
|
|
datalen += rsa_q_len;
|
|
|
|
|
|
2013-08-28 11:21:10 +02:00
|
|
|
|
if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
|
|
|
|
|
|| app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
|
|
|
|
|
{
|
|
|
|
|
tp += add_tlv (tp, 0x94, rsa_u_len);
|
|
|
|
|
datalen += rsa_u_len;
|
|
|
|
|
tp += add_tlv (tp, 0x95, rsa_dp_len);
|
|
|
|
|
datalen += rsa_dp_len;
|
|
|
|
|
tp += add_tlv (tp, 0x96, rsa_dq_len);
|
|
|
|
|
datalen += rsa_dq_len;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-08 03:40:37 +01:00
|
|
|
|
if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
|
|
|
|
|
|| app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
|
2008-09-25 12:06:02 +02:00
|
|
|
|
{
|
|
|
|
|
tp += add_tlv (tp, 0x97, rsa_n_len);
|
|
|
|
|
datalen += rsa_n_len;
|
|
|
|
|
}
|
|
|
|
|
privkey_len = tp - privkey;
|
|
|
|
|
|
|
|
|
|
/* Build the extended header list without the private key template. */
|
|
|
|
|
tp = exthdr;
|
|
|
|
|
*tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
|
|
|
|
|
*tp++ = 0;
|
|
|
|
|
tp += add_tlv (tp, 0x7f48, privkey_len);
|
|
|
|
|
exthdr_len = tp - exthdr;
|
|
|
|
|
|
|
|
|
|
/* Build the 5f48 suffix of the data. */
|
|
|
|
|
tp = suffix;
|
|
|
|
|
tp += add_tlv (tp, 0x5f48, datalen);
|
|
|
|
|
suffix_len = tp - suffix;
|
|
|
|
|
|
|
|
|
|
/* Now concatenate everything. */
|
|
|
|
|
template_size = (1 + 3 /* 0x4d and len. */
|
|
|
|
|
+ exthdr_len
|
|
|
|
|
+ privkey_len
|
|
|
|
|
+ suffix_len
|
|
|
|
|
+ datalen);
|
|
|
|
|
tp = template = xtrymalloc_secure (template_size);
|
|
|
|
|
if (!template)
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
|
|
|
|
|
tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
|
|
|
|
|
memcpy (tp, exthdr, exthdr_len);
|
|
|
|
|
tp += exthdr_len;
|
|
|
|
|
memcpy (tp, privkey, privkey_len);
|
|
|
|
|
tp += privkey_len;
|
|
|
|
|
memcpy (tp, suffix, suffix_len);
|
|
|
|
|
tp += suffix_len;
|
|
|
|
|
|
|
|
|
|
memcpy (tp, rsa_e, rsa_e_len);
|
|
|
|
|
if (rsa_e_len < rsa_e_reqlen)
|
|
|
|
|
{
|
|
|
|
|
/* Right justify E. */
|
|
|
|
|
memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
|
|
|
|
|
memset (tp, 0, rsa_e_reqlen - rsa_e_len);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
}
|
2008-09-25 12:06:02 +02:00
|
|
|
|
tp += rsa_e_reqlen;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
memcpy (tp, rsa_p, rsa_p_len);
|
|
|
|
|
tp += rsa_p_len;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
memcpy (tp, rsa_q, rsa_q_len);
|
|
|
|
|
tp += rsa_q_len;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2013-08-28 11:21:10 +02:00
|
|
|
|
if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
|
|
|
|
|
|| app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
|
|
|
|
|
{
|
|
|
|
|
memcpy (tp, rsa_u, rsa_u_len);
|
|
|
|
|
tp += rsa_u_len;
|
|
|
|
|
memcpy (tp, rsa_dp, rsa_dp_len);
|
|
|
|
|
tp += rsa_dp_len;
|
|
|
|
|
memcpy (tp, rsa_dq, rsa_dq_len);
|
|
|
|
|
tp += rsa_dq_len;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-08 03:40:37 +01:00
|
|
|
|
if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
|
|
|
|
|
|| app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
|
2008-09-25 12:06:02 +02:00
|
|
|
|
{
|
|
|
|
|
memcpy (tp, rsa_n, rsa_n_len);
|
|
|
|
|
tp += rsa_n_len;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Sanity check. We don't know the exact length because we
|
|
|
|
|
allocated 3 bytes for the first length header. */
|
|
|
|
|
assert (tp - template <= template_size);
|
|
|
|
|
|
|
|
|
|
*result = template;
|
|
|
|
|
*resultlen = tp - template;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-12 09:25:33 +01:00
|
|
|
|
static gpg_error_t
|
2014-04-09 02:30:19 +02:00
|
|
|
|
build_ecc_privkey_template (app_t app, int keyno,
|
|
|
|
|
const unsigned char *ecc_d, size_t ecc_d_len,
|
2016-09-16 08:20:32 +02:00
|
|
|
|
const unsigned char *ecc_q, size_t ecc_q_len,
|
2014-04-09 02:30:19 +02:00
|
|
|
|
unsigned char **result, size_t *resultlen)
|
2014-03-12 09:25:33 +01:00
|
|
|
|
{
|
2020-07-31 10:03:09 +02:00
|
|
|
|
unsigned char privkey[2*(1+3)];
|
2014-03-12 09:25:33 +01:00
|
|
|
|
size_t privkey_len;
|
2020-07-31 10:03:09 +02:00
|
|
|
|
unsigned char exthdr[2+2+3];
|
2014-03-12 09:25:33 +01:00
|
|
|
|
size_t exthdr_len;
|
2020-07-31 10:03:09 +02:00
|
|
|
|
unsigned char suffix[2+3];
|
2014-03-12 09:25:33 +01:00
|
|
|
|
size_t suffix_len;
|
|
|
|
|
unsigned char *tp;
|
|
|
|
|
size_t datalen;
|
|
|
|
|
unsigned char *template;
|
|
|
|
|
size_t template_size;
|
2016-09-16 08:20:32 +02:00
|
|
|
|
int pubkey_required;
|
2014-03-12 09:25:33 +01:00
|
|
|
|
|
2016-09-16 08:20:32 +02:00
|
|
|
|
pubkey_required = !!(app->app_local->keyattr[keyno].ecc.flags
|
|
|
|
|
& ECC_FLAG_PUBKEY);
|
2014-04-08 10:01:36 +02:00
|
|
|
|
|
2014-03-12 09:25:33 +01:00
|
|
|
|
*result = NULL;
|
|
|
|
|
*resultlen = 0;
|
|
|
|
|
|
|
|
|
|
/* Build the 7f48 cardholder private key template. */
|
|
|
|
|
datalen = 0;
|
|
|
|
|
tp = privkey;
|
|
|
|
|
|
2015-05-29 07:06:38 +02:00
|
|
|
|
tp += add_tlv (tp, 0x92, ecc_d_len);
|
2014-03-12 09:25:33 +01:00
|
|
|
|
datalen += ecc_d_len;
|
|
|
|
|
|
2016-09-16 08:20:32 +02:00
|
|
|
|
if (pubkey_required)
|
|
|
|
|
{
|
|
|
|
|
tp += add_tlv (tp, 0x99, ecc_q_len);
|
|
|
|
|
datalen += ecc_q_len;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-12 09:25:33 +01:00
|
|
|
|
privkey_len = tp - privkey;
|
|
|
|
|
|
2016-09-16 08:20:32 +02:00
|
|
|
|
|
2014-03-12 09:25:33 +01:00
|
|
|
|
/* Build the extended header list without the private key template. */
|
|
|
|
|
tp = exthdr;
|
|
|
|
|
*tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
|
|
|
|
|
*tp++ = 0;
|
|
|
|
|
tp += add_tlv (tp, 0x7f48, privkey_len);
|
|
|
|
|
exthdr_len = tp - exthdr;
|
|
|
|
|
|
|
|
|
|
/* Build the 5f48 suffix of the data. */
|
|
|
|
|
tp = suffix;
|
|
|
|
|
tp += add_tlv (tp, 0x5f48, datalen);
|
|
|
|
|
suffix_len = tp - suffix;
|
|
|
|
|
|
|
|
|
|
/* Now concatenate everything. */
|
|
|
|
|
template_size = (1 + 1 /* 0x4d and len. */
|
|
|
|
|
+ exthdr_len
|
|
|
|
|
+ privkey_len
|
|
|
|
|
+ suffix_len
|
|
|
|
|
+ datalen);
|
2016-10-17 05:02:28 +02:00
|
|
|
|
if (exthdr_len + privkey_len + suffix_len + datalen >= 128)
|
|
|
|
|
template_size++;
|
2014-03-12 09:25:33 +01:00
|
|
|
|
tp = template = xtrymalloc_secure (template_size);
|
|
|
|
|
if (!template)
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
|
|
|
|
|
tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
|
|
|
|
|
memcpy (tp, exthdr, exthdr_len);
|
|
|
|
|
tp += exthdr_len;
|
|
|
|
|
memcpy (tp, privkey, privkey_len);
|
|
|
|
|
tp += privkey_len;
|
|
|
|
|
memcpy (tp, suffix, suffix_len);
|
|
|
|
|
tp += suffix_len;
|
|
|
|
|
|
|
|
|
|
memcpy (tp, ecc_d, ecc_d_len);
|
|
|
|
|
tp += ecc_d_len;
|
|
|
|
|
|
2016-09-16 08:20:32 +02:00
|
|
|
|
if (pubkey_required)
|
|
|
|
|
{
|
|
|
|
|
memcpy (tp, ecc_q, ecc_q_len);
|
|
|
|
|
tp += ecc_q_len;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-12 09:25:33 +01:00
|
|
|
|
assert (tp - template == template_size);
|
|
|
|
|
|
|
|
|
|
*result = template;
|
|
|
|
|
*resultlen = tp - template;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
|
2009-07-09 16:54:18 +02:00
|
|
|
|
/* Helper for do_writekley to change the size of a key. Not ethat
|
|
|
|
|
this deletes the entire key without asking. */
|
|
|
|
|
static gpg_error_t
|
2015-07-21 07:27:02 +02:00
|
|
|
|
change_keyattr (app_t app, int keyno, const unsigned char *buf, size_t buflen,
|
2009-07-09 16:54:18 +02:00
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
|
|
|
|
void *pincb_arg)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
|
|
|
|
|
assert (keyno >=0 && keyno <= 2);
|
|
|
|
|
|
|
|
|
|
/* Prepare for storing the key. */
|
|
|
|
|
err = verify_chv3 (app, pincb, pincb_arg);
|
|
|
|
|
if (err)
|
2015-07-21 07:27:02 +02:00
|
|
|
|
return err;
|
2009-07-09 16:54:18 +02:00
|
|
|
|
|
|
|
|
|
/* Change the attribute. */
|
2015-07-21 07:27:02 +02:00
|
|
|
|
err = iso7816_put_data (app->slot, 0, 0xC1+keyno, buf, buflen);
|
2009-07-09 16:54:18 +02:00
|
|
|
|
if (err)
|
2015-07-21 07:27:02 +02:00
|
|
|
|
log_error ("error changing key attribute (key=%d)\n", keyno+1);
|
2009-07-09 16:54:18 +02:00
|
|
|
|
else
|
2015-07-21 07:27:02 +02:00
|
|
|
|
log_info ("key attribute changed (key=%d)\n", keyno+1);
|
2009-07-09 16:54:18 +02:00
|
|
|
|
flush_cache (app);
|
|
|
|
|
parse_algorithm_attribute (app, keyno);
|
2009-07-10 12:47:30 +02:00
|
|
|
|
app->did_chv1 = 0;
|
|
|
|
|
app->did_chv2 = 0;
|
|
|
|
|
app->did_chv3 = 0;
|
2009-07-09 16:54:18 +02:00
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-09-07 06:49:47 +02:00
|
|
|
|
static gpg_error_t
|
|
|
|
|
change_rsa_keyattr (app_t app, int keyno, unsigned int nbits,
|
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
|
|
|
|
void *pincb_arg)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err = 0;
|
|
|
|
|
unsigned char *buf;
|
|
|
|
|
size_t buflen;
|
|
|
|
|
void *relptr;
|
|
|
|
|
|
|
|
|
|
/* Read the current attributes into a buffer. */
|
|
|
|
|
relptr = get_one_do (app, 0xC1+keyno, &buf, &buflen, NULL);
|
|
|
|
|
if (!relptr)
|
|
|
|
|
err = gpg_error (GPG_ERR_CARD);
|
2018-03-30 02:59:09 +02:00
|
|
|
|
else if (buflen < 6)
|
2015-09-07 06:49:47 +02:00
|
|
|
|
{
|
2018-03-30 02:59:09 +02:00
|
|
|
|
/* Attributes too short. */
|
2015-09-07 06:49:47 +02:00
|
|
|
|
xfree (relptr);
|
|
|
|
|
err = gpg_error (GPG_ERR_CARD);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2018-03-30 02:59:09 +02:00
|
|
|
|
/* If key attribute was RSA, we only change n_bits and don't
|
|
|
|
|
touch anything else. Before we do so, we round up NBITS to a
|
|
|
|
|
sensible way in the same way as gpg's key generation does it.
|
|
|
|
|
This may help to sort out problems with a few bits too short
|
|
|
|
|
keys. */
|
2015-09-07 06:49:47 +02:00
|
|
|
|
nbits = ((nbits + 31) / 32) * 32;
|
|
|
|
|
buf[1] = (nbits >> 8);
|
|
|
|
|
buf[2] = nbits;
|
2018-03-30 02:59:09 +02:00
|
|
|
|
|
|
|
|
|
/* If it was not RSA, we need to fill other parts. */
|
|
|
|
|
if (buf[0] != PUBKEY_ALGO_RSA)
|
|
|
|
|
{
|
|
|
|
|
buf[0] = PUBKEY_ALGO_RSA;
|
|
|
|
|
buf[3] = 0;
|
|
|
|
|
buf[4] = 32;
|
|
|
|
|
buf[5] = 0;
|
|
|
|
|
buflen = 6;
|
|
|
|
|
}
|
|
|
|
|
|
2015-09-07 06:49:47 +02:00
|
|
|
|
err = change_keyattr (app, keyno, buf, buflen, pincb, pincb_arg);
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-07-21 07:27:02 +02:00
|
|
|
|
/* Helper to process an setattr command for name KEY-ATTR.
|
|
|
|
|
In (VALUE,VALUELEN), it expects following string:
|
2015-09-07 06:09:01 +02:00
|
|
|
|
RSA: "--force <key> <algo> rsa<nbits>"
|
|
|
|
|
ECC: "--force <key> <algo> <curvename>"
|
2015-07-21 07:27:02 +02:00
|
|
|
|
*/
|
2011-02-04 12:57:53 +01:00
|
|
|
|
static gpg_error_t
|
|
|
|
|
change_keyattr_from_string (app_t app,
|
2009-08-05 13:24:43 +02:00
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
|
|
|
|
void *pincb_arg,
|
|
|
|
|
const void *value, size_t valuelen)
|
|
|
|
|
{
|
2015-07-21 07:27:02 +02:00
|
|
|
|
gpg_error_t err = 0;
|
2009-08-05 13:24:43 +02:00
|
|
|
|
char *string;
|
2015-09-07 06:09:01 +02:00
|
|
|
|
int key, keyno, algo;
|
2015-07-21 07:27:02 +02:00
|
|
|
|
int n = 0;
|
2009-08-05 13:24:43 +02:00
|
|
|
|
|
|
|
|
|
/* VALUE is expected to be a string but not guaranteed to be
|
|
|
|
|
terminated. Thus copy it to an allocated buffer first. */
|
|
|
|
|
string = xtrymalloc (valuelen+1);
|
|
|
|
|
if (!string)
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
memcpy (string, value, valuelen);
|
|
|
|
|
string[valuelen] = 0;
|
|
|
|
|
|
|
|
|
|
/* Because this function deletes the key we require the string
|
|
|
|
|
"--force" in the data to make clear that something serious might
|
|
|
|
|
happen. */
|
2015-11-04 02:48:59 +01:00
|
|
|
|
sscanf (string, "--force %d %d %n", &key, &algo, &n);
|
|
|
|
|
if (n < 12)
|
2015-07-21 07:27:02 +02:00
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_INV_DATA);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2015-09-07 06:09:01 +02:00
|
|
|
|
keyno = key - 1;
|
|
|
|
|
if (keyno < 0 || keyno > 2)
|
2009-08-05 13:24:43 +02:00
|
|
|
|
err = gpg_error (GPG_ERR_INV_ID);
|
2015-07-21 07:27:02 +02:00
|
|
|
|
else if (algo == PUBKEY_ALGO_RSA)
|
|
|
|
|
{
|
|
|
|
|
unsigned int nbits;
|
|
|
|
|
|
|
|
|
|
errno = 0;
|
2015-07-23 07:10:03 +02:00
|
|
|
|
nbits = strtoul (string+n+3, NULL, 10);
|
2015-07-21 07:27:02 +02:00
|
|
|
|
if (errno)
|
|
|
|
|
err = gpg_error (GPG_ERR_INV_DATA);
|
|
|
|
|
else if (nbits < 1024)
|
|
|
|
|
err = gpg_error (GPG_ERR_TOO_SHORT);
|
|
|
|
|
else if (nbits > 4096)
|
|
|
|
|
err = gpg_error (GPG_ERR_TOO_LARGE);
|
|
|
|
|
else
|
2015-09-07 06:49:47 +02:00
|
|
|
|
err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
|
2015-07-21 07:27:02 +02:00
|
|
|
|
}
|
|
|
|
|
else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA
|
|
|
|
|
|| algo == PUBKEY_ALGO_EDDSA)
|
|
|
|
|
{
|
|
|
|
|
const char *oidstr;
|
2015-09-07 06:09:01 +02:00
|
|
|
|
gcry_mpi_t oid;
|
|
|
|
|
const unsigned char *oidbuf;
|
|
|
|
|
size_t oid_len;
|
2015-07-21 07:27:02 +02:00
|
|
|
|
|
|
|
|
|
oidstr = openpgp_curve_to_oid (string+n, NULL);
|
|
|
|
|
if (!oidstr)
|
|
|
|
|
{
|
2015-09-07 06:09:01 +02:00
|
|
|
|
err = gpg_error (GPG_ERR_INV_DATA);
|
|
|
|
|
goto leave;
|
2015-07-21 07:27:02 +02:00
|
|
|
|
}
|
2015-09-07 06:09:01 +02:00
|
|
|
|
|
|
|
|
|
err = openpgp_oid_from_str (oidstr, &oid);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
oidbuf = gcry_mpi_get_opaque (oid, &n);
|
|
|
|
|
oid_len = (n+7)/8;
|
|
|
|
|
|
|
|
|
|
/* We have enough room at STRING. */
|
|
|
|
|
string[0] = algo;
|
|
|
|
|
memcpy (string+1, oidbuf+1, oid_len-1);
|
|
|
|
|
err = change_keyattr (app, keyno, string, oid_len, pincb, pincb_arg);
|
2016-10-21 09:27:46 +02:00
|
|
|
|
gcry_mpi_release (oid);
|
2015-07-21 07:27:02 +02:00
|
|
|
|
}
|
2009-08-05 13:24:43 +02:00
|
|
|
|
else
|
2015-07-21 07:27:02 +02:00
|
|
|
|
err = gpg_error (GPG_ERR_PUBKEY_ALGO);
|
2009-08-05 13:24:43 +02:00
|
|
|
|
|
2015-07-21 07:27:02 +02:00
|
|
|
|
leave:
|
2009-08-05 13:24:43 +02:00
|
|
|
|
xfree (string);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2005-05-20 22:39:36 +02:00
|
|
|
|
|
|
|
|
|
static gpg_error_t
|
2014-03-12 09:25:33 +01:00
|
|
|
|
rsa_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
|
|
|
|
|
void *pincb_arg, int keyno,
|
|
|
|
|
const unsigned char *buf, size_t buflen, int depth)
|
2005-05-20 22:39:36 +02:00
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
2014-03-12 09:25:33 +01:00
|
|
|
|
const unsigned char *tok;
|
|
|
|
|
size_t toklen;
|
|
|
|
|
int last_depth1, last_depth2;
|
2005-05-20 22:39:36 +02:00
|
|
|
|
const unsigned char *rsa_n = NULL;
|
|
|
|
|
const unsigned char *rsa_e = NULL;
|
|
|
|
|
const unsigned char *rsa_p = NULL;
|
|
|
|
|
const unsigned char *rsa_q = NULL;
|
|
|
|
|
size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
|
|
|
|
|
unsigned int nbits;
|
2008-09-25 12:06:02 +02:00
|
|
|
|
unsigned int maxbits;
|
2005-05-20 22:39:36 +02:00
|
|
|
|
unsigned char *template = NULL;
|
|
|
|
|
unsigned char *tp;
|
|
|
|
|
size_t template_len;
|
|
|
|
|
unsigned char fprbuf[20];
|
|
|
|
|
u32 created_at = 0;
|
|
|
|
|
|
2015-07-23 07:10:03 +02:00
|
|
|
|
if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_RSA)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("unsupported algorithm: %s"), "RSA");
|
|
|
|
|
err = gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2005-05-20 22:39:36 +02:00
|
|
|
|
last_depth1 = depth;
|
|
|
|
|
while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
|
|
|
|
|
&& depth && depth >= last_depth1)
|
|
|
|
|
{
|
|
|
|
|
if (tok)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
|
|
|
|
|
goto leave;
|
|
|
|
|
if (tok && toklen == 1)
|
|
|
|
|
{
|
|
|
|
|
const unsigned char **mpi;
|
|
|
|
|
size_t *mpi_len;
|
|
|
|
|
|
|
|
|
|
switch (*tok)
|
|
|
|
|
{
|
2011-02-04 12:57:53 +01:00
|
|
|
|
case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
|
|
|
|
|
case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
|
|
|
|
|
case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break;
|
|
|
|
|
case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break;
|
2005-05-20 22:39:36 +02:00
|
|
|
|
default: mpi = NULL; mpi_len = NULL; break;
|
|
|
|
|
}
|
|
|
|
|
if (mpi && *mpi)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_DUP_VALUE);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
|
|
|
|
|
goto leave;
|
|
|
|
|
if (tok && mpi)
|
|
|
|
|
{
|
|
|
|
|
/* Strip off leading zero bytes and save. */
|
|
|
|
|
for (;toklen && !*tok; toklen--, tok++)
|
|
|
|
|
;
|
|
|
|
|
*mpi = tok;
|
|
|
|
|
*mpi_len = toklen;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/* Skip until end of list. */
|
|
|
|
|
last_depth2 = depth;
|
|
|
|
|
while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
|
|
|
|
|
&& depth && depth >= last_depth2)
|
|
|
|
|
;
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
/* Parse other attributes. */
|
|
|
|
|
last_depth1 = depth;
|
|
|
|
|
while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
|
|
|
|
|
&& depth && depth >= last_depth1)
|
|
|
|
|
{
|
|
|
|
|
if (tok)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
|
|
|
|
|
goto leave;
|
|
|
|
|
if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
|
|
|
|
|
{
|
|
|
|
|
if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
|
|
|
|
|
goto leave;
|
|
|
|
|
if (tok)
|
|
|
|
|
{
|
|
|
|
|
for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
|
|
|
|
|
tok++, toklen--)
|
|
|
|
|
created_at = created_at*10 + (*tok - '0');
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/* Skip until end of list. */
|
|
|
|
|
last_depth2 = depth;
|
|
|
|
|
while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
|
|
|
|
|
&& depth && depth >= last_depth2)
|
|
|
|
|
;
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Check that we have all parameters and that they match the card
|
|
|
|
|
description. */
|
|
|
|
|
if (!created_at)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("creation timestamp missing\n"));
|
|
|
|
|
err = gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2008-09-25 12:06:02 +02:00
|
|
|
|
|
2013-03-08 03:40:37 +01:00
|
|
|
|
maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
|
2005-05-20 22:39:36 +02:00
|
|
|
|
nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
|
2009-05-15 21:26:46 +02:00
|
|
|
|
if (opt.verbose)
|
2017-03-06 07:14:18 +01:00
|
|
|
|
log_info ("RSA modulus size is %u bits\n", nbits);
|
2015-09-07 06:49:47 +02:00
|
|
|
|
if (nbits && nbits != maxbits
|
|
|
|
|
&& app->app_local->extcap.algo_attr_change)
|
|
|
|
|
{
|
|
|
|
|
/* Try to switch the key to a new length. */
|
|
|
|
|
err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
|
|
|
|
|
if (!err)
|
|
|
|
|
maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
|
|
|
|
|
}
|
2008-09-25 12:06:02 +02:00
|
|
|
|
if (nbits != maxbits)
|
2005-05-20 22:39:36 +02:00
|
|
|
|
{
|
2011-02-04 12:57:53 +01:00
|
|
|
|
log_error (_("RSA modulus missing or not of size %d bits\n"),
|
2008-09-25 12:06:02 +02:00
|
|
|
|
(int)maxbits);
|
2005-05-20 22:39:36 +02:00
|
|
|
|
err = gpg_error (GPG_ERR_BAD_SECKEY);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2008-09-25 12:06:02 +02:00
|
|
|
|
|
2013-03-08 03:40:37 +01:00
|
|
|
|
maxbits = app->app_local->keyattr[keyno].rsa.e_bits;
|
2008-09-25 12:06:02 +02:00
|
|
|
|
if (maxbits > 32 && !app->app_local->extcap.is_v2)
|
|
|
|
|
maxbits = 32; /* Our code for v1 does only support 32 bits. */
|
2005-05-20 22:39:36 +02:00
|
|
|
|
nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
|
2008-09-25 12:06:02 +02:00
|
|
|
|
if (nbits < 2 || nbits > maxbits)
|
2005-05-20 22:39:36 +02:00
|
|
|
|
{
|
2005-06-03 15:57:24 +02:00
|
|
|
|
log_error (_("RSA public exponent missing or larger than %d bits\n"),
|
2008-09-25 12:06:02 +02:00
|
|
|
|
(int)maxbits);
|
2005-05-20 22:39:36 +02:00
|
|
|
|
err = gpg_error (GPG_ERR_BAD_SECKEY);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2008-09-25 12:06:02 +02:00
|
|
|
|
|
2013-03-08 03:40:37 +01:00
|
|
|
|
maxbits = app->app_local->keyattr[keyno].rsa.n_bits/2;
|
2005-05-20 22:39:36 +02:00
|
|
|
|
nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
|
2008-09-25 12:06:02 +02:00
|
|
|
|
if (nbits != maxbits)
|
2005-05-20 22:39:36 +02:00
|
|
|
|
{
|
2011-02-04 12:57:53 +01:00
|
|
|
|
log_error (_("RSA prime %s missing or not of size %d bits\n"),
|
2008-09-25 12:06:02 +02:00
|
|
|
|
"P", (int)maxbits);
|
2005-05-20 22:39:36 +02:00
|
|
|
|
err = gpg_error (GPG_ERR_BAD_SECKEY);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
|
2008-09-25 12:06:02 +02:00
|
|
|
|
if (nbits != maxbits)
|
2005-05-20 22:39:36 +02:00
|
|
|
|
{
|
2011-02-04 12:57:53 +01:00
|
|
|
|
log_error (_("RSA prime %s missing or not of size %d bits\n"),
|
2008-09-25 12:06:02 +02:00
|
|
|
|
"Q", (int)maxbits);
|
2005-05-20 22:39:36 +02:00
|
|
|
|
err = gpg_error (GPG_ERR_BAD_SECKEY);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
/* We need to remove the cached public key. */
|
2005-05-20 22:39:36 +02:00
|
|
|
|
xfree (app->app_local->pk[keyno].key);
|
|
|
|
|
app->app_local->pk[keyno].key = NULL;
|
|
|
|
|
app->app_local->pk[keyno].keylen = 0;
|
|
|
|
|
app->app_local->pk[keyno].read_done = 0;
|
|
|
|
|
|
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
if (app->app_local->extcap.is_v2)
|
|
|
|
|
{
|
2013-08-28 11:21:10 +02:00
|
|
|
|
unsigned char *rsa_u, *rsa_dp, *rsa_dq;
|
|
|
|
|
size_t rsa_u_len, rsa_dp_len, rsa_dq_len;
|
|
|
|
|
gcry_mpi_t mpi_e, mpi_p, mpi_q;
|
|
|
|
|
gcry_mpi_t mpi_u = gcry_mpi_snew (0);
|
|
|
|
|
gcry_mpi_t mpi_dp = gcry_mpi_snew (0);
|
|
|
|
|
gcry_mpi_t mpi_dq = gcry_mpi_snew (0);
|
|
|
|
|
gcry_mpi_t mpi_tmp = gcry_mpi_snew (0);
|
2008-09-25 12:06:02 +02:00
|
|
|
|
int exmode;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2013-08-28 11:21:10 +02:00
|
|
|
|
/* Calculate the u, dp and dq components needed by RSA_CRT cards */
|
|
|
|
|
gcry_mpi_scan (&mpi_e, GCRYMPI_FMT_USG, rsa_e, rsa_e_len, NULL);
|
|
|
|
|
gcry_mpi_scan (&mpi_p, GCRYMPI_FMT_USG, rsa_p, rsa_p_len, NULL);
|
|
|
|
|
gcry_mpi_scan (&mpi_q, GCRYMPI_FMT_USG, rsa_q, rsa_q_len, NULL);
|
|
|
|
|
|
|
|
|
|
gcry_mpi_invm (mpi_u, mpi_q, mpi_p);
|
|
|
|
|
gcry_mpi_sub_ui (mpi_tmp, mpi_p, 1);
|
|
|
|
|
gcry_mpi_invm (mpi_dp, mpi_e, mpi_tmp);
|
|
|
|
|
gcry_mpi_sub_ui (mpi_tmp, mpi_q, 1);
|
|
|
|
|
gcry_mpi_invm (mpi_dq, mpi_e, mpi_tmp);
|
|
|
|
|
|
|
|
|
|
gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_u, &rsa_u_len, mpi_u);
|
|
|
|
|
gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dp, &rsa_dp_len, mpi_dp);
|
|
|
|
|
gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dq, &rsa_dq_len, mpi_dq);
|
|
|
|
|
|
|
|
|
|
gcry_mpi_release (mpi_e);
|
|
|
|
|
gcry_mpi_release (mpi_p);
|
|
|
|
|
gcry_mpi_release (mpi_q);
|
|
|
|
|
gcry_mpi_release (mpi_u);
|
|
|
|
|
gcry_mpi_release (mpi_dp);
|
|
|
|
|
gcry_mpi_release (mpi_dq);
|
|
|
|
|
gcry_mpi_release (mpi_tmp);
|
|
|
|
|
|
|
|
|
|
/* Build the private key template as described in section 4.3.3.7 of
|
|
|
|
|
the OpenPGP card specs version 2.0. */
|
2008-09-25 12:06:02 +02:00
|
|
|
|
err = build_privkey_template (app, keyno,
|
|
|
|
|
rsa_n, rsa_n_len,
|
|
|
|
|
rsa_e, rsa_e_len,
|
|
|
|
|
rsa_p, rsa_p_len,
|
|
|
|
|
rsa_q, rsa_q_len,
|
2013-08-28 11:21:10 +02:00
|
|
|
|
rsa_u, rsa_u_len,
|
|
|
|
|
rsa_dp, rsa_dp_len,
|
|
|
|
|
rsa_dq, rsa_dq_len,
|
2008-09-25 12:06:02 +02:00
|
|
|
|
&template, &template_len);
|
2013-08-28 11:21:10 +02:00
|
|
|
|
xfree(rsa_u);
|
|
|
|
|
xfree(rsa_dp);
|
|
|
|
|
xfree(rsa_dq);
|
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
/* Prepare for storing the key. */
|
|
|
|
|
err = verify_chv3 (app, pincb, pincb_arg);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
/* Store the key. */
|
2009-04-01 16:38:22 +02:00
|
|
|
|
if (app->app_local->cardcap.ext_lc_le && template_len > 254)
|
|
|
|
|
exmode = 1; /* Use extended length w/o a limit. */
|
|
|
|
|
else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
|
2008-09-25 12:06:02 +02:00
|
|
|
|
exmode = -254;
|
|
|
|
|
else
|
|
|
|
|
exmode = 0;
|
|
|
|
|
err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
|
|
|
|
|
template, template_len);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Build the private key template as described in section 4.3.3.6 of
|
|
|
|
|
the OpenPGP card specs version 1.1:
|
|
|
|
|
0xC0 <length> public exponent
|
2011-02-04 12:57:53 +01:00
|
|
|
|
0xC1 <length> prime p
|
|
|
|
|
0xC2 <length> prime q
|
2008-09-25 12:06:02 +02:00
|
|
|
|
*/
|
|
|
|
|
assert (rsa_e_len <= 4);
|
|
|
|
|
template_len = (1 + 1 + 4
|
|
|
|
|
+ 1 + 1 + rsa_p_len
|
|
|
|
|
+ 1 + 1 + rsa_q_len);
|
|
|
|
|
template = tp = xtrymalloc_secure (template_len);
|
|
|
|
|
if (!template)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
*tp++ = 0xC0;
|
|
|
|
|
*tp++ = 4;
|
|
|
|
|
memcpy (tp, rsa_e, rsa_e_len);
|
|
|
|
|
if (rsa_e_len < 4)
|
|
|
|
|
{
|
|
|
|
|
/* Right justify E. */
|
|
|
|
|
memmove (tp+4-rsa_e_len, tp, rsa_e_len);
|
|
|
|
|
memset (tp, 0, 4-rsa_e_len);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
}
|
2008-09-25 12:06:02 +02:00
|
|
|
|
tp += 4;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
*tp++ = 0xC1;
|
|
|
|
|
*tp++ = rsa_p_len;
|
|
|
|
|
memcpy (tp, rsa_p, rsa_p_len);
|
|
|
|
|
tp += rsa_p_len;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
*tp++ = 0xC2;
|
|
|
|
|
*tp++ = rsa_q_len;
|
|
|
|
|
memcpy (tp, rsa_q, rsa_q_len);
|
|
|
|
|
tp += rsa_q_len;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
assert (tp - template == template_len);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
/* Prepare for storing the key. */
|
|
|
|
|
err = verify_chv3 (app, pincb, pincb_arg);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
/* Store the key. */
|
|
|
|
|
err = iso7816_put_data (app->slot, 0,
|
|
|
|
|
(app->card_version > 0x0007? 0xE0:0xE9)+keyno,
|
|
|
|
|
template, template_len);
|
|
|
|
|
}
|
2005-05-20 22:39:36 +02:00
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2015-07-25 05:09:23 +02:00
|
|
|
|
err = store_fpr (app, keyno, created_at, fprbuf, PUBKEY_ALGO_RSA,
|
2015-01-28 03:24:29 +01:00
|
|
|
|
rsa_n, rsa_n_len, rsa_e, rsa_e_len);
|
2014-03-12 09:25:33 +01:00
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
leave:
|
|
|
|
|
xfree (template);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static gpg_error_t
|
2014-04-09 02:30:19 +02:00
|
|
|
|
ecc_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
|
|
|
|
|
void *pincb_arg, int keyno,
|
|
|
|
|
const unsigned char *buf, size_t buflen, int depth)
|
2014-03-12 09:25:33 +01:00
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
const unsigned char *tok;
|
|
|
|
|
size_t toklen;
|
|
|
|
|
int last_depth1, last_depth2;
|
|
|
|
|
const unsigned char *ecc_q = NULL;
|
|
|
|
|
const unsigned char *ecc_d = NULL;
|
|
|
|
|
size_t ecc_q_len, ecc_d_len;
|
2016-10-24 04:22:44 +02:00
|
|
|
|
const char *curve = NULL;
|
2014-03-12 09:25:33 +01:00
|
|
|
|
u32 created_at = 0;
|
2016-10-24 04:22:44 +02:00
|
|
|
|
const char *oidstr;
|
2015-08-06 10:00:41 +02:00
|
|
|
|
int flag_djb_tweak = 0;
|
2015-07-25 05:09:23 +02:00
|
|
|
|
int algo;
|
2016-10-21 14:37:04 +02:00
|
|
|
|
gcry_mpi_t oid = NULL;
|
|
|
|
|
const unsigned char *oidbuf;
|
2015-09-07 06:09:01 +02:00
|
|
|
|
unsigned int n;
|
|
|
|
|
size_t oid_len;
|
|
|
|
|
unsigned char fprbuf[20];
|
2014-04-09 02:30:19 +02:00
|
|
|
|
|
2014-12-05 06:20:50 +01:00
|
|
|
|
/* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
|
|
|
|
|
curve = "NIST P-256" */
|
2014-04-09 02:30:19 +02:00
|
|
|
|
/* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
|
|
|
|
|
curve = "secp256k1" */
|
|
|
|
|
/* (private-key(ecc(curve%s)(flags eddsa)(q%m)(d%m))(created-at%d)):
|
|
|
|
|
curve = "Ed25519" */
|
2014-03-12 09:25:33 +01:00
|
|
|
|
last_depth1 = depth;
|
|
|
|
|
while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
|
|
|
|
|
&& depth && depth >= last_depth1)
|
|
|
|
|
{
|
|
|
|
|
if (tok)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
if (tok && toklen == 5 && !memcmp (tok, "curve", 5))
|
|
|
|
|
{
|
2016-10-24 04:22:44 +02:00
|
|
|
|
char *curve_name;
|
2015-07-25 05:09:23 +02:00
|
|
|
|
|
2014-03-12 09:25:33 +01:00
|
|
|
|
if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
|
|
|
|
|
goto leave;
|
|
|
|
|
|
2016-10-24 04:22:44 +02:00
|
|
|
|
curve_name = xtrymalloc (toklen+1);
|
|
|
|
|
if (!curve_name)
|
2014-12-05 06:20:50 +01:00
|
|
|
|
{
|
2015-07-25 05:09:23 +02:00
|
|
|
|
err = gpg_error_from_syserror ();
|
2014-12-05 06:20:50 +01:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2015-07-25 05:09:23 +02:00
|
|
|
|
|
2016-10-24 04:22:44 +02:00
|
|
|
|
memcpy (curve_name, tok, toklen);
|
|
|
|
|
curve_name[toklen] = 0;
|
2016-12-02 19:43:36 +01:00
|
|
|
|
curve = openpgp_is_curve_supported (curve_name, NULL, NULL);
|
2016-10-24 04:22:44 +02:00
|
|
|
|
xfree (curve_name);
|
2015-07-25 05:09:23 +02:00
|
|
|
|
}
|
|
|
|
|
else if (tok && toklen == 5 && !memcmp (tok, "flags", 5))
|
|
|
|
|
{
|
|
|
|
|
if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
|
|
|
|
|
goto leave;
|
|
|
|
|
|
2015-08-06 10:00:41 +02:00
|
|
|
|
if (tok)
|
|
|
|
|
{
|
|
|
|
|
if ((toklen == 5 && !memcmp (tok, "eddsa", 5))
|
|
|
|
|
|| (toklen == 9 && !memcmp (tok, "djb-tweak", 9)))
|
|
|
|
|
flag_djb_tweak = 1;
|
|
|
|
|
}
|
2014-03-12 09:25:33 +01:00
|
|
|
|
}
|
|
|
|
|
else if (tok && toklen == 1)
|
|
|
|
|
{
|
2014-04-09 02:30:19 +02:00
|
|
|
|
const unsigned char **buf2;
|
|
|
|
|
size_t *buf2len;
|
2015-09-19 09:27:36 +02:00
|
|
|
|
int native = flag_djb_tweak;
|
2014-03-12 09:25:33 +01:00
|
|
|
|
|
|
|
|
|
switch (*tok)
|
|
|
|
|
{
|
2014-04-09 02:30:19 +02:00
|
|
|
|
case 'q': buf2 = &ecc_q; buf2len = &ecc_q_len; break;
|
2015-09-19 09:27:36 +02:00
|
|
|
|
case 'd': buf2 = &ecc_d; buf2len = &ecc_d_len; native = 0; break;
|
2014-04-09 02:30:19 +02:00
|
|
|
|
default: buf2 = NULL; buf2len = NULL; break;
|
2014-03-12 09:25:33 +01:00
|
|
|
|
}
|
2014-04-09 02:30:19 +02:00
|
|
|
|
if (buf2 && *buf2)
|
2014-03-12 09:25:33 +01:00
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_DUP_VALUE);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
|
|
|
|
|
goto leave;
|
2015-09-19 09:27:36 +02:00
|
|
|
|
if (tok && buf2)
|
|
|
|
|
{
|
|
|
|
|
if (!native)
|
|
|
|
|
/* Strip off leading zero bytes and save. */
|
|
|
|
|
for (;toklen && !*tok; toklen--, tok++)
|
|
|
|
|
;
|
2014-04-09 02:30:19 +02:00
|
|
|
|
|
2015-09-19 09:27:36 +02:00
|
|
|
|
*buf2 = tok;
|
|
|
|
|
*buf2len = toklen;
|
|
|
|
|
}
|
2014-03-12 09:25:33 +01:00
|
|
|
|
}
|
|
|
|
|
/* Skip until end of list. */
|
|
|
|
|
last_depth2 = depth;
|
|
|
|
|
while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
|
|
|
|
|
&& depth && depth >= last_depth2)
|
|
|
|
|
;
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
/* Parse other attributes. */
|
|
|
|
|
last_depth1 = depth;
|
|
|
|
|
while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
|
|
|
|
|
&& depth && depth >= last_depth1)
|
|
|
|
|
{
|
|
|
|
|
if (tok)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
|
|
|
|
|
goto leave;
|
|
|
|
|
if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
|
|
|
|
|
{
|
|
|
|
|
if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
|
|
|
|
|
goto leave;
|
|
|
|
|
if (tok)
|
|
|
|
|
{
|
|
|
|
|
for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
|
|
|
|
|
tok++, toklen--)
|
|
|
|
|
created_at = created_at*10 + (*tok - '0');
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/* Skip until end of list. */
|
|
|
|
|
last_depth2 = depth;
|
|
|
|
|
while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
|
|
|
|
|
&& depth && depth >= last_depth2)
|
|
|
|
|
;
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Check that we have all parameters and that they match the card
|
|
|
|
|
description. */
|
2016-10-24 04:22:44 +02:00
|
|
|
|
if (!curve)
|
2015-07-25 05:09:23 +02:00
|
|
|
|
{
|
|
|
|
|
log_error (_("unsupported curve\n"));
|
|
|
|
|
err = gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2014-03-12 09:25:33 +01:00
|
|
|
|
if (!created_at)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("creation timestamp missing\n"));
|
|
|
|
|
err = gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2015-08-06 10:00:41 +02:00
|
|
|
|
if (flag_djb_tweak && keyno != 1)
|
2015-07-25 05:09:23 +02:00
|
|
|
|
algo = PUBKEY_ALGO_EDDSA;
|
|
|
|
|
else if (keyno == 1)
|
|
|
|
|
algo = PUBKEY_ALGO_ECDH;
|
|
|
|
|
else
|
|
|
|
|
algo = PUBKEY_ALGO_ECDSA;
|
|
|
|
|
|
2016-10-24 04:22:44 +02:00
|
|
|
|
oidstr = openpgp_curve_to_oid (curve, NULL);
|
2015-09-07 06:09:01 +02:00
|
|
|
|
err = openpgp_oid_from_str (oidstr, &oid);
|
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
oidbuf = gcry_mpi_get_opaque (oid, &n);
|
|
|
|
|
if (!oidbuf)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2016-10-18 15:46:37 +02:00
|
|
|
|
oid_len = (n+7)/8;
|
2015-09-07 06:09:01 +02:00
|
|
|
|
|
2015-07-25 05:09:23 +02:00
|
|
|
|
if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_ECC
|
2016-10-24 04:22:44 +02:00
|
|
|
|
|| app->app_local->keyattr[keyno].ecc.curve != curve
|
2016-09-16 08:20:32 +02:00
|
|
|
|
|| (flag_djb_tweak !=
|
|
|
|
|
(app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK)))
|
2015-07-25 05:09:23 +02:00
|
|
|
|
{
|
2015-09-07 06:49:47 +02:00
|
|
|
|
if (app->app_local->extcap.algo_attr_change)
|
|
|
|
|
{
|
2017-01-02 13:29:18 +01:00
|
|
|
|
unsigned char *keyattr;
|
2015-09-07 06:49:47 +02:00
|
|
|
|
|
2017-01-02 13:29:18 +01:00
|
|
|
|
if (!oid_len)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_INTERNAL);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
keyattr = xtrymalloc (oid_len);
|
|
|
|
|
if (!keyattr)
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error_from_syserror ();
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2015-09-07 06:49:47 +02:00
|
|
|
|
keyattr[0] = algo;
|
|
|
|
|
memcpy (keyattr+1, oidbuf+1, oid_len-1);
|
|
|
|
|
err = change_keyattr (app, keyno, keyattr, oid_len, pincb, pincb_arg);
|
2017-01-02 13:29:18 +01:00
|
|
|
|
xfree (keyattr);
|
2015-09-07 06:49:47 +02:00
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
log_error ("key attribute on card doesn't match\n");
|
|
|
|
|
err = gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2015-07-25 05:09:23 +02:00
|
|
|
|
}
|
2014-03-12 09:25:33 +01:00
|
|
|
|
|
|
|
|
|
if (opt.verbose)
|
|
|
|
|
log_info ("ECC private key size is %u bytes\n", (unsigned int)ecc_d_len);
|
|
|
|
|
|
|
|
|
|
/* We need to remove the cached public key. */
|
|
|
|
|
xfree (app->app_local->pk[keyno].key);
|
|
|
|
|
app->app_local->pk[keyno].key = NULL;
|
|
|
|
|
app->app_local->pk[keyno].keylen = 0;
|
|
|
|
|
app->app_local->pk[keyno].read_done = 0;
|
|
|
|
|
|
|
|
|
|
if (app->app_local->extcap.is_v2)
|
|
|
|
|
{
|
|
|
|
|
/* Build the private key template as described in section 4.3.3.7 of
|
|
|
|
|
the OpenPGP card specs version 2.0. */
|
2015-07-25 05:09:23 +02:00
|
|
|
|
unsigned char *template;
|
|
|
|
|
size_t template_len;
|
2014-03-12 09:25:33 +01:00
|
|
|
|
int exmode;
|
|
|
|
|
|
2014-04-09 02:30:19 +02:00
|
|
|
|
err = build_ecc_privkey_template (app, keyno,
|
|
|
|
|
ecc_d, ecc_d_len,
|
2016-09-16 08:20:32 +02:00
|
|
|
|
ecc_q, ecc_q_len,
|
2014-04-09 02:30:19 +02:00
|
|
|
|
&template, &template_len);
|
2014-03-12 09:25:33 +01:00
|
|
|
|
if (err)
|
|
|
|
|
goto leave;
|
|
|
|
|
|
|
|
|
|
/* Prepare for storing the key. */
|
|
|
|
|
err = verify_chv3 (app, pincb, pincb_arg);
|
|
|
|
|
if (err)
|
2015-07-25 05:09:23 +02:00
|
|
|
|
{
|
|
|
|
|
xfree (template);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2014-03-12 09:25:33 +01:00
|
|
|
|
|
|
|
|
|
/* Store the key. */
|
|
|
|
|
if (app->app_local->cardcap.ext_lc_le && template_len > 254)
|
|
|
|
|
exmode = 1; /* Use extended length w/o a limit. */
|
|
|
|
|
else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
|
|
|
|
|
exmode = -254;
|
|
|
|
|
else
|
|
|
|
|
exmode = 0;
|
|
|
|
|
err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
|
|
|
|
|
template, template_len);
|
2015-07-25 05:09:23 +02:00
|
|
|
|
xfree (template);
|
2014-03-12 09:25:33 +01:00
|
|
|
|
}
|
|
|
|
|
else
|
2015-07-25 05:09:23 +02:00
|
|
|
|
err = gpg_error (GPG_ERR_NOT_SUPPORTED);
|
2014-03-12 09:25:33 +01:00
|
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
2015-09-07 06:09:01 +02:00
|
|
|
|
err = store_fpr (app, keyno, created_at, fprbuf, algo, oidbuf, oid_len,
|
2016-10-24 04:22:44 +02:00
|
|
|
|
ecc_q, ecc_q_len, ecdh_params (curve), (size_t)4);
|
2005-05-20 22:39:36 +02:00
|
|
|
|
|
|
|
|
|
leave:
|
2016-10-21 14:37:04 +02:00
|
|
|
|
gcry_mpi_release (oid);
|
2005-05-20 22:39:36 +02:00
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-12 09:25:33 +01:00
|
|
|
|
/* Handle the WRITEKEY command for OpenPGP. This function expects a
|
|
|
|
|
canonical encoded S-expression with the secret key in KEYDATA and
|
|
|
|
|
its length (for assertions) in KEYDATALEN. KEYID needs to be the
|
|
|
|
|
usual keyid which for OpenPGP is the string "OPENPGP.n" with
|
|
|
|
|
n=1,2,3. Bit 0 of FLAGS indicates whether an existing key shall
|
|
|
|
|
get overwritten. PINCB and PINCB_ARG are the usual arguments for
|
|
|
|
|
the pinentry callback. */
|
|
|
|
|
static gpg_error_t
|
|
|
|
|
do_writekey (app_t app, ctrl_t ctrl,
|
|
|
|
|
const char *keyid, unsigned int flags,
|
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
|
|
|
|
void *pincb_arg,
|
|
|
|
|
const unsigned char *keydata, size_t keydatalen)
|
|
|
|
|
{
|
|
|
|
|
gpg_error_t err;
|
|
|
|
|
int force = (flags & 1);
|
|
|
|
|
int keyno;
|
|
|
|
|
const unsigned char *buf, *tok;
|
|
|
|
|
size_t buflen, toklen;
|
|
|
|
|
int depth;
|
|
|
|
|
|
|
|
|
|
(void)ctrl;
|
|
|
|
|
|
|
|
|
|
if (!strcmp (keyid, "OPENPGP.1"))
|
|
|
|
|
keyno = 0;
|
|
|
|
|
else if (!strcmp (keyid, "OPENPGP.2"))
|
|
|
|
|
keyno = 1;
|
|
|
|
|
else if (!strcmp (keyid, "OPENPGP.3"))
|
|
|
|
|
keyno = 2;
|
|
|
|
|
else
|
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
|
|
|
|
|
err = does_key_exist (app, keyno, 0, force);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Parse the S-expression
|
|
|
|
|
*/
|
|
|
|
|
buf = keydata;
|
|
|
|
|
buflen = keydatalen;
|
|
|
|
|
depth = 0;
|
|
|
|
|
if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
|
|
|
|
|
goto leave;
|
|
|
|
|
if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
|
|
|
|
|
goto leave;
|
|
|
|
|
if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
|
|
|
|
|
{
|
|
|
|
|
if (!tok)
|
|
|
|
|
;
|
|
|
|
|
else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
|
|
|
|
|
log_info ("protected-private-key passed to writekey\n");
|
|
|
|
|
else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
|
|
|
|
|
log_info ("shadowed-private-key passed to writekey\n");
|
|
|
|
|
err = gpg_error (GPG_ERR_BAD_SECKEY);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
|
|
|
|
|
goto leave;
|
|
|
|
|
if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
|
|
|
|
|
goto leave;
|
|
|
|
|
if (tok && toklen == 3 && memcmp ("rsa", tok, toklen) == 0)
|
2014-12-05 06:20:50 +01:00
|
|
|
|
err = rsa_writekey (app, pincb, pincb_arg, keyno, buf, buflen, depth);
|
2015-07-23 07:10:03 +02:00
|
|
|
|
else if (tok && toklen == 3 && memcmp ("ecc", tok, toklen) == 0)
|
2014-12-05 06:20:50 +01:00
|
|
|
|
err = ecc_writekey (app, pincb, pincb_arg, keyno, buf, buflen, depth);
|
2014-03-12 09:25:33 +01:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
leave:
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
/* Handle the GENKEY command. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
static gpg_error_t
|
2019-02-06 14:07:42 +01:00
|
|
|
|
do_genkey (app_t app, ctrl_t ctrl, const char *keynostr, const char *keytype,
|
|
|
|
|
unsigned int flags, time_t createtime,
|
2007-07-05 18:58:19 +02:00
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
|
|
|
|
void *pincb_arg)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
2016-10-18 13:40:09 +02:00
|
|
|
|
gpg_error_t err;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
char numbuf[30];
|
2005-05-20 22:39:36 +02:00
|
|
|
|
unsigned char *buffer = NULL;
|
2016-10-18 15:46:37 +02:00
|
|
|
|
const unsigned char *keydata;
|
|
|
|
|
size_t buflen, keydatalen;
|
2016-10-18 13:40:09 +02:00
|
|
|
|
u32 created_at;
|
2015-09-07 06:09:01 +02:00
|
|
|
|
int keyno = atoi (keynostr) - 1;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
int force = (flags & 1);
|
|
|
|
|
time_t start_at;
|
2016-10-18 15:46:37 +02:00
|
|
|
|
int exmode = 0;
|
|
|
|
|
int le_value = 256; /* Use legacy value. */
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2019-02-06 14:07:42 +01:00
|
|
|
|
(void)keytype; /* Ignored for OpenPGP cards. */
|
|
|
|
|
|
2015-09-07 06:09:01 +02:00
|
|
|
|
if (keyno < 0 || keyno > 2)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
|
2004-04-26 20:28:06 +02:00
|
|
|
|
/* We flush the cache to increase the traffic before a key
|
|
|
|
|
generation. This _might_ help a card to gather more entropy. */
|
|
|
|
|
flush_cache (app);
|
|
|
|
|
|
2005-02-22 18:29:07 +01:00
|
|
|
|
/* Obviously we need to remove the cached public key. */
|
2005-04-11 18:20:10 +02:00
|
|
|
|
xfree (app->app_local->pk[keyno].key);
|
|
|
|
|
app->app_local->pk[keyno].key = NULL;
|
|
|
|
|
app->app_local->pk[keyno].keylen = 0;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
app->app_local->pk[keyno].read_done = 0;
|
|
|
|
|
|
|
|
|
|
/* Check whether a key already exists. */
|
2016-10-18 13:40:09 +02:00
|
|
|
|
err = does_key_exist (app, keyno, 1, force);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2016-10-18 15:46:37 +02:00
|
|
|
|
if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
|
|
|
|
|
{
|
|
|
|
|
unsigned int keybits = app->app_local->keyattr[keyno].rsa.n_bits;
|
|
|
|
|
|
|
|
|
|
/* Because we send the key parameter back via status lines we need
|
|
|
|
|
to put a limit on the max. allowed keysize. 2048 bit will
|
|
|
|
|
already lead to a 527 byte long status line and thus a 4096 bit
|
|
|
|
|
key would exceed the Assuan line length limit. */
|
|
|
|
|
if (keybits > 4096)
|
|
|
|
|
return gpg_error (GPG_ERR_TOO_LARGE);
|
|
|
|
|
|
2016-11-25 08:12:26 +01:00
|
|
|
|
if (app->app_local->cardcap.ext_lc_le && keybits > RSA_SMALL_SIZE_KEY
|
|
|
|
|
&& app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
|
2016-10-18 15:46:37 +02:00
|
|
|
|
{
|
|
|
|
|
exmode = 1; /* Use extended length w/o a limit. */
|
2016-11-25 08:12:26 +01:00
|
|
|
|
le_value = determine_rsa_response (app, keyno);
|
2016-10-18 15:46:37 +02:00
|
|
|
|
/* No need to check le_value because it comes from a 16 bit
|
|
|
|
|
value and thus can't create an overflow on a 32 bit
|
|
|
|
|
system. */
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-05-08 17:07:45 +02:00
|
|
|
|
|
2007-07-05 18:58:19 +02:00
|
|
|
|
/* Prepare for key generation by verifying the Admin PIN. */
|
2016-10-18 13:40:09 +02:00
|
|
|
|
err = verify_chv3 (app, pincb, pincb_arg);
|
|
|
|
|
if (err)
|
2016-10-18 15:46:37 +02:00
|
|
|
|
return err;
|
2009-05-08 17:07:45 +02:00
|
|
|
|
|
|
|
|
|
|
2005-02-03 14:20:57 +01:00
|
|
|
|
log_info (_("please wait while key is being generated ...\n"));
|
2003-08-05 19:11:04 +02:00
|
|
|
|
start_at = time (NULL);
|
2019-02-06 14:07:42 +01:00
|
|
|
|
err = iso7816_generate_keypair (app->slot, exmode, 0x80, 0,
|
2016-10-18 13:40:09 +02:00
|
|
|
|
(keyno == 0? "\xB6" :
|
|
|
|
|
keyno == 1? "\xB8" : "\xA4"),
|
|
|
|
|
2, le_value, &buffer, &buflen);
|
|
|
|
|
if (err)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
2005-02-03 14:20:57 +01:00
|
|
|
|
log_error (_("generating key failed\n"));
|
2016-10-18 15:46:37 +02:00
|
|
|
|
return gpg_error (GPG_ERR_CARD);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
2016-01-18 11:20:15 +01:00
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
int nsecs = (int)(time (NULL) - start_at);
|
|
|
|
|
log_info (ngettext("key generation completed (%d second)\n",
|
|
|
|
|
"key generation completed (%d seconds)\n",
|
|
|
|
|
nsecs), nsecs);
|
|
|
|
|
}
|
2009-05-08 17:07:45 +02:00
|
|
|
|
|
2004-01-27 17:40:42 +01:00
|
|
|
|
keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (!keydata)
|
|
|
|
|
{
|
2016-10-18 13:40:09 +02:00
|
|
|
|
err = gpg_error (GPG_ERR_CARD);
|
2005-02-03 14:20:57 +01:00
|
|
|
|
log_error (_("response does not contain the public key data\n"));
|
2003-08-05 19:11:04 +02:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2016-10-18 13:40:09 +02:00
|
|
|
|
created_at = (u32)(createtime? createtime : gnupg_get_time ());
|
|
|
|
|
sprintf (numbuf, "%u", created_at);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
send_status_info (ctrl, "KEY-CREATED-AT",
|
|
|
|
|
numbuf, (size_t)strlen(numbuf), NULL, 0);
|
|
|
|
|
|
2016-10-20 09:25:47 +02:00
|
|
|
|
err = read_public_key (app, ctrl, created_at, keyno, buffer, buflen);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
leave:
|
|
|
|
|
xfree (buffer);
|
2016-10-18 13:40:09 +02:00
|
|
|
|
return err;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static unsigned long
|
2003-09-30 19:35:05 +02:00
|
|
|
|
convert_sig_counter_value (const unsigned char *value, size_t valuelen)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
|
|
|
|
unsigned long ul;
|
|
|
|
|
|
|
|
|
|
if (valuelen == 3 )
|
|
|
|
|
ul = (value[0] << 16) | (value[1] << 8) | value[2];
|
|
|
|
|
else
|
|
|
|
|
{
|
2005-02-03 14:20:57 +01:00
|
|
|
|
log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
|
2003-08-05 19:11:04 +02:00
|
|
|
|
ul = 0;
|
|
|
|
|
}
|
2003-09-30 19:35:05 +02:00
|
|
|
|
return ul;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static unsigned long
|
2004-10-14 15:22:03 +02:00
|
|
|
|
get_sig_counter (app_t app)
|
2003-09-30 19:35:05 +02:00
|
|
|
|
{
|
|
|
|
|
void *relptr;
|
|
|
|
|
unsigned char *value;
|
|
|
|
|
size_t valuelen;
|
|
|
|
|
unsigned long ul;
|
|
|
|
|
|
2005-02-24 18:36:11 +01:00
|
|
|
|
relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
|
2003-09-30 19:35:05 +02:00
|
|
|
|
if (!relptr)
|
|
|
|
|
return 0;
|
|
|
|
|
ul = convert_sig_counter_value (value, valuelen);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
xfree (relptr);
|
|
|
|
|
return ul;
|
|
|
|
|
}
|
|
|
|
|
|
2005-05-18 12:48:06 +02:00
|
|
|
|
static gpg_error_t
|
2004-10-14 15:22:03 +02:00
|
|
|
|
compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
|
|
|
|
const unsigned char *fpr;
|
|
|
|
|
unsigned char *buffer;
|
|
|
|
|
size_t buflen, n;
|
|
|
|
|
int rc, i;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2015-09-07 06:09:01 +02:00
|
|
|
|
assert (keyno >= 0 && keyno <= 2);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2009-06-17 11:45:50 +02:00
|
|
|
|
rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0, 0);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (rc)
|
|
|
|
|
{
|
2005-02-03 14:20:57 +01:00
|
|
|
|
log_error (_("error reading application data\n"));
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return gpg_error (GPG_ERR_GENERAL);
|
|
|
|
|
}
|
2004-01-27 17:40:42 +01:00
|
|
|
|
fpr = find_tlv (buffer, buflen, 0x00C5, &n);
|
2020-05-29 04:18:50 +02:00
|
|
|
|
if (!fpr || n < 60)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
|
|
|
|
xfree (buffer);
|
2005-02-03 14:20:57 +01:00
|
|
|
|
log_error (_("error reading fingerprint DO\n"));
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return gpg_error (GPG_ERR_GENERAL);
|
|
|
|
|
}
|
2015-09-07 06:09:01 +02:00
|
|
|
|
fpr += keyno*20;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
for (i=0; i < 20; i++)
|
|
|
|
|
if (sha1fpr[i] != fpr[i])
|
|
|
|
|
{
|
|
|
|
|
xfree (buffer);
|
2006-12-21 13:13:44 +01:00
|
|
|
|
log_info (_("fingerprint on card does not match requested one\n"));
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return gpg_error (GPG_ERR_WRONG_SECKEY);
|
|
|
|
|
}
|
|
|
|
|
xfree (buffer);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2009-06-08 11:11:27 +02:00
|
|
|
|
/* If a fingerprint has been specified check it against the one on the
|
|
|
|
|
card. This allows for a meaningful error message in case the key
|
|
|
|
|
on the card has been replaced but the shadow information known to
|
|
|
|
|
gpg has not been updated. If there is no fingerprint we assume
|
|
|
|
|
that this is okay. */
|
2005-05-18 12:48:06 +02:00
|
|
|
|
static gpg_error_t
|
2015-09-07 06:09:01 +02:00
|
|
|
|
check_against_given_fingerprint (app_t app, const char *fpr, int key)
|
2003-10-21 19:12:50 +02:00
|
|
|
|
{
|
|
|
|
|
unsigned char tmp[20];
|
|
|
|
|
const char *s;
|
|
|
|
|
int n;
|
|
|
|
|
|
|
|
|
|
for (s=fpr, n=0; hexdigitp (s); s++, n++)
|
|
|
|
|
;
|
|
|
|
|
if (n != 40)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
else if (!*s)
|
|
|
|
|
; /* okay */
|
|
|
|
|
else
|
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
|
|
|
|
|
for (s=fpr, n=0; n < 20; s += 2, n++)
|
|
|
|
|
tmp[n] = xtoi_2 (s);
|
2015-09-07 06:09:01 +02:00
|
|
|
|
return compare_fingerprint (app, key-1, tmp);
|
2003-10-21 19:12:50 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
/* Compute a digital signature on INDATA which is expected to be the
|
|
|
|
|
raw message digest. For this application the KEYIDSTR consists of
|
|
|
|
|
the serialnumber and the fingerprint delimited by a slash.
|
|
|
|
|
|
2006-02-06 17:13:20 +01:00
|
|
|
|
Note that this function may return the error code
|
2003-08-05 19:11:04 +02:00
|
|
|
|
GPG_ERR_WRONG_CARD to indicate that the card currently present does
|
|
|
|
|
not match the one required for the requested action (e.g. the
|
2011-02-04 12:57:53 +01:00
|
|
|
|
serial number does not match).
|
|
|
|
|
|
2006-10-11 19:52:15 +02:00
|
|
|
|
As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
|
|
|
|
|
operation to the auth command.
|
|
|
|
|
*/
|
2011-02-04 12:57:53 +01:00
|
|
|
|
static gpg_error_t
|
2004-10-14 15:22:03 +02:00
|
|
|
|
do_sign (app_t app, const char *keyidstr, int hashalgo,
|
2005-05-18 12:48:06 +02:00
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
2003-08-05 19:11:04 +02:00
|
|
|
|
void *pincb_arg,
|
|
|
|
|
const void *indata, size_t indatalen,
|
|
|
|
|
unsigned char **outdata, size_t *outdatalen )
|
|
|
|
|
{
|
|
|
|
|
static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
|
2008-09-23 17:42:11 +02:00
|
|
|
|
{ 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
|
|
|
|
|
0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
|
|
|
|
|
static unsigned char sha1_prefix[15] = /* (1.3.14.3.2.26) */
|
|
|
|
|
{ 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
|
|
|
|
|
0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
|
|
|
|
|
static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
|
|
|
|
|
{ 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
|
|
|
|
|
0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
|
|
|
|
|
0x1C };
|
|
|
|
|
static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
|
|
|
|
|
{ 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
|
|
|
|
|
0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
|
|
|
|
|
0x00, 0x04, 0x20 };
|
|
|
|
|
static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
|
|
|
|
|
{ 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
|
|
|
|
|
0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
|
|
|
|
|
0x00, 0x04, 0x30 };
|
|
|
|
|
static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
|
|
|
|
|
{ 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
|
|
|
|
|
0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
|
|
|
|
|
0x00, 0x04, 0x40 };
|
2003-08-05 19:11:04 +02:00
|
|
|
|
int rc;
|
2008-09-23 17:42:11 +02:00
|
|
|
|
unsigned char data[19+64];
|
|
|
|
|
size_t datalen;
|
|
|
|
|
unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
|
2003-08-05 19:11:04 +02:00
|
|
|
|
const char *s;
|
|
|
|
|
int n;
|
|
|
|
|
const char *fpr = NULL;
|
|
|
|
|
unsigned long sigcount;
|
2006-10-11 19:52:15 +02:00
|
|
|
|
int use_auth = 0;
|
2009-07-10 12:15:33 +02:00
|
|
|
|
int exmode, le_value;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
if (!keyidstr || !*keyidstr)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
2008-09-23 17:42:11 +02:00
|
|
|
|
|
|
|
|
|
/* Strip off known prefixes. */
|
|
|
|
|
#define X(a,b,c,d) \
|
|
|
|
|
if (hashalgo == GCRY_MD_ ## a \
|
|
|
|
|
&& (d) \
|
|
|
|
|
&& indatalen == sizeof b ## _prefix + (c) \
|
|
|
|
|
&& !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
|
|
|
|
|
{ \
|
|
|
|
|
indata = (const char*)indata + sizeof b ## _prefix; \
|
|
|
|
|
indatalen -= sizeof b ## _prefix; \
|
2011-02-04 12:57:53 +01:00
|
|
|
|
}
|
2008-09-23 17:42:11 +02:00
|
|
|
|
|
2005-02-25 17:14:55 +01:00
|
|
|
|
if (indatalen == 20)
|
2008-09-23 17:42:11 +02:00
|
|
|
|
; /* Assume a plain SHA-1 or RMD160 digest has been given. */
|
|
|
|
|
else X(SHA1, sha1, 20, 1)
|
|
|
|
|
else X(RMD160, rmd160, 20, 1)
|
|
|
|
|
else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
|
|
|
|
|
else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
|
|
|
|
|
else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
|
|
|
|
|
else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
|
2011-02-04 12:57:53 +01:00
|
|
|
|
else if ((indatalen == 28 || indatalen == 32
|
2008-09-23 17:42:11 +02:00
|
|
|
|
|| indatalen == 48 || indatalen ==64)
|
|
|
|
|
&& app->app_local->extcap.is_v2)
|
|
|
|
|
; /* Assume a plain SHA-3 digest has been given. */
|
2005-02-25 17:14:55 +01:00
|
|
|
|
else
|
2006-02-06 17:13:20 +01:00
|
|
|
|
{
|
|
|
|
|
log_error (_("card does not support digest algorithm %s\n"),
|
|
|
|
|
gcry_md_algo_name (hashalgo));
|
2008-09-23 17:42:11 +02:00
|
|
|
|
/* Or the supplied digest length does not match an algorithm. */
|
2006-02-06 17:13:20 +01:00
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
}
|
2008-09-23 17:42:11 +02:00
|
|
|
|
#undef X
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
/* Check whether an OpenPGP card of any version has been requested. */
|
2006-08-29 20:29:30 +02:00
|
|
|
|
if (!strcmp (keyidstr, "OPENPGP.1"))
|
2003-08-05 19:11:04 +02:00
|
|
|
|
;
|
2006-10-11 19:52:15 +02:00
|
|
|
|
else if (!strcmp (keyidstr, "OPENPGP.3"))
|
|
|
|
|
use_auth = 1;
|
2006-08-29 20:29:30 +02:00
|
|
|
|
else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
else
|
2006-08-29 20:29:30 +02:00
|
|
|
|
{
|
|
|
|
|
for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
;
|
2006-08-29 20:29:30 +02:00
|
|
|
|
if (n != 32)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
2006-08-29 20:29:30 +02:00
|
|
|
|
else if (!*s)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
; /* no fingerprint given: we allow this for now. */
|
2006-08-29 20:29:30 +02:00
|
|
|
|
else if (*s == '/')
|
2016-11-04 05:45:57 +01:00
|
|
|
|
fpr = s + 1;
|
2006-08-29 20:29:30 +02:00
|
|
|
|
else
|
2016-11-04 05:45:57 +01:00
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2006-08-29 20:29:30 +02:00
|
|
|
|
for (s=keyidstr, n=0; n < 16; s += 2, n++)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
tmp_sn[n] = xtoi_2 (s);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2006-08-29 20:29:30 +02:00
|
|
|
|
if (app->serialnolen != 16)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
return gpg_error (GPG_ERR_INV_CARD);
|
2006-08-29 20:29:30 +02:00
|
|
|
|
if (memcmp (app->serialno, tmp_sn, 16))
|
2016-11-04 05:45:57 +01:00
|
|
|
|
return gpg_error (GPG_ERR_WRONG_CARD);
|
2006-08-29 20:29:30 +02:00
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
/* If a fingerprint has been specified check it against the one on
|
|
|
|
|
the card. This is allows for a meaningful error message in case
|
|
|
|
|
the key on the card has been replaced but the shadow information
|
|
|
|
|
known to gpg was not updated. If there is no fingerprint, gpg
|
|
|
|
|
will detect a bogus signature anyway due to the
|
|
|
|
|
verify-after-signing feature. */
|
2003-10-21 19:12:50 +02:00
|
|
|
|
rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2008-09-23 17:42:11 +02:00
|
|
|
|
/* Concatenate prefix and digest. */
|
|
|
|
|
#define X(a,b,d) \
|
|
|
|
|
if (hashalgo == GCRY_MD_ ## a && (d) ) \
|
|
|
|
|
{ \
|
|
|
|
|
datalen = sizeof b ## _prefix + indatalen; \
|
|
|
|
|
assert (datalen <= sizeof data); \
|
|
|
|
|
memcpy (data, b ## _prefix, sizeof b ## _prefix); \
|
|
|
|
|
memcpy (data + sizeof b ## _prefix, indata, indatalen); \
|
2011-02-04 12:57:53 +01:00
|
|
|
|
}
|
2008-09-23 17:42:11 +02:00
|
|
|
|
|
2013-03-09 01:36:21 +01:00
|
|
|
|
if (use_auth
|
|
|
|
|
|| app->app_local->keyattr[use_auth? 2: 0].key_type == KEY_TYPE_RSA)
|
|
|
|
|
{
|
|
|
|
|
X(SHA1, sha1, 1)
|
|
|
|
|
else X(RMD160, rmd160, 1)
|
|
|
|
|
else X(SHA224, sha224, app->app_local->extcap.is_v2)
|
|
|
|
|
else X(SHA256, sha256, app->app_local->extcap.is_v2)
|
|
|
|
|
else X(SHA384, sha384, app->app_local->extcap.is_v2)
|
|
|
|
|
else X(SHA512, sha512, app->app_local->extcap.is_v2)
|
|
|
|
|
else
|
|
|
|
|
return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
|
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
else
|
2013-03-09 01:36:21 +01:00
|
|
|
|
{
|
|
|
|
|
datalen = indatalen;
|
|
|
|
|
memcpy (data, indata, indatalen);
|
|
|
|
|
}
|
2008-09-23 17:42:11 +02:00
|
|
|
|
#undef X
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2008-09-23 17:42:11 +02:00
|
|
|
|
/* Redirect to the AUTH command if asked to. */
|
2006-10-11 19:52:15 +02:00
|
|
|
|
if (use_auth)
|
|
|
|
|
{
|
|
|
|
|
return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
|
2008-09-23 17:42:11 +02:00
|
|
|
|
data, datalen,
|
2006-10-11 19:52:15 +02:00
|
|
|
|
outdata, outdatalen);
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-23 17:42:11 +02:00
|
|
|
|
/* Show the number of signature done using this key. */
|
2003-08-05 19:11:04 +02:00
|
|
|
|
sigcount = get_sig_counter (app);
|
2005-02-03 14:20:57 +01:00
|
|
|
|
log_info (_("signatures created so far: %lu\n"), sigcount);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2008-09-23 17:42:11 +02:00
|
|
|
|
/* Check CHV if needed. */
|
2018-10-15 04:10:15 +02:00
|
|
|
|
if (!app->did_chv1 || app->force_chv1)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
|
|
|
|
char *pinvalue;
|
2018-01-22 11:46:14 +01:00
|
|
|
|
int pinlen;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2018-01-22 11:46:14 +01:00
|
|
|
|
rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue, &pinlen);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (rc)
|
2006-12-21 13:13:44 +01:00
|
|
|
|
return rc;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
app->did_chv1 = 1;
|
2006-12-21 13:13:44 +01:00
|
|
|
|
|
2008-09-23 17:42:11 +02:00
|
|
|
|
/* For cards with versions < 2 we want to keep CHV1 and CHV2 in
|
|
|
|
|
sync, thus we verify CHV2 here using the given PIN. Cards
|
|
|
|
|
with version2 to not have the need for a separate CHV2 and
|
|
|
|
|
internally use just one. Obviously we can't do that if the
|
scd: Rename 'keypad' to 'pinpad'.
* NEWS: Mention scd changes.
* agent/divert-scd.c (getpin_cb): Change message.
* agent/call-scd.c (inq_needpin): Change the protocol to
POPUPPINPADPROMPT and DISMISSPINPADPROMPT.
* scd/command.c (pin_cb): Likewise.
* scd/apdu.c (struct reader_table_s): Rename member functions.
(check_pcsc_pinpad, pcsc_pinpad_verify, pcsc_pinpad_modify,
check_ccid_pinpad, ccid_pinpad_operation, apdu_check_pinpad
apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/apdu.h (SW_HOST_NO_PINPAD, apdu_check_pinpad)
(apdu_pinpad_verify, apdu_pinpad_modify): Rename.
* scd/iso7816.h (iso7816_check_pinpad): Rename.
* scd/iso7816.c (map_sw): Use SW_HOST_NO_PINPAD.
(iso7816_check_pinpad): Rename.
(iso7816_verify_kp, iso7816_change_reference_data_kp): Follow
the change.
* scd/ccid-driver.h (CCID_DRIVER_ERR_NO_PINPAD): Rename.
* scd/ccid-driver.c (ccid_transceive_secure): Use it.
* scd/app-dinsig.c (verify_pin): Follow the change.
* scd/app-nks.c (verify_pin): Follow the change.
* scd/app-openpgp.c (check_pinpad_request): Rename.
(parse_login_data, verify_a_chv, verify_chv3, do_change_pin): Follow
the change.
* scd/scdaemon.c (oDisablePinpad, oEnablePinpadVarlen): Rename.
* scd/scdaemon.h (opt): Rename to disable_pinpad,
enable_pinpad_varlen.
* tools/gpgconf-comp.c (gc_options_scdaemon): Rename to
disable-pinpad.
2013-02-07 02:07:51 +01:00
|
|
|
|
pinpad has been used. */
|
2008-09-23 17:42:11 +02:00
|
|
|
|
if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
|
2003-09-30 19:35:05 +02:00
|
|
|
|
{
|
2018-01-22 11:46:14 +01:00
|
|
|
|
rc = iso7816_verify (app->slot, 0x82, pinvalue, pinlen);
|
2003-09-30 19:35:05 +02:00
|
|
|
|
if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
|
|
|
|
|
rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
|
|
|
|
|
if (rc)
|
|
|
|
|
{
|
2004-09-30 15:24:33 +02:00
|
|
|
|
log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
|
2003-09-30 19:35:05 +02:00
|
|
|
|
xfree (pinvalue);
|
2004-04-26 20:28:06 +02:00
|
|
|
|
flush_cache_after_error (app);
|
2003-09-30 19:35:05 +02:00
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
app->did_chv2 = 1;
|
|
|
|
|
}
|
|
|
|
|
xfree (pinvalue);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
2009-07-10 12:15:33 +02:00
|
|
|
|
|
2016-11-25 08:12:26 +01:00
|
|
|
|
if (app->app_local->cardcap.ext_lc_le
|
|
|
|
|
&& app->app_local->keyattr[0].key_type == KEY_TYPE_RSA
|
|
|
|
|
&& app->app_local->keyattr[0].rsa.n_bits > RSA_SMALL_SIZE_OP)
|
2009-07-10 12:15:33 +02:00
|
|
|
|
{
|
|
|
|
|
exmode = 1; /* Use extended length. */
|
2016-11-25 08:12:26 +01:00
|
|
|
|
le_value = app->app_local->keyattr[0].rsa.n_bits / 8;
|
2009-07-10 12:15:33 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
exmode = 0;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
le_value = 0;
|
2009-07-10 12:15:33 +02:00
|
|
|
|
}
|
|
|
|
|
rc = iso7816_compute_ds (app->slot, exmode, data, datalen, le_value,
|
|
|
|
|
outdata, outdatalen);
|
2018-10-15 04:10:15 +02:00
|
|
|
|
if (!rc && app->force_chv1)
|
|
|
|
|
app->did_chv1 = 0;
|
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Compute a digital signature using the INTERNAL AUTHENTICATE command
|
|
|
|
|
on INDATA which is expected to be the raw message digest. For this
|
|
|
|
|
application the KEYIDSTR consists of the serialnumber and the
|
2005-02-25 17:14:55 +01:00
|
|
|
|
fingerprint delimited by a slash. Optionally the id OPENPGP.3 may
|
|
|
|
|
be given.
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2005-09-09 13:18:08 +02:00
|
|
|
|
Note that this function may return the error code
|
2003-08-05 19:11:04 +02:00
|
|
|
|
GPG_ERR_WRONG_CARD to indicate that the card currently present does
|
|
|
|
|
not match the one required for the requested action (e.g. the
|
|
|
|
|
serial number does not match). */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
static gpg_error_t
|
2004-10-14 15:22:03 +02:00
|
|
|
|
do_auth (app_t app, const char *keyidstr,
|
2005-05-18 12:48:06 +02:00
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
2003-08-05 19:11:04 +02:00
|
|
|
|
void *pincb_arg,
|
|
|
|
|
const void *indata, size_t indatalen,
|
|
|
|
|
unsigned char **outdata, size_t *outdatalen )
|
|
|
|
|
{
|
|
|
|
|
int rc;
|
2008-09-23 17:42:11 +02:00
|
|
|
|
unsigned char tmp_sn[20]; /* Actually 16 but we use it also for the fpr. */
|
2003-08-05 19:11:04 +02:00
|
|
|
|
const char *s;
|
|
|
|
|
int n;
|
|
|
|
|
const char *fpr = NULL;
|
|
|
|
|
|
|
|
|
|
if (!keyidstr || !*keyidstr)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
2014-04-09 02:30:19 +02:00
|
|
|
|
if (app->app_local->keyattr[2].key_type == KEY_TYPE_RSA
|
|
|
|
|
&& indatalen > 101) /* For a 2048 bit key. */
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
|
2015-07-25 05:09:23 +02:00
|
|
|
|
if (app->app_local->keyattr[2].key_type == KEY_TYPE_ECC)
|
2014-04-09 02:30:19 +02:00
|
|
|
|
{
|
2016-09-16 08:20:32 +02:00
|
|
|
|
if (!(app->app_local->keyattr[2].ecc.flags & ECC_FLAG_DJB_TWEAK)
|
2015-07-25 05:09:23 +02:00
|
|
|
|
&& (indatalen == 51 || indatalen == 67 || indatalen == 83))
|
|
|
|
|
{
|
|
|
|
|
const char *p = (const char *)indata + 19;
|
|
|
|
|
indata = p;
|
|
|
|
|
indatalen -= 19;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
const char *p = (const char *)indata + 15;
|
|
|
|
|
indata = p;
|
|
|
|
|
indatalen -= 15;
|
|
|
|
|
}
|
2014-04-09 02:30:19 +02:00
|
|
|
|
}
|
2013-03-09 01:36:21 +01:00
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
/* Check whether an OpenPGP card of any version has been requested. */
|
2005-02-25 17:14:55 +01:00
|
|
|
|
if (!strcmp (keyidstr, "OPENPGP.3"))
|
2003-08-05 19:11:04 +02:00
|
|
|
|
;
|
2005-02-25 17:14:55 +01:00
|
|
|
|
else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
else
|
2005-02-25 17:14:55 +01:00
|
|
|
|
{
|
|
|
|
|
for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
|
|
|
|
|
;
|
|
|
|
|
if (n != 32)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
else if (!*s)
|
|
|
|
|
; /* no fingerprint given: we allow this for now. */
|
|
|
|
|
else if (*s == '/')
|
2011-02-04 12:57:53 +01:00
|
|
|
|
fpr = s + 1;
|
2005-02-25 17:14:55 +01:00
|
|
|
|
else
|
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2005-02-25 17:14:55 +01:00
|
|
|
|
for (s=keyidstr, n=0; n < 16; s += 2, n++)
|
|
|
|
|
tmp_sn[n] = xtoi_2 (s);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2005-02-25 17:14:55 +01:00
|
|
|
|
if (app->serialnolen != 16)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_CARD);
|
|
|
|
|
if (memcmp (app->serialno, tmp_sn, 16))
|
|
|
|
|
return gpg_error (GPG_ERR_WRONG_CARD);
|
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
/* If a fingerprint has been specified check it against the one on
|
|
|
|
|
the card. This is allows for a meaningful error message in case
|
|
|
|
|
the key on the card has been replaced but the shadow information
|
|
|
|
|
known to gpg was not updated. If there is no fingerprint, gpg
|
|
|
|
|
will detect a bogus signature anyway due to the
|
|
|
|
|
verify-after-signing feature. */
|
2003-10-21 19:12:50 +02:00
|
|
|
|
rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2003-09-30 19:35:05 +02:00
|
|
|
|
rc = verify_chv2 (app, pincb, pincb_arg);
|
|
|
|
|
if (!rc)
|
2009-07-10 12:15:33 +02:00
|
|
|
|
{
|
|
|
|
|
int exmode, le_value;
|
|
|
|
|
|
2016-11-25 08:12:26 +01:00
|
|
|
|
if (app->app_local->cardcap.ext_lc_le
|
|
|
|
|
&& app->app_local->keyattr[2].key_type == KEY_TYPE_RSA
|
|
|
|
|
&& app->app_local->keyattr[2].rsa.n_bits > RSA_SMALL_SIZE_OP)
|
2009-07-10 12:15:33 +02:00
|
|
|
|
{
|
|
|
|
|
exmode = 1; /* Use extended length. */
|
2016-11-25 08:12:26 +01:00
|
|
|
|
le_value = app->app_local->keyattr[2].rsa.n_bits / 8;
|
2009-07-10 12:15:33 +02:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
exmode = 0;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
le_value = 0;
|
2009-07-10 12:15:33 +02:00
|
|
|
|
}
|
|
|
|
|
rc = iso7816_internal_authenticate (app->slot, exmode,
|
|
|
|
|
indata, indatalen, le_value,
|
|
|
|
|
outdata, outdatalen);
|
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2011-02-04 12:57:53 +01:00
|
|
|
|
static gpg_error_t
|
2004-10-14 15:22:03 +02:00
|
|
|
|
do_decipher (app_t app, const char *keyidstr,
|
2005-05-18 12:48:06 +02:00
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
2003-08-05 19:11:04 +02:00
|
|
|
|
void *pincb_arg,
|
|
|
|
|
const void *indata, size_t indatalen,
|
2013-08-26 17:29:54 +02:00
|
|
|
|
unsigned char **outdata, size_t *outdatalen,
|
|
|
|
|
unsigned int *r_info)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
|
|
|
|
int rc;
|
|
|
|
|
unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
|
|
|
|
|
const char *s;
|
|
|
|
|
int n;
|
|
|
|
|
const char *fpr = NULL;
|
2009-09-03 12:57:23 +02:00
|
|
|
|
int exmode, le_value;
|
2014-12-22 01:27:00 +01:00
|
|
|
|
unsigned char *fixbuf = NULL;
|
|
|
|
|
int padind = 0;
|
2015-06-05 07:02:40 +02:00
|
|
|
|
int fixuplen = 0;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
if (!keyidstr || !*keyidstr || !indatalen)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
|
|
|
|
|
/* Check whether an OpenPGP card of any version has been requested. */
|
2006-08-29 20:29:30 +02:00
|
|
|
|
if (!strcmp (keyidstr, "OPENPGP.2"))
|
2003-08-05 19:11:04 +02:00
|
|
|
|
;
|
2006-08-29 20:29:30 +02:00
|
|
|
|
else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
else
|
2006-08-29 20:29:30 +02:00
|
|
|
|
{
|
|
|
|
|
for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
;
|
2006-08-29 20:29:30 +02:00
|
|
|
|
if (n != 32)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
2006-08-29 20:29:30 +02:00
|
|
|
|
else if (!*s)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
; /* no fingerprint given: we allow this for now. */
|
2006-08-29 20:29:30 +02:00
|
|
|
|
else if (*s == '/')
|
2016-11-04 05:45:57 +01:00
|
|
|
|
fpr = s + 1;
|
2006-08-29 20:29:30 +02:00
|
|
|
|
else
|
2016-11-04 05:45:57 +01:00
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2006-08-29 20:29:30 +02:00
|
|
|
|
for (s=keyidstr, n=0; n < 16; s += 2, n++)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
tmp_sn[n] = xtoi_2 (s);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2006-08-29 20:29:30 +02:00
|
|
|
|
if (app->serialnolen != 16)
|
2016-11-04 05:45:57 +01:00
|
|
|
|
return gpg_error (GPG_ERR_INV_CARD);
|
2006-08-29 20:29:30 +02:00
|
|
|
|
if (memcmp (app->serialno, tmp_sn, 16))
|
2016-11-04 05:45:57 +01:00
|
|
|
|
return gpg_error (GPG_ERR_WRONG_CARD);
|
2006-08-29 20:29:30 +02:00
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
/* If a fingerprint has been specified check it against the one on
|
|
|
|
|
the card. This is allows for a meaningful error message in case
|
|
|
|
|
the key on the card has been replaced but the shadow information
|
|
|
|
|
known to gpg was not updated. If there is no fingerprint, the
|
2009-05-08 17:07:45 +02:00
|
|
|
|
decryption won't produce the right plaintext anyway. */
|
2003-10-21 19:12:50 +02:00
|
|
|
|
rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
|
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2003-09-30 19:35:05 +02:00
|
|
|
|
rc = verify_chv2 (app, pincb, pincb_arg);
|
2014-12-22 01:27:00 +01:00
|
|
|
|
if (rc)
|
|
|
|
|
return rc;
|
|
|
|
|
|
2015-12-03 13:46:03 +01:00
|
|
|
|
if ((indatalen == 16 + 1 || indatalen == 32 + 1)
|
2015-12-03 00:48:51 +01:00
|
|
|
|
&& ((char *)indata)[0] == 0x02)
|
2015-12-03 13:46:03 +01:00
|
|
|
|
{
|
|
|
|
|
/* PSO:DECIPHER with symmetric key. */
|
|
|
|
|
padind = -1;
|
|
|
|
|
}
|
2015-07-02 05:14:40 +02:00
|
|
|
|
else if (app->app_local->keyattr[1].key_type == KEY_TYPE_RSA)
|
2007-12-10 16:19:34 +01:00
|
|
|
|
{
|
|
|
|
|
/* We might encounter a couple of leading zeroes in the
|
2011-08-08 10:44:03 +02:00
|
|
|
|
cryptogram. Due to internal use of MPIs these leading zeroes
|
|
|
|
|
are stripped. However the OpenPGP card expects exactly 128
|
|
|
|
|
bytes for the cryptogram (for a 1k key). Thus we need to fix
|
|
|
|
|
it up. We do this for up to 16 leading zero bytes; a
|
|
|
|
|
cryptogram with more than this is with a very high
|
|
|
|
|
probability anyway broken. If a signed conversion was used
|
|
|
|
|
we may also encounter one leading zero followed by the correct
|
|
|
|
|
length. We fix that as well. */
|
2007-12-10 16:19:34 +01:00
|
|
|
|
if (indatalen >= (128-16) && indatalen < 128) /* 1024 bit key. */
|
|
|
|
|
fixuplen = 128 - indatalen;
|
|
|
|
|
else if (indatalen >= (192-16) && indatalen < 192) /* 1536 bit key. */
|
|
|
|
|
fixuplen = 192 - indatalen;
|
2009-05-08 17:07:45 +02:00
|
|
|
|
else if (indatalen >= (256-16) && indatalen < 256) /* 2048 bit key. */
|
|
|
|
|
fixuplen = 256 - indatalen;
|
|
|
|
|
else if (indatalen >= (384-16) && indatalen < 384) /* 3072 bit key. */
|
|
|
|
|
fixuplen = 384 - indatalen;
|
2011-06-16 14:27:33 +02:00
|
|
|
|
else if (indatalen >= (512-16) && indatalen < 512) /* 4096 bit key. */
|
|
|
|
|
fixuplen = 512 - indatalen;
|
2011-08-08 10:44:03 +02:00
|
|
|
|
else if (!*(const char *)indata && (indatalen == 129
|
|
|
|
|
|| indatalen == 193
|
|
|
|
|
|| indatalen == 257
|
|
|
|
|
|| indatalen == 385
|
|
|
|
|
|| indatalen == 513))
|
|
|
|
|
fixuplen = -1;
|
2007-12-10 16:19:34 +01:00
|
|
|
|
else
|
|
|
|
|
fixuplen = 0;
|
2009-05-08 17:07:45 +02:00
|
|
|
|
|
2011-08-08 10:44:03 +02:00
|
|
|
|
if (fixuplen > 0)
|
2007-12-10 16:19:34 +01:00
|
|
|
|
{
|
|
|
|
|
/* While we have to prepend stuff anyway, we can also
|
|
|
|
|
include the padding byte here so that iso1816_decipher
|
2009-05-08 17:07:45 +02:00
|
|
|
|
does not need to do another data mangling. */
|
2007-12-10 16:19:34 +01:00
|
|
|
|
fixuplen++;
|
2009-05-08 17:07:45 +02:00
|
|
|
|
|
2007-12-10 16:19:34 +01:00
|
|
|
|
fixbuf = xtrymalloc (fixuplen + indatalen);
|
|
|
|
|
if (!fixbuf)
|
2009-05-08 17:07:45 +02:00
|
|
|
|
return gpg_error_from_syserror ();
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2009-05-08 17:07:45 +02:00
|
|
|
|
memset (fixbuf, 0, fixuplen);
|
|
|
|
|
memcpy (fixbuf+fixuplen, indata, indatalen);
|
|
|
|
|
indata = fixbuf;
|
|
|
|
|
indatalen = fixuplen + indatalen;
|
|
|
|
|
padind = -1; /* Already padded. */
|
2007-12-10 16:19:34 +01:00
|
|
|
|
}
|
2011-08-08 10:44:03 +02:00
|
|
|
|
else if (fixuplen < 0)
|
|
|
|
|
{
|
|
|
|
|
/* We use the extra leading zero as the padding byte. */
|
|
|
|
|
padind = -1;
|
|
|
|
|
}
|
2014-12-22 01:27:00 +01:00
|
|
|
|
}
|
|
|
|
|
else if (app->app_local->keyattr[1].key_type == KEY_TYPE_ECC)
|
2015-06-05 07:02:40 +02:00
|
|
|
|
{
|
2015-12-04 06:02:48 +01:00
|
|
|
|
int old_format_len = 0;
|
|
|
|
|
|
2016-09-16 08:20:32 +02:00
|
|
|
|
if ((app->app_local->keyattr[1].ecc.flags & ECC_FLAG_DJB_TWEAK))
|
2015-12-04 06:02:48 +01:00
|
|
|
|
{
|
2015-12-04 06:37:05 +01:00
|
|
|
|
if (indatalen > 32 && (indatalen % 2))
|
2015-12-04 06:02:48 +01:00
|
|
|
|
{ /*
|
|
|
|
|
* Skip the prefix. It may be 0x40 (in new format), or MPI
|
|
|
|
|
* head of 0x00 (in old format).
|
|
|
|
|
*/
|
|
|
|
|
indata = (const char *)indata + 1;
|
|
|
|
|
indatalen--;
|
|
|
|
|
}
|
|
|
|
|
else if (indatalen < 32)
|
|
|
|
|
{ /*
|
|
|
|
|
* Old format trancated by MPI handling.
|
|
|
|
|
*/
|
|
|
|
|
old_format_len = indatalen;
|
|
|
|
|
indatalen = 32;
|
|
|
|
|
}
|
2015-12-03 00:48:51 +01:00
|
|
|
|
}
|
|
|
|
|
|
2017-08-29 07:35:47 +02:00
|
|
|
|
n = 0;
|
|
|
|
|
if (indatalen < 128)
|
|
|
|
|
fixuplen = 7;
|
|
|
|
|
else
|
|
|
|
|
fixuplen = 10;
|
|
|
|
|
|
2015-06-05 07:02:40 +02:00
|
|
|
|
fixbuf = xtrymalloc (fixuplen + indatalen);
|
|
|
|
|
if (!fixbuf)
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
|
|
|
|
|
/* Build 'Cipher DO' */
|
2017-08-29 07:35:47 +02:00
|
|
|
|
fixbuf[n++] = '\xa6';
|
|
|
|
|
if (indatalen < 128)
|
|
|
|
|
fixbuf[n++] = (char)(indatalen+5);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
fixbuf[n++] = 0x81;
|
|
|
|
|
fixbuf[n++] = (char)(indatalen+7);
|
|
|
|
|
}
|
|
|
|
|
fixbuf[n++] = '\x7f';
|
|
|
|
|
fixbuf[n++] = '\x49';
|
|
|
|
|
if (indatalen < 128)
|
|
|
|
|
fixbuf[n++] = (char)(indatalen+2);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
fixbuf[n++] = 0x81;
|
|
|
|
|
fixbuf[n++] = (char)(indatalen+3);
|
|
|
|
|
}
|
|
|
|
|
fixbuf[n++] = '\x86';
|
|
|
|
|
if (indatalen < 128)
|
|
|
|
|
fixbuf[n++] = (char)indatalen;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
fixbuf[n++] = 0x81;
|
|
|
|
|
fixbuf[n++] = (char)indatalen;
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-04 06:02:48 +01:00
|
|
|
|
if (old_format_len)
|
|
|
|
|
{
|
|
|
|
|
memset (fixbuf+fixuplen, 0, 32 - old_format_len);
|
|
|
|
|
memcpy (fixbuf+fixuplen + 32 - old_format_len,
|
|
|
|
|
indata, old_format_len);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
memcpy (fixbuf+fixuplen, indata, indatalen);
|
|
|
|
|
}
|
2015-06-05 07:02:40 +02:00
|
|
|
|
indata = fixbuf;
|
|
|
|
|
indatalen = fixuplen + indatalen;
|
|
|
|
|
|
|
|
|
|
padind = -1;
|
|
|
|
|
}
|
2014-12-22 01:27:00 +01:00
|
|
|
|
else
|
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
2009-09-03 12:57:23 +02:00
|
|
|
|
|
2016-11-25 08:12:26 +01:00
|
|
|
|
if (app->app_local->cardcap.ext_lc_le
|
|
|
|
|
&& (indatalen > 254
|
|
|
|
|
|| (app->app_local->keyattr[1].key_type == KEY_TYPE_RSA
|
|
|
|
|
&& app->app_local->keyattr[1].rsa.n_bits > RSA_SMALL_SIZE_OP)))
|
2014-12-22 01:27:00 +01:00
|
|
|
|
{
|
|
|
|
|
exmode = 1; /* Extended length w/o a limit. */
|
2016-11-25 08:12:26 +01:00
|
|
|
|
le_value = app->app_local->keyattr[1].rsa.n_bits / 8;
|
2014-12-22 01:27:00 +01:00
|
|
|
|
}
|
|
|
|
|
else if (app->app_local->cardcap.cmd_chaining && indatalen > 254)
|
|
|
|
|
{
|
|
|
|
|
exmode = -254; /* Command chaining with max. 254 bytes. */
|
|
|
|
|
le_value = 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
exmode = le_value = 0;
|
2009-05-08 17:07:45 +02:00
|
|
|
|
|
2014-12-22 01:27:00 +01:00
|
|
|
|
rc = iso7816_decipher (app->slot, exmode,
|
|
|
|
|
indata, indatalen, le_value, padind,
|
|
|
|
|
outdata, outdatalen);
|
|
|
|
|
xfree (fixbuf);
|
2016-10-27 04:56:18 +02:00
|
|
|
|
if (app->app_local->keyattr[1].key_type == KEY_TYPE_ECC)
|
|
|
|
|
{
|
|
|
|
|
unsigned char prefix = 0;
|
|
|
|
|
|
|
|
|
|
if (app->app_local->keyattr[1].ecc.flags & ECC_FLAG_DJB_TWEAK)
|
|
|
|
|
prefix = 0x40;
|
|
|
|
|
else if ((*outdatalen % 2) == 0) /* No 0x04 -> x-coordinate only */
|
|
|
|
|
prefix = 0x41;
|
|
|
|
|
|
|
|
|
|
if (prefix)
|
|
|
|
|
{ /* Add the prefix */
|
|
|
|
|
fixbuf = xtrymalloc (*outdatalen + 1);
|
|
|
|
|
if (!fixbuf)
|
|
|
|
|
{
|
|
|
|
|
xfree (*outdata);
|
|
|
|
|
return gpg_error_from_syserror ();
|
|
|
|
|
}
|
|
|
|
|
fixbuf[0] = prefix;
|
|
|
|
|
memcpy (fixbuf+1, *outdata, *outdatalen);
|
2015-12-04 06:02:48 +01:00
|
|
|
|
xfree (*outdata);
|
2016-10-27 04:56:18 +02:00
|
|
|
|
*outdata = fixbuf;
|
|
|
|
|
*outdatalen = *outdatalen + 1;
|
2015-12-03 00:48:51 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
2012-11-06 12:02:25 +01:00
|
|
|
|
|
2014-12-22 01:27:00 +01:00
|
|
|
|
if (gpg_err_code (rc) == GPG_ERR_CARD /* actual SW is 0x640a */
|
|
|
|
|
&& app->app_local->manufacturer == 5
|
|
|
|
|
&& app->card_version == 0x0200)
|
|
|
|
|
log_info ("NOTE: Cards with manufacturer id 5 and s/n <= 346 (0x15a)"
|
|
|
|
|
" do not work with encryption keys > 2048 bits\n");
|
2013-08-26 17:29:54 +02:00
|
|
|
|
|
2014-12-22 01:27:00 +01:00
|
|
|
|
*r_info |= APP_DECIPHER_INFO_NOPAD;
|
2009-05-08 17:07:45 +02:00
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return rc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-10-21 19:12:50 +02:00
|
|
|
|
/* Perform a simple verify operation for CHV1 and CHV2, so that
|
|
|
|
|
further operations won't ask for CHV2 and it is possible to do a
|
|
|
|
|
cheap check on the PIN: If there is something wrong with the PIN
|
|
|
|
|
entry system, only the regular CHV will get blocked and not the
|
|
|
|
|
dangerous CHV3. KEYIDSTR is the usual card's serial number; an
|
2005-04-11 18:20:10 +02:00
|
|
|
|
optional fingerprint part will be ignored.
|
|
|
|
|
|
|
|
|
|
There is a special mode if the keyidstr is "<serialno>[CHV3]" with
|
|
|
|
|
the "[CHV3]" being a literal string: The Admin Pin is checked if
|
|
|
|
|
and only if the retry counter is still at 3. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
static gpg_error_t
|
2004-10-14 15:22:03 +02:00
|
|
|
|
do_check_pin (app_t app, const char *keyidstr,
|
2005-05-18 12:48:06 +02:00
|
|
|
|
gpg_error_t (*pincb)(void*, const char *, char **),
|
2003-10-21 19:12:50 +02:00
|
|
|
|
void *pincb_arg)
|
|
|
|
|
{
|
2011-02-04 12:57:53 +01:00
|
|
|
|
unsigned char tmp_sn[20];
|
2003-10-21 19:12:50 +02:00
|
|
|
|
const char *s;
|
|
|
|
|
int n;
|
2005-04-11 18:20:10 +02:00
|
|
|
|
int admin_pin = 0;
|
2003-10-21 19:12:50 +02:00
|
|
|
|
|
|
|
|
|
if (!keyidstr || !*keyidstr)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_VALUE);
|
|
|
|
|
|
|
|
|
|
/* Check whether an OpenPGP card of any version has been requested. */
|
|
|
|
|
if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
|
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-10-21 19:12:50 +02:00
|
|
|
|
for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
|
|
|
|
|
;
|
|
|
|
|
if (n != 32)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
else if (!*s)
|
|
|
|
|
; /* No fingerprint given: we allow this for now. */
|
|
|
|
|
else if (*s == '/')
|
|
|
|
|
; /* We ignore a fingerprint. */
|
2005-04-11 18:20:10 +02:00
|
|
|
|
else if (!strcmp (s, "[CHV3]") )
|
|
|
|
|
admin_pin = 1;
|
2003-10-21 19:12:50 +02:00
|
|
|
|
else
|
|
|
|
|
return gpg_error (GPG_ERR_INV_ID);
|
|
|
|
|
|
|
|
|
|
for (s=keyidstr, n=0; n < 16; s += 2, n++)
|
|
|
|
|
tmp_sn[n] = xtoi_2 (s);
|
|
|
|
|
|
|
|
|
|
if (app->serialnolen != 16)
|
|
|
|
|
return gpg_error (GPG_ERR_INV_CARD);
|
|
|
|
|
if (memcmp (app->serialno, tmp_sn, 16))
|
|
|
|
|
return gpg_error (GPG_ERR_WRONG_CARD);
|
2005-04-11 18:20:10 +02:00
|
|
|
|
|
2003-10-21 19:12:50 +02:00
|
|
|
|
/* Yes, there is a race conditions: The user might pull the card
|
|
|
|
|
right here and we won't notice that. However this is not a
|
|
|
|
|
problem and the check above is merely for a graceful failure
|
|
|
|
|
between operations. */
|
|
|
|
|
|
2005-04-11 18:20:10 +02:00
|
|
|
|
if (admin_pin)
|
|
|
|
|
{
|
|
|
|
|
void *relptr;
|
|
|
|
|
unsigned char *value;
|
|
|
|
|
size_t valuelen;
|
|
|
|
|
int count;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2005-04-11 18:20:10 +02:00
|
|
|
|
relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
|
|
|
|
|
if (!relptr || valuelen < 7)
|
|
|
|
|
{
|
|
|
|
|
log_error (_("error retrieving CHV status from card\n"));
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
return gpg_error (GPG_ERR_CARD);
|
|
|
|
|
}
|
|
|
|
|
count = value[6];
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
|
|
|
|
|
if (!count)
|
|
|
|
|
{
|
|
|
|
|
log_info (_("card is permanently locked!\n"));
|
|
|
|
|
return gpg_error (GPG_ERR_BAD_PIN);
|
|
|
|
|
}
|
2014-12-12 20:08:45 +01:00
|
|
|
|
else if (count < 3)
|
2005-04-11 18:20:10 +02:00
|
|
|
|
{
|
|
|
|
|
log_info (_("verification of Admin PIN is currently prohibited "
|
|
|
|
|
"through this command\n"));
|
|
|
|
|
return gpg_error (GPG_ERR_GENERAL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
app->did_chv3 = 0; /* Force verification. */
|
|
|
|
|
return verify_chv3 (app, pincb, pincb_arg);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return verify_chv2 (app, pincb, pincb_arg);
|
2003-10-21 19:12:50 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-09-23 11:57:45 +02:00
|
|
|
|
/* Show information about card capabilities. */
|
|
|
|
|
static void
|
|
|
|
|
show_caps (struct app_local_s *s)
|
|
|
|
|
{
|
2017-07-21 04:21:19 +02:00
|
|
|
|
log_info ("Version-2+ .....: %s\n", s->extcap.is_v2? "yes":"no");
|
|
|
|
|
log_info ("Extcap-v3 ......: %s\n", s->extcap.extcap_v3? "yes":"no");
|
|
|
|
|
log_info ("Button .........: %s\n", s->extcap.has_button? "yes":"no");
|
|
|
|
|
|
|
|
|
|
log_info ("SM-Support .....: %s", s->extcap.sm_supported? "yes":"no");
|
|
|
|
|
if (s->extcap.sm_supported)
|
|
|
|
|
log_printf (" (%s)", s->extcap.sm_algo==2? "3DES":
|
|
|
|
|
(s->extcap.sm_algo==2? "AES-128" : "AES-256"));
|
2008-09-23 11:57:45 +02:00
|
|
|
|
log_info ("Get-Challenge ..: %s", s->extcap.get_challenge? "yes":"no");
|
|
|
|
|
if (s->extcap.get_challenge)
|
|
|
|
|
log_printf (" (%u bytes max)", s->extcap.max_get_challenge);
|
|
|
|
|
log_info ("Key-Import .....: %s\n", s->extcap.key_import? "yes":"no");
|
|
|
|
|
log_info ("Change-Force-PW1: %s\n", s->extcap.change_force_chv? "yes":"no");
|
|
|
|
|
log_info ("Private-DOs ....: %s\n", s->extcap.private_dos? "yes":"no");
|
2008-12-05 13:01:01 +01:00
|
|
|
|
log_info ("Algo-Attr-Change: %s\n", s->extcap.algo_attr_change? "yes":"no");
|
2017-07-21 04:21:19 +02:00
|
|
|
|
log_info ("Symmetric Crypto: %s\n", s->extcap.has_decrypt? "yes":"no");
|
|
|
|
|
log_info ("KDF-Support ....: %s\n", s->extcap.kdf_do? "yes":"no");
|
2008-09-23 11:57:45 +02:00
|
|
|
|
log_info ("Max-Cert3-Len ..: %u\n", s->extcap.max_certlen_3);
|
2017-07-21 04:21:19 +02:00
|
|
|
|
if (s->extcap.extcap_v3)
|
|
|
|
|
{
|
|
|
|
|
log_info ("PIN-Block-2 ....: %s\n", s->extcap.pin_blk2? "yes":"no");
|
|
|
|
|
log_info ("MSE-Support ....: %s\n", s->extcap.mse? "yes":"no");
|
|
|
|
|
log_info ("Max-Special-DOs : %u\n", s->extcap.max_special_do);
|
|
|
|
|
}
|
2008-09-23 11:57:45 +02:00
|
|
|
|
log_info ("Cmd-Chaining ...: %s\n", s->cardcap.cmd_chaining?"yes":"no");
|
|
|
|
|
log_info ("Ext-Lc-Le ......: %s\n", s->cardcap.ext_lc_le?"yes":"no");
|
2017-07-21 04:21:19 +02:00
|
|
|
|
log_info ("Status-Indicator: %02X\n", s->status_indicator);
|
2008-09-23 11:57:45 +02:00
|
|
|
|
|
|
|
|
|
log_info ("GnuPG-No-Sync ..: %s\n", s->flags.no_sync? "yes":"no");
|
|
|
|
|
log_info ("GnuPG-Def-PW2 ..: %s\n", s->flags.def_chv2? "yes":"no");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Parse the historical bytes in BUFFER of BUFLEN and store them in
|
|
|
|
|
APPLOC. */
|
|
|
|
|
static void
|
2011-02-04 12:57:53 +01:00
|
|
|
|
parse_historical (struct app_local_s *apploc,
|
2008-09-23 11:57:45 +02:00
|
|
|
|
const unsigned char * buffer, size_t buflen)
|
|
|
|
|
{
|
|
|
|
|
/* Example buffer: 00 31 C5 73 C0 01 80 00 90 00 */
|
|
|
|
|
if (buflen < 4)
|
|
|
|
|
{
|
|
|
|
|
log_error ("warning: historical bytes are too short\n");
|
|
|
|
|
return; /* Too short. */
|
|
|
|
|
}
|
|
|
|
|
if (*buffer)
|
|
|
|
|
{
|
|
|
|
|
log_error ("warning: bad category indicator in historical bytes\n");
|
2011-02-04 12:57:53 +01:00
|
|
|
|
return;
|
2008-09-23 11:57:45 +02:00
|
|
|
|
}
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2008-09-23 11:57:45 +02:00
|
|
|
|
/* Skip category indicator. */
|
|
|
|
|
buffer++;
|
|
|
|
|
buflen--;
|
|
|
|
|
|
|
|
|
|
/* Get the status indicator. */
|
|
|
|
|
apploc->status_indicator = buffer[buflen-3];
|
|
|
|
|
buflen -= 3;
|
|
|
|
|
|
|
|
|
|
/* Parse the compact TLV. */
|
|
|
|
|
while (buflen)
|
|
|
|
|
{
|
|
|
|
|
unsigned int tag = (*buffer & 0xf0) >> 4;
|
|
|
|
|
unsigned int len = (*buffer & 0x0f);
|
|
|
|
|
if (len+1 > buflen)
|
|
|
|
|
{
|
|
|
|
|
log_error ("warning: bad Compact-TLV in historical bytes\n");
|
|
|
|
|
return; /* Error. */
|
|
|
|
|
}
|
|
|
|
|
buffer++;
|
|
|
|
|
buflen--;
|
|
|
|
|
if (tag == 7 && len == 3)
|
|
|
|
|
{
|
|
|
|
|
/* Card capabilities. */
|
|
|
|
|
apploc->cardcap.cmd_chaining = !!(buffer[2] & 0x80);
|
|
|
|
|
apploc->cardcap.ext_lc_le = !!(buffer[2] & 0x40);
|
|
|
|
|
}
|
|
|
|
|
buffer += len;
|
|
|
|
|
buflen -= len;
|
|
|
|
|
}
|
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
|
|
|
|
|
2015-08-05 00:59:50 +02:00
|
|
|
|
/*
|
|
|
|
|
* Check if the OID in an DER encoding is available by GnuPG/libgcrypt,
|
2016-10-24 04:22:44 +02:00
|
|
|
|
* and return the curve name. Return NULL if not available.
|
2015-08-05 00:59:50 +02:00
|
|
|
|
* The constant string is not allocated dynamically, never free it.
|
|
|
|
|
*/
|
2015-07-25 05:09:23 +02:00
|
|
|
|
static const char *
|
2016-10-24 04:22:44 +02:00
|
|
|
|
ecc_curve (unsigned char *buf, size_t buflen)
|
2013-03-08 03:40:37 +01:00
|
|
|
|
{
|
2015-07-25 05:09:23 +02:00
|
|
|
|
gcry_mpi_t oid;
|
|
|
|
|
char *oidstr;
|
|
|
|
|
const char *result;
|
2015-08-05 00:59:50 +02:00
|
|
|
|
unsigned char *oidbuf;
|
2015-07-25 05:09:23 +02:00
|
|
|
|
|
2015-08-05 00:59:50 +02:00
|
|
|
|
oidbuf = xtrymalloc (buflen + 1);
|
|
|
|
|
if (!oidbuf)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
memcpy (oidbuf+1, buf, buflen);
|
|
|
|
|
oidbuf[0] = buflen;
|
2015-08-05 01:17:46 +02:00
|
|
|
|
oid = gcry_mpi_set_opaque (NULL, oidbuf, (buflen+1) * 8);
|
2015-07-25 05:09:23 +02:00
|
|
|
|
if (!oid)
|
2015-08-05 00:59:50 +02:00
|
|
|
|
{
|
|
|
|
|
xfree (oidbuf);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2015-07-25 05:09:23 +02:00
|
|
|
|
|
|
|
|
|
oidstr = openpgp_oid_to_str (oid);
|
|
|
|
|
gcry_mpi_release (oid);
|
|
|
|
|
if (!oidstr)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2016-10-24 04:22:44 +02:00
|
|
|
|
result = openpgp_oid_to_curve (oidstr, 1);
|
2015-07-25 05:09:23 +02:00
|
|
|
|
xfree (oidstr);
|
|
|
|
|
return result;
|
2013-03-08 03:40:37 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
/* Parse and optionally show the algorithm attributes for KEYNO.
|
|
|
|
|
KEYNO must be in the range 0..2. */
|
2011-02-04 12:57:53 +01:00
|
|
|
|
static void
|
2008-09-23 17:42:11 +02:00
|
|
|
|
parse_algorithm_attribute (app_t app, int keyno)
|
2011-02-04 12:57:53 +01:00
|
|
|
|
{
|
2008-09-23 17:42:11 +02:00
|
|
|
|
unsigned char *buffer;
|
|
|
|
|
size_t buflen;
|
|
|
|
|
void *relptr;
|
2010-10-18 14:59:19 +02:00
|
|
|
|
const char desc[3][5] = {"sign", "encr", "auth"};
|
2008-09-23 17:42:11 +02:00
|
|
|
|
|
|
|
|
|
assert (keyno >=0 && keyno <= 2);
|
|
|
|
|
|
2013-03-08 03:40:37 +01:00
|
|
|
|
app->app_local->keyattr[keyno].key_type = KEY_TYPE_RSA;
|
|
|
|
|
app->app_local->keyattr[keyno].rsa.n_bits = 0;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2008-09-23 17:42:11 +02:00
|
|
|
|
relptr = get_one_do (app, 0xC1+keyno, &buffer, &buflen, NULL);
|
|
|
|
|
if (!relptr)
|
|
|
|
|
{
|
|
|
|
|
log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (buflen < 1)
|
|
|
|
|
{
|
|
|
|
|
log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
if (opt.verbose)
|
|
|
|
|
log_info ("Key-Attr-%s ..: ", desc[keyno]);
|
2015-07-17 02:34:47 +02:00
|
|
|
|
if (*buffer == PUBKEY_ALGO_RSA && (buflen == 5 || buflen == 6))
|
2008-09-23 17:42:11 +02:00
|
|
|
|
{
|
2013-03-08 03:40:37 +01:00
|
|
|
|
app->app_local->keyattr[keyno].rsa.n_bits = (buffer[1]<<8 | buffer[2]);
|
|
|
|
|
app->app_local->keyattr[keyno].rsa.e_bits = (buffer[3]<<8 | buffer[4]);
|
|
|
|
|
app->app_local->keyattr[keyno].rsa.format = 0;
|
2008-09-25 12:06:02 +02:00
|
|
|
|
if (buflen < 6)
|
2013-03-08 03:40:37 +01:00
|
|
|
|
app->app_local->keyattr[keyno].rsa.format = RSA_STD;
|
2008-09-25 12:06:02 +02:00
|
|
|
|
else
|
2013-03-08 03:40:37 +01:00
|
|
|
|
app->app_local->keyattr[keyno].rsa.format = (buffer[5] == 0? RSA_STD :
|
|
|
|
|
buffer[5] == 1? RSA_STD_N :
|
|
|
|
|
buffer[5] == 2? RSA_CRT :
|
|
|
|
|
buffer[5] == 3? RSA_CRT_N :
|
|
|
|
|
RSA_UNKNOWN_FMT);
|
2008-09-25 12:06:02 +02:00
|
|
|
|
|
|
|
|
|
if (opt.verbose)
|
|
|
|
|
log_printf
|
|
|
|
|
("RSA, n=%u, e=%u, fmt=%s\n",
|
2013-03-08 03:40:37 +01:00
|
|
|
|
app->app_local->keyattr[keyno].rsa.n_bits,
|
|
|
|
|
app->app_local->keyattr[keyno].rsa.e_bits,
|
|
|
|
|
app->app_local->keyattr[keyno].rsa.format == RSA_STD? "std" :
|
|
|
|
|
app->app_local->keyattr[keyno].rsa.format == RSA_STD_N?"std+n":
|
|
|
|
|
app->app_local->keyattr[keyno].rsa.format == RSA_CRT? "crt" :
|
|
|
|
|
app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N?"crt+n":"?");
|
|
|
|
|
}
|
2015-07-25 05:09:23 +02:00
|
|
|
|
else if (*buffer == PUBKEY_ALGO_ECDH || *buffer == PUBKEY_ALGO_ECDSA
|
|
|
|
|
|| *buffer == PUBKEY_ALGO_EDDSA)
|
2013-03-08 03:40:37 +01:00
|
|
|
|
{
|
2016-10-24 04:22:44 +02:00
|
|
|
|
const char *curve;
|
2016-09-16 08:20:32 +02:00
|
|
|
|
int oidlen = buflen - 1;
|
|
|
|
|
|
|
|
|
|
app->app_local->keyattr[keyno].ecc.flags = 0;
|
|
|
|
|
|
|
|
|
|
if (buffer[buflen-1] == 0x00 || buffer[buflen-1] == 0xff)
|
|
|
|
|
{ /* Found "pubkey required"-byte for private key template. */
|
|
|
|
|
oidlen--;
|
|
|
|
|
if (buffer[buflen-1] == 0xff)
|
|
|
|
|
app->app_local->keyattr[keyno].ecc.flags |= ECC_FLAG_PUBKEY;
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-24 04:22:44 +02:00
|
|
|
|
curve = ecc_curve (buffer + 1, oidlen);
|
2015-08-05 00:59:50 +02:00
|
|
|
|
|
2016-10-24 04:22:44 +02:00
|
|
|
|
if (!curve)
|
2020-05-12 18:51:47 +02:00
|
|
|
|
log_printhex (buffer+1, buflen-1, "Curve with OID not supported: ");
|
2015-08-05 00:59:50 +02:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
app->app_local->keyattr[keyno].key_type = KEY_TYPE_ECC;
|
2016-10-24 04:22:44 +02:00
|
|
|
|
app->app_local->keyattr[keyno].ecc.curve = curve;
|
2015-08-06 10:00:41 +02:00
|
|
|
|
if (*buffer == PUBKEY_ALGO_EDDSA
|
|
|
|
|
|| (*buffer == PUBKEY_ALGO_ECDH
|
2016-10-24 04:22:44 +02:00
|
|
|
|
&& !strcmp (app->app_local->keyattr[keyno].ecc.curve,
|
|
|
|
|
"Curve25519")))
|
2016-09-16 08:20:32 +02:00
|
|
|
|
app->app_local->keyattr[keyno].ecc.flags |= ECC_FLAG_DJB_TWEAK;
|
2015-08-05 00:59:50 +02:00
|
|
|
|
if (opt.verbose)
|
|
|
|
|
log_printf
|
2016-10-24 04:22:44 +02:00
|
|
|
|
("ECC, curve=%s%s\n", app->app_local->keyattr[keyno].ecc.curve,
|
2016-09-16 08:20:32 +02:00
|
|
|
|
!(app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK)?
|
|
|
|
|
"": keyno==1? " (djb-tweak)": " (eddsa)");
|
2015-08-05 00:59:50 +02:00
|
|
|
|
}
|
2008-09-25 12:06:02 +02:00
|
|
|
|
}
|
|
|
|
|
else if (opt.verbose)
|
2020-05-12 18:51:47 +02:00
|
|
|
|
log_printhex (buffer, buflen, "");
|
2008-09-23 17:42:11 +02:00
|
|
|
|
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
}
|
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
/* Select the OpenPGP application on the card in SLOT. This function
|
|
|
|
|
must be used before any other OpenPGP application functions. */
|
2005-05-18 12:48:06 +02:00
|
|
|
|
gpg_error_t
|
2004-10-14 15:22:03 +02:00
|
|
|
|
app_select_openpgp (app_t app)
|
2003-08-05 19:11:04 +02:00
|
|
|
|
{
|
|
|
|
|
static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
|
|
|
|
|
int slot = app->slot;
|
|
|
|
|
int rc;
|
|
|
|
|
unsigned char *buffer;
|
|
|
|
|
size_t buflen;
|
2003-09-30 19:35:05 +02:00
|
|
|
|
void *relptr;
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2005-11-28 12:52:25 +01:00
|
|
|
|
/* Note that the card can't cope with P2=0xCO, thus we need to pass a
|
|
|
|
|
special flag value. */
|
|
|
|
|
rc = iso7816_select_application (slot, aid, sizeof aid, 0x0001);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (!rc)
|
|
|
|
|
{
|
2004-09-30 15:24:33 +02:00
|
|
|
|
unsigned int manufacturer;
|
|
|
|
|
|
2004-01-27 17:40:42 +01:00
|
|
|
|
app->apptype = "OPENPGP";
|
|
|
|
|
|
2003-09-30 19:35:05 +02:00
|
|
|
|
app->did_chv1 = 0;
|
|
|
|
|
app->did_chv2 = 0;
|
|
|
|
|
app->did_chv3 = 0;
|
2004-09-30 15:24:33 +02:00
|
|
|
|
app->app_local = NULL;
|
2003-09-30 19:35:05 +02:00
|
|
|
|
|
2004-01-27 17:40:42 +01:00
|
|
|
|
/* The OpenPGP card returns the serial number as part of the
|
|
|
|
|
AID; because we prefer to use OpenPGP serial numbers, we
|
2004-03-16 19:59:21 +01:00
|
|
|
|
replace a possibly already set one from a EF.GDO with this
|
2004-01-27 17:40:42 +01:00
|
|
|
|
one. Note, that for current OpenPGP cards, no EF.GDO exists
|
|
|
|
|
and thus it won't matter at all. */
|
2009-06-17 11:45:50 +02:00
|
|
|
|
rc = iso7816_get_data (slot, 0, 0x004F, &buffer, &buflen);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (rc)
|
|
|
|
|
goto leave;
|
|
|
|
|
if (opt.verbose)
|
|
|
|
|
{
|
2004-09-30 15:24:33 +02:00
|
|
|
|
log_info ("AID: ");
|
2020-05-12 18:51:47 +02:00
|
|
|
|
log_printhex (buffer, buflen, "");
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
2004-01-27 17:40:42 +01:00
|
|
|
|
app->card_version = buffer[6] << 8;
|
|
|
|
|
app->card_version |= buffer[7];
|
2004-09-30 15:24:33 +02:00
|
|
|
|
manufacturer = (buffer[8]<<8 | buffer[9]);
|
|
|
|
|
|
2004-01-27 17:40:42 +01:00
|
|
|
|
xfree (app->serialno);
|
|
|
|
|
app->serialno = buffer;
|
|
|
|
|
app->serialnolen = buflen;
|
|
|
|
|
buffer = NULL;
|
2004-09-30 15:24:33 +02:00
|
|
|
|
app->app_local = xtrycalloc (1, sizeof *app->app_local);
|
|
|
|
|
if (!app->app_local)
|
|
|
|
|
{
|
|
|
|
|
rc = gpg_error (gpg_err_code_from_errno (errno));
|
|
|
|
|
goto leave;
|
|
|
|
|
}
|
2003-08-05 19:11:04 +02:00
|
|
|
|
|
2012-11-06 12:02:25 +01:00
|
|
|
|
app->app_local->manufacturer = manufacturer;
|
|
|
|
|
|
2008-07-17 21:40:53 +02:00
|
|
|
|
if (app->card_version >= 0x0200)
|
|
|
|
|
app->app_local->extcap.is_v2 = 1;
|
|
|
|
|
|
2017-07-20 10:27:21 +02:00
|
|
|
|
if (app->card_version >= 0x0300)
|
|
|
|
|
app->app_local->extcap.extcap_v3 = 1;
|
2008-09-23 11:57:45 +02:00
|
|
|
|
|
|
|
|
|
/* Read the historical bytes. */
|
|
|
|
|
relptr = get_one_do (app, 0x5f52, &buffer, &buflen, NULL);
|
|
|
|
|
if (relptr)
|
|
|
|
|
{
|
|
|
|
|
if (opt.verbose)
|
|
|
|
|
{
|
|
|
|
|
log_info ("Historical Bytes: ");
|
2020-05-12 18:51:47 +02:00
|
|
|
|
log_printhex (buffer, buflen, "");
|
2008-09-23 11:57:45 +02:00
|
|
|
|
}
|
|
|
|
|
parse_historical (app->app_local, buffer, buflen);
|
|
|
|
|
xfree (relptr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Read the force-chv1 flag. */
|
2005-02-24 18:36:11 +01:00
|
|
|
|
relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
|
2003-09-30 19:35:05 +02:00
|
|
|
|
if (!relptr)
|
|
|
|
|
{
|
2004-10-14 15:22:03 +02:00
|
|
|
|
log_error (_("can't access %s - invalid OpenPGP card?\n"),
|
|
|
|
|
"CHV Status Bytes");
|
2003-09-30 19:35:05 +02:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
app->force_chv1 = (buflen && *buffer == 0);
|
|
|
|
|
xfree (relptr);
|
2004-09-30 15:24:33 +02:00
|
|
|
|
|
2008-09-23 11:57:45 +02:00
|
|
|
|
/* Read the extended capabilities. */
|
2005-02-24 18:36:11 +01:00
|
|
|
|
relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
|
2004-09-30 15:24:33 +02:00
|
|
|
|
if (!relptr)
|
|
|
|
|
{
|
2004-10-14 15:22:03 +02:00
|
|
|
|
log_error (_("can't access %s - invalid OpenPGP card?\n"),
|
|
|
|
|
"Extended Capability Flags" );
|
2004-09-30 15:24:33 +02:00
|
|
|
|
goto leave;
|
|
|
|
|
}
|
|
|
|
|
if (buflen)
|
|
|
|
|
{
|
2008-09-23 11:57:45 +02:00
|
|
|
|
app->app_local->extcap.sm_supported = !!(*buffer & 0x80);
|
2004-09-30 15:24:33 +02:00
|
|
|
|
app->app_local->extcap.get_challenge = !!(*buffer & 0x40);
|
|
|
|
|
app->app_local->extcap.key_import = !!(*buffer & 0x20);
|
|
|
|
|
app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
|
|
|
|
|
app->app_local->extcap.private_dos = !!(*buffer & 0x08);
|
2008-12-05 13:01:01 +01:00
|
|
|
|
app->app_local->extcap.algo_attr_change = !!(*buffer & 0x04);
|
2015-06-26 08:14:27 +02:00
|
|
|
|
app->app_local->extcap.has_decrypt = !!(*buffer & 0x02);
|
2017-07-20 10:27:21 +02:00
|
|
|
|
app->app_local->extcap.kdf_do = !!(*buffer & 0x01);
|
2004-09-30 15:24:33 +02:00
|
|
|
|
}
|
2008-07-17 21:40:53 +02:00
|
|
|
|
if (buflen >= 10)
|
|
|
|
|
{
|
2017-07-20 10:27:21 +02:00
|
|
|
|
/* Available with cards of v2 or later. */
|
2015-06-26 08:14:27 +02:00
|
|
|
|
app->app_local->extcap.sm_algo = buffer[1];
|
2011-02-04 12:57:53 +01:00
|
|
|
|
app->app_local->extcap.max_get_challenge
|
2008-09-23 11:57:45 +02:00
|
|
|
|
= (buffer[2] << 8 | buffer[3]);
|
2008-07-17 21:40:53 +02:00
|
|
|
|
app->app_local->extcap.max_certlen_3 = (buffer[4] << 8 | buffer[5]);
|
2017-07-20 10:27:21 +02:00
|
|
|
|
|
|
|
|
|
/* Interpretation is different between v2 and v3, unfortunately. */
|
|
|
|
|
if (app->app_local->extcap.extcap_v3)
|
|
|
|
|
{
|
|
|
|
|
app->app_local->extcap.max_special_do
|
|
|
|
|
= (buffer[6] << 8 | buffer[7]);
|
|
|
|
|
app->app_local->extcap.pin_blk2 = !!(buffer[8] & 0x01);
|
|
|
|
|
app->app_local->extcap.mse= !!(buffer[9] & 0x01);
|
|
|
|
|
}
|
2008-07-17 21:40:53 +02:00
|
|
|
|
}
|
2004-09-30 15:24:33 +02:00
|
|
|
|
xfree (relptr);
|
2008-09-23 17:42:11 +02:00
|
|
|
|
|
2015-11-16 12:41:46 +01:00
|
|
|
|
/* Some of the first cards accidentally don't set the
|
2004-09-30 15:24:33 +02:00
|
|
|
|
CHANGE_FORCE_CHV bit but allow it anyway. */
|
|
|
|
|
if (app->card_version <= 0x0100 && manufacturer == 1)
|
|
|
|
|
app->app_local->extcap.change_force_chv = 1;
|
|
|
|
|
|
2015-06-26 08:14:27 +02:00
|
|
|
|
/* Check optional DO of "General Feature Management" for button. */
|
|
|
|
|
relptr = get_one_do (app, 0x7f74, &buffer, &buflen, NULL);
|
|
|
|
|
if (relptr)
|
|
|
|
|
/* It must be: 03 81 01 20 */
|
|
|
|
|
app->app_local->extcap.has_button = 1;
|
|
|
|
|
|
2004-10-14 15:22:03 +02:00
|
|
|
|
parse_login_data (app);
|
2004-09-30 15:24:33 +02:00
|
|
|
|
|
2008-09-23 11:57:45 +02:00
|
|
|
|
if (opt.verbose)
|
|
|
|
|
show_caps (app->app_local);
|
|
|
|
|
|
2008-09-25 12:06:02 +02:00
|
|
|
|
parse_algorithm_attribute (app, 0);
|
|
|
|
|
parse_algorithm_attribute (app, 1);
|
|
|
|
|
parse_algorithm_attribute (app, 2);
|
2011-02-04 12:57:53 +01:00
|
|
|
|
|
2003-08-05 19:11:04 +02:00
|
|
|
|
if (opt.verbose > 1)
|
|
|
|
|
dump_all_do (slot);
|
|
|
|
|
|
2004-04-26 20:28:06 +02:00
|
|
|
|
app->fnc.deinit = do_deinit;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
app->fnc.learn_status = do_learn_status;
|
2008-07-17 21:40:53 +02:00
|
|
|
|
app->fnc.readcert = do_readcert;
|
2005-02-22 18:29:07 +01:00
|
|
|
|
app->fnc.readkey = do_readkey;
|
2003-09-30 19:35:05 +02:00
|
|
|
|
app->fnc.getattr = do_getattr;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
app->fnc.setattr = do_setattr;
|
2008-09-23 11:57:45 +02:00
|
|
|
|
app->fnc.writecert = do_writecert;
|
2005-05-20 22:39:36 +02:00
|
|
|
|
app->fnc.writekey = do_writekey;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
app->fnc.genkey = do_genkey;
|
|
|
|
|
app->fnc.sign = do_sign;
|
|
|
|
|
app->fnc.auth = do_auth;
|
|
|
|
|
app->fnc.decipher = do_decipher;
|
|
|
|
|
app->fnc.change_pin = do_change_pin;
|
2003-10-21 19:12:50 +02:00
|
|
|
|
app->fnc.check_pin = do_check_pin;
|
2003-08-05 19:11:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
leave:
|
2004-09-30 15:24:33 +02:00
|
|
|
|
if (rc)
|
|
|
|
|
do_deinit (app);
|
2003-08-05 19:11:04 +02:00
|
|
|
|
return rc;
|
|
|
|
|
}
|