mirror of
git://git.gniibe.org/gnuk/gnuk.git
synced 2026-11-20 18:51:25 +00:00
Fix Ed448 key import/generation.
Signed-off-by: NIIBE Yutaka <[email protected]>
This commit is contained in:
@@ -1,3 +1,17 @@
|
||||
2025-03-13 NIIBE Yutaka <[email protected]>
|
||||
|
||||
* src/openpgp-do.c (CHECKSUM_ADDR): Remove.
|
||||
(struct key_data_internal): Remove.
|
||||
(gpg_do_load_prvkey): Use struct key_data for KDI.
|
||||
(gpg_do_write_prvkey): Use struct key_data for KDI. Fix for Ed448
|
||||
key with GCM SIV encryption.
|
||||
(proc_key_import): Add length check for ALGO_SECP256K1.
|
||||
After flash writing, clear private key data sent to Gnuk.
|
||||
Fix for Ed448 key.
|
||||
|
||||
* src/flash.c (flash_key_write): Handle the case where the length
|
||||
of data is odd for Ed448 key.
|
||||
|
||||
2024-04-20 NIIBE Yutaka <[email protected]>
|
||||
|
||||
* VERSION: Version 2.2.
|
||||
|
||||
@@ -458,6 +458,9 @@ flash_key_write (enum kind_of_key kk, int algo,
|
||||
uint16_t len = DATA_ENCRYPTION_NONCE_SIZE + DATA_ENCRYPTION_TAG_SIZE
|
||||
+ prvkey_len + pubkey_len;
|
||||
|
||||
/* The length must be even. */
|
||||
len += (len & 1);
|
||||
|
||||
addr = (uintptr_t)key_addr;
|
||||
pkc_key[kk].key_addr = key_addr;
|
||||
|
||||
|
||||
+36
-45
@@ -1128,18 +1128,6 @@ proc_resetting_code (const uint8_t *data, int len)
|
||||
}
|
||||
|
||||
|
||||
#define CHECKSUM_ADDR(kdi,prvkey_len) \
|
||||
(uint8_t *)(&(kdi).data[prvkey_len / sizeof (uint32_t)])
|
||||
#define kdi_len(prvkey_len) (prvkey_len+ENCRYPTION_BLOCK_SIZE)
|
||||
struct key_data_internal {
|
||||
uint32_t data[(MAX_PRVKEY_LEN+ENCRYPTION_BLOCK_SIZE) / sizeof (uint32_t)];
|
||||
/*
|
||||
* Secret key data.
|
||||
* ECDSA/ECDH: d, EdDSA: a+seed
|
||||
*/
|
||||
/* Checksum */
|
||||
};
|
||||
|
||||
/*
|
||||
* We use CTR mode for encryption and decryption. The operation is
|
||||
* exactly same, thus, we call it "crypt".
|
||||
@@ -1202,7 +1190,7 @@ int
|
||||
gpg_do_load_prvkey (enum kind_of_key kk, int who, const uint8_t *keystring)
|
||||
{
|
||||
uint8_t dek[DATA_ENCRYPTION_KEY_SIZE];
|
||||
struct key_data_internal kdi;
|
||||
struct key_data kdi;
|
||||
int r;
|
||||
const uint8_t *nonce;
|
||||
const uint8_t *tag;
|
||||
@@ -1224,7 +1212,7 @@ gpg_do_load_prvkey (enum kind_of_key kk, int who, const uint8_t *keystring)
|
||||
decrypt_dek ((who - BY_USER), keystring, nonce, dek);
|
||||
|
||||
r = gcm_siv_decrypt (dek, nonce, pubkey, pubkey_len,
|
||||
(uint8_t *)kdi.data, prvkey_len, tag);
|
||||
kdi.data, prvkey_len, tag);
|
||||
memset (dek, 0, DATA_ENCRYPTION_KEY_SIZE);
|
||||
if (!r)
|
||||
{
|
||||
@@ -1292,20 +1280,20 @@ gpg_do_terminate (void)
|
||||
}
|
||||
|
||||
static int
|
||||
gpg_do_write_prvkey (enum kind_of_key kk, const uint8_t *key_data,
|
||||
gpg_do_write_prvkey (enum kind_of_key kk, const uint8_t *prvkey,
|
||||
int prvkey_len, const uint8_t *keystring_admin,
|
||||
const uint8_t *pubkey)
|
||||
{
|
||||
int attr = gpg_get_algo_attr (kk);;
|
||||
int r;
|
||||
const uint8_t *dek, *nonce;
|
||||
struct key_data_internal kdi;
|
||||
struct key_data kdi;
|
||||
int pubkey_len;
|
||||
uint8_t ks[KEYSTRING_MD_SIZE];
|
||||
enum kind_of_key kk0;
|
||||
int pw_len;
|
||||
const uint8_t *initial_pw;
|
||||
uint8_t *tag;
|
||||
uint8_t tag[DATA_ENCRYPTION_TAG_SIZE];
|
||||
uint8_t nonce0[DATA_ENCRYPTION_NONCE_SIZE];
|
||||
uint8_t dek_encrypted_1[DATA_ENCRYPTION_KEY_SIZE];
|
||||
uint8_t dek_encrypted_3[DATA_ENCRYPTION_KEY_SIZE];
|
||||
@@ -1333,8 +1321,8 @@ gpg_do_write_prvkey (enum kind_of_key kk, const uint8_t *key_data,
|
||||
}
|
||||
else if (attr == ALGO_ED448)
|
||||
{
|
||||
pubkey_len = 57 + 1; /* +1 to be even. */
|
||||
if (prvkey_len != 128)
|
||||
pubkey_len = 57;
|
||||
if (prvkey_len != 114)
|
||||
return -1;
|
||||
}
|
||||
else if (attr == ALGO_X448)
|
||||
@@ -1348,8 +1336,7 @@ gpg_do_write_prvkey (enum kind_of_key kk, const uint8_t *key_data,
|
||||
|
||||
num_prv_keys++;
|
||||
|
||||
memcpy (kdi.data, key_data, prvkey_len);
|
||||
memset ((uint8_t *)kdi.data + prvkey_len, 0, MAX_PRVKEY_LEN - prvkey_len);
|
||||
memcpy (kdi.data, prvkey, prvkey_len);
|
||||
|
||||
nonce = random_bytes_get (); /* 32-byte random bytes */
|
||||
memcpy (nonce0, nonce, DATA_ENCRYPTION_NONCE_SIZE);
|
||||
@@ -1373,13 +1360,12 @@ gpg_do_write_prvkey (enum kind_of_key kk, const uint8_t *key_data,
|
||||
gpg_do_chks_prvkey (kk0, BY_RESETCODE, NULL, 0, NULL);
|
||||
}
|
||||
|
||||
tag = CHECKSUM_ADDR (kdi, prvkey_len);
|
||||
gcm_siv_encrypt (dek, nonce0, pubkey, pubkey_len,
|
||||
(uint8_t *)kdi.data, prvkey_len, tag);
|
||||
kdi.data, prvkey_len, tag);
|
||||
random_bytes_free (dek);
|
||||
|
||||
r = flash_key_write (kk, attr, nonce0, tag,
|
||||
(const uint8_t *)kdi.data, prvkey_len,
|
||||
kdi.data, prvkey_len,
|
||||
pubkey, pubkey_len);
|
||||
if (r < 0)
|
||||
{
|
||||
@@ -1487,6 +1473,7 @@ proc_key_import (const uint8_t *data, int len)
|
||||
int attr;
|
||||
const uint8_t *p = data;
|
||||
uint8_t pubkey[512];
|
||||
uint8_t *prvkey;
|
||||
|
||||
#ifdef KDF_DO_REQUIRED
|
||||
const uint8_t *kdf_do = do_ptr[NR_DO_KDF];
|
||||
@@ -1530,69 +1517,73 @@ proc_key_import (const uint8_t *data, int len)
|
||||
return 1;
|
||||
}
|
||||
|
||||
prvkey = (uint8_t *)&data[12];
|
||||
len -= 12;
|
||||
if (attr == ALGO_SECP256K1)
|
||||
{
|
||||
r = ecc_compute_public_p256k1 (&data[12], pubkey);
|
||||
if (len != 32)
|
||||
return 0; /* Error. */
|
||||
|
||||
r = ecc_compute_public_p256k1 (prvkey, pubkey);
|
||||
if (r >= 0)
|
||||
r = gpg_do_write_prvkey (kk, &data[12], len - 12, keystring_admin,
|
||||
pubkey);
|
||||
r = gpg_do_write_prvkey (kk, prvkey, len, keystring_admin, pubkey);
|
||||
}
|
||||
else if (attr == ALGO_CURVE25519)
|
||||
{
|
||||
uint8_t priv[32];
|
||||
int i;
|
||||
|
||||
if (len - 12 != 32)
|
||||
if (len != 32)
|
||||
return 0; /* Error. */
|
||||
|
||||
/* Revert the order, because it's big-endian MPI from server. */
|
||||
for (i = 0; i < 32; i++)
|
||||
priv[31-i] = data[12+i];
|
||||
for (i = 0; i < len; i++)
|
||||
priv[31-i] = prvkey[i];
|
||||
ecdh_compute_public_25519 (priv, pubkey);
|
||||
r = gpg_do_write_prvkey (kk, priv, 32, keystring_admin, pubkey);
|
||||
r = gpg_do_write_prvkey (kk, priv, len, keystring_admin, pubkey);
|
||||
memset (priv, 0, len);
|
||||
}
|
||||
else if (attr == ALGO_ED25519)
|
||||
{
|
||||
uint8_t hash[64];
|
||||
|
||||
if (len - 12 != 32)
|
||||
if (len != 32)
|
||||
return 0; /* Error. */
|
||||
|
||||
sha512 (&data[12], 32, hash);
|
||||
sha512 (prvkey, 32, hash);
|
||||
hash[0] &= 248;
|
||||
hash[31] &= 127;
|
||||
hash[31] |= 64;
|
||||
eddsa_compute_public_25519 (hash, pubkey);
|
||||
r = gpg_do_write_prvkey (kk, hash, 64, keystring_admin, pubkey);
|
||||
memset (hash, 0, 64);
|
||||
}
|
||||
else if (attr == ALGO_ED448)
|
||||
{
|
||||
keccak_context ctx;
|
||||
uint8_t hash[128];
|
||||
uint8_t hash[114];
|
||||
|
||||
if (len - 12 != 57)
|
||||
if (len != 57)
|
||||
return 0; /* Error. */
|
||||
|
||||
shake256_start (&ctx);
|
||||
shake256_update (&ctx, &data[12], 57);
|
||||
shake256_finish (&ctx, hash, 2*57);
|
||||
memset (hash+114, 0, 128-114);
|
||||
shake256_update (&ctx, prvkey, 57);
|
||||
shake256_finish (&ctx, hash, 114);
|
||||
ed448_compute_public (pubkey, hash);
|
||||
pubkey[57] = 0;
|
||||
r = gpg_do_write_prvkey (kk, hash, 128, keystring_admin, pubkey);
|
||||
r = gpg_do_write_prvkey (kk, hash, 114, keystring_admin, pubkey);
|
||||
memset (hash, 0, 114);
|
||||
}
|
||||
else if (attr == ALGO_X448)
|
||||
{
|
||||
uint8_t priv[56];
|
||||
|
||||
if (len - 12 != 56)
|
||||
if (len != 56)
|
||||
return 0; /* Error. */
|
||||
|
||||
memcpy (priv, data+12, 56);
|
||||
ecdh_compute_public_x448 (pubkey, priv);
|
||||
r = gpg_do_write_prvkey (kk, priv, 56, keystring_admin, pubkey);
|
||||
ecdh_compute_public_x448 (pubkey, prvkey);
|
||||
r = gpg_do_write_prvkey (kk, prvkey, len, keystring_admin, pubkey);
|
||||
}
|
||||
|
||||
memset (prvkey, 0, len);
|
||||
if (r < 0)
|
||||
return 0;
|
||||
else
|
||||
|
||||
Reference in New Issue
Block a user