Skip to content

Commit 9e9be91

Browse files
mguetschowmguetschow
committed
sys/psa_crypto: unify buffer size size handling for ed25519 backends
1 parent ed226e3 commit 9e9be91

File tree

4 files changed

+70
-103
lines changed

4 files changed

+70
-103
lines changed

‎pkg/c25519/psa_c25519/edsign.c‎

Lines changed: 13 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -22,72 +22,42 @@
2222
#include "edsign.h"
2323
#include "random.h"
2424

25-
psa_status_t psa_generate_ecc_ed25519_key_pair( uint8_t *priv_key_buffer, uint8_t *pub_key_buffer,
26-
size_t *priv_key_buffer_length,
27-
size_t *pub_key_buffer_length)
25+
psa_status_t psa_generate_ecc_ed25519_key_pair( uint8_t *priv_key_buffer,
26+
uint8_t *pub_key_buffer)
2827
{
29-
*priv_key_buffer_length = EDSIGN_SECRET_KEY_SIZE;
30-
*pub_key_buffer_length = EDSIGN_PUBLIC_KEY_SIZE;
31-
28+
// todo: maybe this should usa psa_random instead
3229
random_bytes(priv_key_buffer, EDSIGN_SECRET_KEY_SIZE);
3330
ed25519_prepare(priv_key_buffer);
3431
edsign_sec_to_pub(pub_key_buffer, priv_key_buffer);
3532

3633
return PSA_SUCCESS;
3734
}
3835

39-
psa_status_t psa_derive_ecc_ed25519_public_key( const uint8_t *priv_key_buffer, uint8_t *pub_key_buffer,
40-
size_t priv_key_buffer_length,
41-
size_t *pub_key_buffer_length)
36+
psa_status_t psa_derive_ecc_ed25519_public_key( const uint8_t *priv_key_buffer,
37+
uint8_t *pub_key_buffer)
4238
{
43-
*pub_key_buffer_length = EDSIGN_PUBLIC_KEY_SIZE;
44-
4539
edsign_sec_to_pub(pub_key_buffer, priv_key_buffer);
4640

47-
(void)priv_key_buffer_length;
4841
return PSA_SUCCESS;
4942
}
5043

51-
psa_status_t psa_ecc_ed25519_sign_message( const uint8_t *priv_key_buffer,
52-
size_t priv_key_buffer_size,
53-
const uint8_t *pub_key_buffer,
54-
size_t pub_key_buffer_size,
55-
const uint8_t *input,
56-
size_t input_length,
57-
uint8_t *signature,
58-
size_t signature_size,
59-
size_t *signature_length)
44+
psa_status_t psa_ecc_ed25519_sign_message(const uint8_t *priv_key_buffer,
45+
const uint8_t *pub_key_buffer,
46+
const uint8_t *input, size_t input_length,
47+
uint8_t *signature)
6048
{
61-
if (signature_size < EDSIGN_SIGNATURE_SIZE) {
62-
return PSA_ERROR_BUFFER_TOO_SMALL;
63-
}
64-
65-
*signature_length = EDSIGN_SIGNATURE_SIZE;
6649
edsign_sign(signature, pub_key_buffer, priv_key_buffer, input, input_length);
6750

68-
(void)priv_key_buffer_size;
69-
(void)pub_key_buffer_size;
7051
return PSA_SUCCESS;
7152
}
7253

73-
psa_status_t psa_ecc_ed25519_verify_message(const uint8_t *key_buffer,
74-
size_t key_buffer_size,
75-
const uint8_t *input,
76-
size_t input_length,
77-
const uint8_t *signature,
78-
size_t signature_length)
54+
psa_status_t psa_ecc_ed25519_verify_message(const uint8_t *pub_key_buffer,
55+
const uint8_t *input, size_t input_length,
56+
const uint8_t *signature)
7957
{
80-
uint8_t ret = 0;
81-
82-
if (signature_length < EDSIGN_SIGNATURE_SIZE) {
83-
return PSA_ERROR_INVALID_SIGNATURE;
84-
}
85-
86-
ret = edsign_verify(signature, key_buffer, input, input_length);
87-
if (!ret) {
58+
if (!edsign_verify(signature, pub_key_buffer, input, input_length)) {
8859
return PSA_ERROR_INVALID_SIGNATURE;
8960
}
9061

91-
(void)key_buffer_size;
9262
return PSA_SUCCESS;
9363
}

‎pkg/driver_cryptocell_310/psa_cryptocell_310/ecc_ed25519.c‎

Lines changed: 19 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -29,9 +29,7 @@
2929
extern CRYS_RND_State_t *rndState_ptr;
3030

3131
psa_status_t psa_generate_ecc_ed25519_key_pair( uint8_t *priv_key_buffer,
32-
uint8_t *pub_key_buffer,
33-
size_t *priv_key_buffer_length,
34-
size_t *pub_key_buffer_length)
32+
uint8_t *pub_key_buffer)
3533
{
3634
CRYS_ECEDW_TempBuff_t tmp;
3735
CRYSError_t ret;
@@ -40,12 +38,11 @@ psa_status_t psa_generate_ecc_ed25519_key_pair( uint8_t *priv_key_buffer,
4038
uint8_t secret_key[CRYS_ECEDW_ORD_SIZE_IN_BYTES + CRYS_ECEDW_MOD_SIZE_IN_BYTES] = { 0x0 };
4139
size_t secret_key_size = sizeof(secret_key);
4240

43-
*priv_key_buffer_length = CRYS_ECEDW_ORD_SIZE_IN_BYTES;
44-
*pub_key_buffer_length = CRYS_ECEDW_MOD_SIZE_IN_BYTES;
41+
size_t pub_key_size = 32;
4542

4643
cryptocell_310_enable();
4744
ret = CRYS_ECEDW_KeyPair(secret_key, &secret_key_size,
48-
pub_key_buffer, pub_key_buffer_length,
45+
pub_key_buffer, &pub_key_size,
4946
rndState_ptr, CRYS_RND_GenerateVector, &tmp);
5047
cryptocell_310_disable();
5148
if (ret != CRYS_OK) {
@@ -60,9 +57,8 @@ psa_status_t psa_generate_ecc_ed25519_key_pair( uint8_t *priv_key_buffer,
6057
return CRYS_to_psa_error(ret);
6158
}
6259

63-
psa_status_t psa_derive_ecc_ed25519_public_key( const uint8_t *priv_key_buffer, uint8_t *pub_key_buffer,
64-
size_t priv_key_buffer_length,
65-
size_t *pub_key_buffer_length)
60+
psa_status_t psa_derive_ecc_ed25519_public_key( const uint8_t *priv_key_buffer,
61+
uint8_t *pub_key_buffer)
6662
{
6763
CRYS_ECEDW_TempBuff_t tmp;
6864
CRYSError_t ret;
@@ -76,11 +72,11 @@ psa_status_t psa_derive_ecc_ed25519_public_key( const uint8_t *priv_key_buffer,
7672
uint8_t secret_key[CRYS_ECEDW_ORD_SIZE_IN_BYTES + CRYS_ECEDW_MOD_SIZE_IN_BYTES] = { 0x0 };
7773
size_t secret_key_size = sizeof(secret_key);
7874

79-
*pub_key_buffer_length = CRYS_ECEDW_MOD_SIZE_IN_BYTES;
75+
size_t pub_key_size = 32;
8076

8177
cryptocell_310_enable();
82-
ret = CRYS_ECEDW_SeedKeyPair(priv_key_buffer, priv_key_buffer_length, secret_key, &secret_key_size,
83-
pub_key_buffer, pub_key_buffer_length, &tmp);
78+
ret = CRYS_ECEDW_SeedKeyPair(priv_key_buffer, 32, secret_key, &secret_key_size,
79+
pub_key_buffer, &pub_key_size, &tmp);
8480
cryptocell_310_disable();
8581
if (ret != CRYS_OK) {
8682
DEBUG("CRYS_ECEDW_SeedKeyPair failed with %s\n", cryptocell310_status_to_humanly_readable(ret));
@@ -93,14 +89,9 @@ psa_status_t psa_derive_ecc_ed25519_public_key( const uint8_t *priv_key_buffer,
9389
}
9490

9591
psa_status_t psa_ecc_ed25519_sign_message(const uint8_t *priv_key_buffer,
96-
size_t priv_key_buffer_size,
9792
const uint8_t *pub_key_buffer,
98-
size_t pub_key_buffer_size,
99-
const uint8_t *input,
100-
size_t input_length,
101-
uint8_t *signature,
102-
size_t signature_size,
103-
size_t *signature_length)
93+
const uint8_t *input, size_t input_length,
94+
uint8_t *signature)
10495
{
10596
CRYS_ECEDW_TempBuff_t tmp;
10697
CRYSError_t ret;
@@ -119,16 +110,13 @@ psa_status_t psa_ecc_ed25519_sign_message(const uint8_t *priv_key_buffer,
119110
/* contains seed (private key), concatenated with public key */
120111
uint8_t secret_key[CRYS_ECEDW_ORD_SIZE_IN_BYTES + CRYS_ECEDW_MOD_SIZE_IN_BYTES] = { 0x0 };
121112

122-
if (priv_key_buffer_size != CRYS_ECEDW_ORD_SIZE_IN_BYTES || pub_key_buffer_size != CRYS_ECEDW_MOD_SIZE_IN_BYTES) {
123-
return PSA_ERROR_INVALID_ARGUMENT;
124-
}
125-
126-
memcpy(secret_key, priv_key_buffer, CRYS_ECEDW_ORD_SIZE_IN_BYTES);
113+
memcpy(&secret_key[0], priv_key_buffer, CRYS_ECEDW_ORD_SIZE_IN_BYTES);
127114
memcpy(&secret_key[CRYS_ECEDW_ORD_SIZE_IN_BYTES], pub_key_buffer, CRYS_ECEDW_MOD_SIZE_IN_BYTES);
128-
*signature_length = signature_size;
115+
116+
size_t signature_size = 64;
129117

130118
cryptocell_310_enable();
131-
ret = CRYS_ECEDW_Sign(signature, signature_length, input, input_length, secret_key, sizeof(secret_key), &tmp);
119+
ret = CRYS_ECEDW_Sign(signature, &signature_size, input, input_length, secret_key, sizeof(secret_key), &tmp);
132120
cryptocell_310_disable();
133121
if (ret != CRYS_OK) {
134122
DEBUG("CRYS_ECEDW_Sign failed with %s\n", cryptocell310_status_to_humanly_readable(ret));
@@ -138,21 +126,16 @@ psa_status_t psa_ecc_ed25519_sign_message(const uint8_t *priv_key_buffer,
138126
done:
139127
explicit_bzero(&secret_key, sizeof(secret_key));
140128
return CRYS_to_psa_error(ret);
141-
142-
(void)signature_size;
143129
}
144130

145-
psa_status_t psa_ecc_ed25519_verify_message(const uint8_t *key_buffer,
146-
size_t key_buffer_size,
147-
const uint8_t *input,
148-
size_t input_length,
149-
const uint8_t *signature,
150-
size_t signature_length)
131+
psa_status_t psa_ecc_ed25519_verify_message(const uint8_t *pub_key_buffer,
132+
const uint8_t *input, size_t input_length,
133+
const uint8_t *signature)
151134
{
152135
CRYS_ECEDW_TempBuff_t tmp;
153136
CRYSError_t ret;
154137

155-
if (!cryptocell_310_data_within_ram(key_buffer) ||
138+
if (!cryptocell_310_data_within_ram(pub_key_buffer) ||
156139
!cryptocell_310_data_within_ram(input) ||
157140
!cryptocell_310_data_within_ram(signature)) {
158141
DEBUG("%s : cryptocell_310 data required to be in RAM.\n", __FILE__);
@@ -164,7 +147,7 @@ psa_status_t psa_ecc_ed25519_verify_message(const uint8_t *key_buffer,
164147
}
165148

166149
cryptocell_310_enable();
167-
ret = CRYS_ECEDW_Verify(signature, signature_length, key_buffer, key_buffer_size, (uint8_t *)input, input_length, &tmp);
150+
ret = CRYS_ECEDW_Verify(signature, 64, pub_key_buffer, 32, (uint8_t *)input, input_length, &tmp);
168151
cryptocell_310_disable();
169152
if (ret != CRYS_OK) {
170153
DEBUG("CRYS_ECEDW_Verify failed with %s\n", cryptocell310_status_to_humanly_readable(ret));

‎sys/psa_crypto/include/psa_ecc.h‎

Lines changed: 23 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -148,41 +148,49 @@ psa_status_t psa_ecc_p256r1_verify_message(const psa_key_attributes_t *attribute
148148
/**
149149
* @brief Low level wrapper function to call a driver for an ECC key generation
150150
* with an ed25519 key.
151-
* See @ref psa_generate_key()
151+
*
152+
* @param[out] priv_key_buffer buffer of size 32B to write the private key to
153+
* @param[out] pub_key_buffer buffer of size 32B to write the public key to
152154
*/
153-
psa_status_t psa_generate_ecc_ed25519_key_pair( uint8_t *priv_key_buffer, uint8_t *pub_key_buffer,
154-
size_t *priv_key_buffer_length,
155-
size_t *pub_key_buffer_length);
155+
psa_status_t psa_generate_ecc_ed25519_key_pair( uint8_t *priv_key_buffer,
156+
uint8_t *pub_key_buffer);
156157

157158
/**
158159
* @brief Low level wrapper function for deriving an ed25519 public key from the private key.
160+
*
161+
* @param[in] priv_key_buffer buffer of size 32B containing the private key
162+
* @param[out] pub_key_buffer buffer of size 32B to write the public key to
159163
*/
160164
psa_status_t psa_derive_ecc_ed25519_public_key( const uint8_t *priv_key_buffer,
161-
uint8_t *pub_key_buffer,
162-
size_t priv_key_buffer_length,
163-
size_t *pub_key_buffer_length);
165+
uint8_t *pub_key_buffer);
164166

165167
/**
166168
* @brief Low level wrapper function to call a driver for an ECC hash signature
167169
* with an ed25519 key.
168-
* See @ref psa_sign_message()
170+
*
171+
* @param[in] priv_key_buffer buffer of size 32B containing the private key
172+
* @param[in] pub_key_buffer buffer of size 32B containing the public key
173+
* @param[in] input input message to be signed
174+
* @param[in] input_length length of @p input in bytes
175+
* @param[out] signature buffer of size 64 to write the signature to
169176
*/
170177
psa_status_t psa_ecc_ed25519_sign_message(const uint8_t *priv_key_buffer,
171-
size_t priv_key_buffer_size,
172178
const uint8_t *pub_key_buffer,
173-
size_t pub_key_buffer_size,
174179
const uint8_t *input, size_t input_length,
175-
uint8_t *signature, size_t signature_size,
176-
size_t *signature_length);
180+
uint8_t *signature);
177181

178182
/**
179183
* @brief Low level wrapper function to call a driver for an ECC hash verification
180184
* with a ed25519 key.
181-
* See @ref psa_verify_message()
185+
*
186+
* @param[in] pub_key_buffer buffer of size 32B containing the public key
187+
* @param[in] input input message whose signature should be checked
188+
* @param[in] input_length length of @p input in bytes
189+
* @param[in] signature buffer of size 64 containing the signature
182190
*/
183-
psa_status_t psa_ecc_ed25519_verify_message(const uint8_t *key_buffer, size_t key_buffer_size,
191+
psa_status_t psa_ecc_ed25519_verify_message(const uint8_t *pub_key_buffer,
184192
const uint8_t *input, size_t input_length,
185-
const uint8_t *signature, size_t signature_length);
193+
const uint8_t *signature);
186194

187195
#ifdef __cplusplus
188196
}

‎sys/psa_crypto/psa_crypto_algorithm_dispatch.c‎

Lines changed: 15 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -366,9 +366,12 @@ psa_status_t psa_algorithm_dispatch_sign_message(const psa_key_attributes_t *att
366366
#if IS_USED(MODULE_PSA_ASYMMETRIC_ECC_ED25519)
367367
case PSA_ECC_ED25519:
368368
psa_get_public_key_data_from_key_slot(slot, &pub_key_data, &pub_key_bytes);
369-
return psa_ecc_ed25519_sign_message(key_data, *key_bytes, pub_key_data, *pub_key_bytes,
370-
input, input_length,
371-
signature, signature_size, signature_length);
369+
assert(*key_bytes == 32);
370+
assert(*pub_key_bytes == 32);
371+
if (signature_size < 64) return PSA_ERROR_BUFFER_TOO_SMALL;
372+
*signature_length = 64;
373+
return psa_ecc_ed25519_sign_message(key_data, pub_key_data,
374+
input, input_length, signature);
372375
#endif
373376
default:
374377
(void)alg;
@@ -467,8 +470,9 @@ psa_status_t psa_algorithm_dispatch_verify_message(const psa_key_attributes_t *a
467470
#endif
468471
#if IS_USED(MODULE_PSA_ASYMMETRIC_ECC_ED25519)
469472
case PSA_ECC_ED25519:
470-
return psa_ecc_ed25519_verify_message(pubkey_data, *pubkey_data_len, input,
471-
input_length, signature, signature_length);
473+
assert(*pubkey_data_len == 32);
474+
if (signature_length < 64) return PSA_ERROR_INVALID_SIGNATURE;
475+
return psa_ecc_ed25519_verify_message(pubkey_data, input, input_length, signature);
472476
#endif
473477
default:
474478
(void)alg;
@@ -525,8 +529,9 @@ psa_status_t psa_algorithm_dispatch_generate_key( const psa_key_attributes_t *
525529
#endif
526530
#if IS_USED(MODULE_PSA_ASYMMETRIC_ECC_ED25519)
527531
case PSA_ECC_ED25519:
528-
return psa_generate_ecc_ed25519_key_pair(key_data, pubkey_data,
529-
key_bytes, pubkey_data_len);
532+
*key_bytes = 32;
533+
*pubkey_data_len = 32;
534+
return psa_generate_ecc_ed25519_key_pair(key_data, pubkey_data);
530535
#endif
531536
default:
532537
(void)status;
@@ -585,8 +590,9 @@ psa_status_t psa_algorithm_dispatch_import_key(const psa_key_attributes_t *attri
585590
#endif
586591
#if IS_USED(MODULE_PSA_ASYMMETRIC_ECC_ED25519)
587592
case PSA_ECC_ED25519:
588-
ret = psa_derive_ecc_ed25519_public_key(data, pubkey_data,
589-
data_length, pubkey_data_len);
593+
if (data_length < 32) return PSA_ERROR_INVALID_ARGUMENT;
594+
ret = psa_derive_ecc_ed25519_public_key(data, pubkey_data);
595+
*pubkey_data_len = 32;
590596
break;
591597
#endif
592598
default:

0 commit comments

Comments
 (0)