Skip to content

Commit 9312cd0

Browse files
ankk-cssankk-css
committed
<TrustM> Fixed Sigma3 and ecdsa keyid selection issues.
1 parent e7107fc commit 9312cd0

5 files changed

+59
-78
lines changed

‎src/platform/Infineon/crypto/trustm/CHIPCryptoPALHost.cpp

+9-11
Original file line numberDiff line numberDiff line change
@@ -83,6 +83,7 @@ typedef struct
8383
} EntropyContext;
8484

8585
static EntropyContext gsEntropyContext;
86+
static mbedtls_ccm_context ccm_context;
8687

8788
static void _log_mbedTLS_error(int error_code)
8889
{
@@ -107,16 +108,14 @@ static bool _isValidTagLength(size_t tag_length)
107108
}
108109
return false;
109110
}
110-
111111
CHIP_ERROR AES_CCM_encrypt(const uint8_t * plaintext, size_t plaintext_length, const uint8_t * aad, size_t aad_length,
112112
const Aes128KeyHandle & key, const uint8_t * nonce, size_t nonce_length, uint8_t * ciphertext,
113113
uint8_t * tag, size_t tag_length)
114114
{
115115
CHIP_ERROR error = CHIP_NO_ERROR;
116116
int result = 1;
117117

118-
mbedtls_ccm_context context;
119-
mbedtls_ccm_init(&context);
118+
mbedtls_ccm_init(&ccm_context);
120119

121120
VerifyOrExit(plaintext != nullptr || plaintext_length == 0, error = CHIP_ERROR_INVALID_ARGUMENT);
122121
VerifyOrExit(ciphertext != nullptr || plaintext_length == 0, error = CHIP_ERROR_INVALID_ARGUMENT);
@@ -130,18 +129,18 @@ CHIP_ERROR AES_CCM_encrypt(const uint8_t * plaintext, size_t plaintext_length, c
130129
}
131130

132131
// Size of key is expressed in bits, hence the multiplication by 8.
133-
result = mbedtls_ccm_setkey(&context, MBEDTLS_CIPHER_ID_AES, key.As<Symmetric128BitsKeyByteArray>(), sizeof(Symmetric128BitsKeyByteArray) * 8);
132+
result = mbedtls_ccm_setkey(&ccm_context, MBEDTLS_CIPHER_ID_AES, key.As<Symmetric128BitsKeyByteArray>(), sizeof(Symmetric128BitsKeyByteArray) * 8);
134133
VerifyOrExit(result == 0, error = CHIP_ERROR_INTERNAL);
135134

136135
// Encrypt
137-
result = mbedtls_ccm_encrypt_and_tag(&context, plaintext_length, Uint8::to_const_uchar(nonce), nonce_length,
136+
result = mbedtls_ccm_encrypt_and_tag(&ccm_context, plaintext_length, Uint8::to_const_uchar(nonce), nonce_length,
138137
Uint8::to_const_uchar(aad), aad_length, Uint8::to_const_uchar(plaintext),
139138
Uint8::to_uchar(ciphertext), Uint8::to_uchar(tag), tag_length);
140139
_log_mbedTLS_error(result);
141140
VerifyOrExit(result == 0, error = CHIP_ERROR_INTERNAL);
142141

143142
exit:
144-
mbedtls_ccm_free(&context);
143+
mbedtls_ccm_free(&ccm_context);
145144
return error;
146145
}
147146

@@ -152,8 +151,7 @@ CHIP_ERROR AES_CCM_decrypt(const uint8_t * ciphertext, size_t ciphertext_len, co
152151
CHIP_ERROR error = CHIP_NO_ERROR;
153152
int result = 1;
154153

155-
mbedtls_ccm_context context;
156-
mbedtls_ccm_init(&context);
154+
mbedtls_ccm_init(&ccm_context);
157155

158156
VerifyOrExit(plaintext != nullptr || ciphertext_len == 0, error = CHIP_ERROR_INVALID_ARGUMENT);
159157
VerifyOrExit(ciphertext != nullptr || ciphertext_len == 0, error = CHIP_ERROR_INVALID_ARGUMENT);
@@ -167,18 +165,18 @@ CHIP_ERROR AES_CCM_decrypt(const uint8_t * ciphertext, size_t ciphertext_len, co
167165
}
168166

169167
// Size of key is expressed in bits, hence the multiplication by 8.
170-
result = mbedtls_ccm_setkey(&context, MBEDTLS_CIPHER_ID_AES, key.As<Symmetric128BitsKeyByteArray>(), sizeof(Symmetric128BitsKeyByteArray) * 8);
168+
result = mbedtls_ccm_setkey(&ccm_context, MBEDTLS_CIPHER_ID_AES, key.As<Symmetric128BitsKeyByteArray>(), sizeof(Symmetric128BitsKeyByteArray) * 8);
171169
VerifyOrExit(result == 0, error = CHIP_ERROR_INTERNAL);
172170

173171
// Decrypt
174-
result = mbedtls_ccm_auth_decrypt(&context, ciphertext_len, Uint8::to_const_uchar(nonce), nonce_length,
172+
result = mbedtls_ccm_auth_decrypt(&ccm_context, ciphertext_len, Uint8::to_const_uchar(nonce), nonce_length,
175173
Uint8::to_const_uchar(aad), aad_len, Uint8::to_const_uchar(ciphertext),
176174
Uint8::to_uchar(plaintext), Uint8::to_const_uchar(tag), tag_length);
177175
_log_mbedTLS_error(result);
178176
VerifyOrExit(result == 0, error = CHIP_ERROR_INTERNAL);
179177

180178
exit:
181-
mbedtls_ccm_free(&context);
179+
mbedtls_ccm_free(&ccm_context);
182180
return error;
183181
}
184182

‎src/platform/Infineon/crypto/trustm/CHIPCryptoPALHsm_P256_trustm.cpp

+48-58
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,6 @@ const uint8_t kTlvHeader = 2;
4848

4949
// Define keyid
5050
uint32_t keyid =0;
51-
5251
namespace chip {
5352
namespace Crypto {
5453

@@ -87,8 +86,7 @@ static CHIP_ERROR get_trustm_keyid_from_keypair(const P256KeypairContext mKeypai
8786
return CHIP_ERROR_INTERNAL;
8887
}
8988

90-
*key_id += (mKeypair.mBytes[CRYPTO_KEYPAIR_KEYID_OFFSET] << (8 * 1) & 0xFF00) |
91-
(mKeypair.mBytes[CRYPTO_KEYPAIR_KEYID_OFFSET + 1] << (8 * 0) & 0x00FF);
89+
*key_id += (mKeypair.mBytes[CRYPTO_KEYPAIR_KEYID_OFFSET]) | (mKeypair.mBytes[CRYPTO_KEYPAIR_KEYID_OFFSET + 1] << 8 );
9290

9391
return CHIP_NO_ERROR;
9492
}
@@ -117,6 +115,7 @@ CHIP_ERROR P256Keypair::Initialize(ECPKeyTarget key_target)
117115
{
118116
mInitialized = true;
119117
}
118+
error = CHIP_NO_ERROR;
120119
return error;
121120
#else
122121
uint8_t pubkey[128] = {
@@ -125,61 +124,40 @@ CHIP_ERROR P256Keypair::Initialize(ECPKeyTarget key_target)
125124
uint16_t pubKeyLen = sizeof(pubkey);
126125
optiga_lib_status_t return_status = OPTIGA_LIB_BUSY;
127126
P256PublicKey & public_key = const_cast<P256PublicKey &>(Pubkey());
127+
optiga_key_usage_t key_usage;
128+
uint16_t keyid;
128129

129-
if (key_target == ECPKeyTarget::ECDH)
130-
{
130+
if (key_target == ECPKeyTarget::ECDH) {
131131
keyid = TRUSTM_ECDH_OID_KEY;
132-
// Trust M init
133-
trustm_Open();
132+
134133
// Trust M ECC 256 Key Gen
135134
ChipLogDetail(Crypto, "Generating NIST256 key in TrustM for ECDH!");
136-
uint8_t key_usage = (optiga_key_usage_t)(OPTIGA_KEY_USAGE_KEY_AGREEMENT);
137-
138-
return_status = trustm_ecc_keygen(OPTIGA_KEY_ID_E0F3, key_usage, OPTIGA_ECC_CURVE_NIST_P_256, pubkey, &pubKeyLen);
139-
140-
// Add signature length
141-
VerifyOrExit(return_status == OPTIGA_LIB_SUCCESS, error = CHIP_ERROR_INTERNAL);
142-
143-
/* Set the public key */
144-
VerifyOrReturnError((size_t) pubKeyLen > NIST256_HEADER_OFFSET, CHIP_ERROR_INTERNAL);
145-
VerifyOrReturnError(((size_t) pubKeyLen - NIST256_HEADER_OFFSET) <= kP256_PublicKey_Length, CHIP_ERROR_INTERNAL);
146-
memcpy((void *) Uint8::to_const_uchar(public_key), pubkey + NIST256_HEADER_OFFSET, pubKeyLen - NIST256_HEADER_OFFSET);
147-
148-
memcpy(&mKeypair.mBytes[0], trustm_magic_no, sizeof(trustm_magic_no));
149-
mKeypair.mBytes[CRYPTO_KEYPAIR_KEYID_OFFSET] = (keyid >> (1 * 8)) & 0x00FF;
150-
mKeypair.mBytes[CRYPTO_KEYPAIR_KEYID_OFFSET + 1] = (keyid >> (0 * 8)) & 0x00FF;
151-
152-
mInitialized = true;
153-
error = CHIP_NO_ERROR;
154-
}
155-
else
156-
{
135+
key_usage = OPTIGA_KEY_USAGE_KEY_AGREEMENT;
136+
} else {
157137
// Add the logic to use different keyid
158-
keyid = TRUSTM_NODE_OID_KEY_START;
159-
// Trust M init
160-
trustm_Open();
138+
keyid = TRUSTM_NODE_OID_KEY_START;
161139
// Trust M ECC 256 Key Gen
162140
ChipLogDetail(Crypto, "Generating NIST256 key in TrustM !");
163-
uint8_t key_usage = (optiga_key_usage_t)(OPTIGA_KEY_USAGE_SIGN | OPTIGA_KEY_USAGE_AUTHENTICATION);
164-
165-
return_status = trustm_ecc_keygen(OPTIGA_KEY_ID_E0F2, key_usage, OPTIGA_ECC_CURVE_NIST_P_256, pubkey, &pubKeyLen);
166-
// Add signature length
167-
VerifyOrExit(return_status == OPTIGA_LIB_SUCCESS, error = CHIP_ERROR_INTERNAL);
168-
169-
/* Set the public key */
170-
VerifyOrReturnError((size_t) pubKeyLen > NIST256_HEADER_OFFSET, CHIP_ERROR_INTERNAL);
171-
VerifyOrReturnError(((size_t) pubKeyLen - NIST256_HEADER_OFFSET) <= kP256_PublicKey_Length, CHIP_ERROR_INTERNAL);
172-
memcpy((void *) Uint8::to_const_uchar(public_key), pubkey + NIST256_HEADER_OFFSET, pubKeyLen - NIST256_HEADER_OFFSET);
141+
key_usage = (optiga_key_usage_t)(OPTIGA_KEY_USAGE_SIGN | OPTIGA_KEY_USAGE_AUTHENTICATION);
142+
}
143+
// Trust M init
144+
trustm_Open();
145+
return_status = trustm_ecc_keygen(keyid, key_usage, OPTIGA_ECC_CURVE_NIST_P_256, pubkey, &pubKeyLen);
173146

174-
memcpy(&mKeypair.mBytes[0], trustm_magic_no, sizeof(trustm_magic_no));
175-
mKeypair.mBytes[CRYPTO_KEYPAIR_KEYID_OFFSET] = (keyid >> (1 * 8)) & 0x00FF;
176-
mKeypair.mBytes[CRYPTO_KEYPAIR_KEYID_OFFSET + 1] = (keyid >> (0 * 8)) & 0x00FF;
147+
// Add signature length
148+
VerifyOrExit(return_status == OPTIGA_LIB_SUCCESS, error = CHIP_ERROR_INTERNAL);
177149

178-
mInitialized = true;
179-
error = CHIP_NO_ERROR;
150+
/* Set the public key */
151+
VerifyOrReturnError((size_t) pubKeyLen > NIST256_HEADER_OFFSET, CHIP_ERROR_INTERNAL);
152+
VerifyOrReturnError(((size_t) pubKeyLen - NIST256_HEADER_OFFSET) <= kP256_PublicKey_Length, CHIP_ERROR_INTERNAL);
153+
memcpy((void *) Uint8::to_const_uchar(public_key), pubkey + NIST256_HEADER_OFFSET, pubKeyLen - NIST256_HEADER_OFFSET);
180154

181-
}
155+
memcpy(&mKeypair.mBytes[0], trustm_magic_no, sizeof(trustm_magic_no));
156+
mKeypair.mBytes[CRYPTO_KEYPAIR_KEYID_OFFSET] = (keyid >> (0 * 8)) & 0xFF;
157+
mKeypair.mBytes[CRYPTO_KEYPAIR_KEYID_OFFSET + 1] = (keyid >> (1 * 8)) & 0xFF;
182158

159+
mInitialized = true;
160+
error = CHIP_NO_ERROR;
183161

184162
exit:
185163
if (error != CHIP_NO_ERROR)
@@ -213,14 +191,19 @@ CHIP_ERROR P256Keypair::ECDSA_sign_msg(const uint8_t * msg, size_t msg_length, P
213191
trustm_Open();
214192
// Hash to get the digest
215193
Hash_SHA256(msg, msg_length, &digest[0]);
194+
uint16_t keyid = (mKeypair.mBytes[CRYPTO_KEYPAIR_KEYID_OFFSET]) | (mKeypair.mBytes[CRYPTO_KEYPAIR_KEYID_OFFSET+1] << 8);
216195
// Api call to calculate the signature
217-
return_status = trustm_ecdsa_sign(OPTIGA_KEY_ID_E0F0, digest, digest_length, signature_trustm, &signature_trustm_len);
218-
196+
if (keyid == OPTIGA_KEY_ID_E0F2) {
197+
return_status = trustm_ecdsa_sign(OPTIGA_KEY_ID_E0F2, digest, digest_length, signature_trustm, &signature_trustm_len);
198+
} else {
199+
return_status = trustm_ecdsa_sign(OPTIGA_KEY_ID_E0F0, digest, digest_length, signature_trustm, &signature_trustm_len);
200+
}
201+
219202
VerifyOrExit(return_status == OPTIGA_LIB_SUCCESS, error = CHIP_ERROR_INTERNAL);
220203

221204
error = EcdsaAsn1SignatureToRaw(kP256_FE_Length, ByteSpan{ signature_trustm, signature_trustm_len }, out_raw_sig_span);
222205

223-
ChipLogError(NotSpecified, "EcdsaAsn1SignatureToRaw %" CHIP_ERROR_FORMAT, error.Format());
206+
// ChipLogError(NotSpecified, "EcdsaAsn1SignatureToRaw %" CHIP_ERROR_FORMAT, error.Format());
224207

225208
SuccessOrExit(error);
226209

@@ -257,9 +240,16 @@ CHIP_ERROR P256Keypair::ECDH_derive_secret(const P256PublicKey & remote_public_k
257240

258241
const uint8_t * const rem_pubKey = Uint8::to_const_uchar(remote_public_key);
259242
const size_t rem_pubKeyLen = remote_public_key.Length();
260-
return_status = trustm_ecdh_derive_secret(OPTIGA_KEY_ID_E0F3, (uint8_t*)rem_pubKey, (uint16_t)rem_pubKeyLen,
261-
out_secret.Bytes(), (uint8_t)secret_length);
262-
243+
244+
uint8_t remote_key[68];
245+
uint8_t header[3] = {0x03, 0x42, 0x00};
246+
247+
memcpy(remote_key, &header, 3);
248+
memcpy(remote_key+3, rem_pubKey, rem_pubKeyLen);
249+
250+
return_status = trustm_ecdh_derive_secret(OPTIGA_KEY_ID_E0F3, (uint8_t*)remote_key, (uint16_t)rem_pubKeyLen+3,
251+
out_secret.Bytes(), (uint8_t)secret_length);
252+
263253
VerifyOrExit(return_status == OPTIGA_LIB_SUCCESS, error = CHIP_ERROR_INTERNAL) ;
264254

265255
exit:
@@ -357,9 +347,10 @@ CHIP_ERROR P256Keypair::Deserialize(P256SerializedKeypair & input)
357347
VerifyOrReturnError(bbuf.Fit(), CHIP_ERROR_NO_MEMORY);
358348

359349
memcpy(&mKeypair.mBytes[0], trustm_magic_no, sizeof(trustm_magic_no));
360-
mKeypair.mBytes[8] = *(privkey + 8);
361-
mKeypair.mBytes[9] = *(privkey + 9);
362-
// ChipLogDetail(Crypto, "Parsed keyId = 0x%02X%02X", mKeypair.mBytes[8], mKeypair.mBytes[9]);
350+
351+
mKeypair.mBytes[4] = *(privkey + 4);
352+
mKeypair.mBytes[5] = *(privkey + 5);
353+
// ChipLogDetail(Crypto, "Parsed keyId = 0x%02X%02X", mKeypair.mBytes[4], mKeypair.mBytes[5]);
363354

364355
mInitialized = true;
365356

@@ -443,7 +434,7 @@ CHIP_ERROR P256Keypair::NewCertificateSigningRequest(uint8_t * csr, size_t & csr
443434
{
444435
#if !ENABLE_TRUSTM_GENERATE_EC_KEY
445436
return NewCertificateSigningRequest_H(&mKeypair, csr, csr_length);
446-
#else
437+
#else
447438
CHIP_ERROR error = CHIP_ERROR_INTERNAL;
448439
optiga_lib_status_t return_status = OPTIGA_LIB_BUSY;
449440

@@ -593,7 +584,6 @@ CHIP_ERROR P256Keypair::NewCertificateSigningRequest(uint8_t * csr, size_t & csr
593584
csr_length = (csr_index + signature_len);
594585

595586
error = CHIP_NO_ERROR;
596-
597587
exit:
598588
if (error != CHIP_NO_ERROR)
599589
{

‎src/platform/Infineon/crypto/trustm/CHIPCryptoPALHsm_utils_trustm.h

+1-1
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ extern optiga_util_t * p_local_util;
5151
}
5252

5353
static const uint8_t trustm_magic_no[] = IFX_CRYPTO_KEY_MAGIC;
54-
54+
static const uint8_t DA_KEY_ID[] = {0xE0, 0xF0};
5555
/* Open session to trustm */
5656
void trustm_Open(void);
5757
void read_certificate_from_optiga(uint16_t optiga_oid, char * cert_pem, uint16_t * cert_pem_length);

‎src/platform/Infineon/crypto/trustm/CHIPCryptoPAL_HostFallBack.cpp

-7
Original file line numberDiff line numberDiff line change
@@ -442,13 +442,6 @@ CHIP_ERROR Deserialize_H(P256Keypair * pk, P256PublicKey * mPublicKey, P256Keypa
442442
bbuf.Put(input.ConstBytes(), mPublicKey->Length());
443443
VerifyOrExit(bbuf.Fit(), error = CHIP_ERROR_NO_MEMORY);
444444

445-
printf("\n");
446-
for (size_t i = 0; i < mPublicKey->Length(); i++)
447-
{
448-
printf("0x%02X ", Uint8::to_const_uchar(*mPublicKey)[i]);
449-
}
450-
printf("\n");
451-
452445
result = mbedtls_ecp_point_read_binary(&keypair->CHIP_CRYPTO_PAL_PRIVATE(grp), &keypair->CHIP_CRYPTO_PAL_PRIVATE(Q),
453446
Uint8::to_const_uchar(*mPublicKey), mPublicKey->Length());
454447
VerifyOrExit(result == 0, error = CHIP_ERROR_INVALID_ARGUMENT);

‎src/platform/Infineon/crypto/trustm/DeviceAttestationCredsExampleTrustM.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -117,7 +117,7 @@ CHIP_ERROR ExampleTrustMDACProvider::SignWithDeviceAttestationKey(const ByteSpan
117117

118118
memset(serialized_keypair.Bytes(), 0, Crypto::kP256_PublicKey_Length);
119119
memcpy(serialized_keypair.Bytes() + Crypto::kP256_PublicKey_Length, trustm_magic_no, sizeof(trustm_magic_no));
120-
120+
memcpy(serialized_keypair.Bytes() + (Crypto::kP256_PublicKey_Length + sizeof (trustm_magic_no)), DA_KEY_ID, 2);
121121

122122
ReturnErrorOnFailure(keypair.Deserialize(serialized_keypair));
123123

0 commit comments

Comments
 (0)