Skip to content

Commit 662d793

Browse files
AdityaHPatwardhanHarshal5
AdityaHPatwardhan
authored and
Harshal5
committed
feat(esp_security): Added support for key manager for esp32c5
1 parent 7e570d2 commit 662d793

File tree

18 files changed

+417
-114
lines changed

18 files changed

+417
-114
lines changed

‎components/bootloader_support/src/esp32c5/flash_encryption_secure_features.c‎

Lines changed: 4 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
2+
* SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
33
*
44
* SPDX-License-Identifier: Apache-2.0
55
*/
@@ -71,12 +71,9 @@ esp_err_t esp_flash_encryption_enable_secure_features(void)
7171

7272
esp_err_t esp_flash_encryption_enable_key_mgr(void)
7373
{
74-
// Enable and reset key manager
75-
// To suppress build errors about spinlock's __DECLARE_RCC_ATOMIC_ENV
76-
int __DECLARE_RCC_ATOMIC_ENV __attribute__ ((unused));
77-
key_mgr_ll_enable_bus_clock(true);
78-
key_mgr_ll_enable_peripheral_clock(true);
79-
key_mgr_ll_reset_register();
74+
_key_mgr_ll_enable_bus_clock(true);
75+
_key_mgr_ll_enable_peripheral_clock(true);
76+
_key_mgr_ll_reset_register();
8077

8178
while (key_mgr_ll_get_state() != ESP_KEY_MGR_STATE_IDLE) {
8279
};

‎components/bootloader_support/src/esp32p4/flash_encryption_secure_features.c‎

Lines changed: 4 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
2+
* SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
33
*
44
* SPDX-License-Identifier: Apache-2.0
55
*/
@@ -53,12 +53,9 @@ esp_err_t esp_flash_encryption_enable_secure_features(void)
5353

5454
esp_err_t esp_flash_encryption_enable_key_mgr(void)
5555
{
56-
// Enable and reset key manager
57-
// To suppress build errors about spinlock's __DECLARE_RCC_ATOMIC_ENV
58-
int __DECLARE_RCC_ATOMIC_ENV __attribute__ ((unused));
59-
key_mgr_ll_enable_bus_clock(true);
60-
key_mgr_ll_enable_peripheral_clock(true);
61-
key_mgr_ll_reset_register();
56+
_key_mgr_ll_enable_bus_clock(true);
57+
_key_mgr_ll_enable_peripheral_clock(true);
58+
_key_mgr_ll_reset_register();
6259

6360
while (key_mgr_ll_get_state() != ESP_KEY_MGR_STATE_IDLE) {
6461
};

‎components/esp_hw_support/include/esp_crypto_lock.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
2+
* SPDX-FileCopyrightText: 2023-2025 Espressif Systems (Shanghai) CO LTD
33
*
44
* SPDX-License-Identifier: Apache-2.0
55
*/

‎components/esp_rom/esp32c5/include/esp32c5/rom/key_mgr.h‎

Lines changed: 115 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,115 @@
1+
/*
2+
* SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
3+
*
4+
* SPDX-License-Identifier: Apache-2.0
5+
*/
6+
7+
#pragma once
8+
9+
#include "soc/soc_caps.h"
10+
11+
#if SOC_KEY_MANAGER_SUPPORTED
12+
13+
#include "rom/ets_sys.h"
14+
#include "esp_attr.h"
15+
#include <stdint.h>
16+
#include "rom/km.h"
17+
18+
#if __cplusplus
19+
extern "C" {
20+
#endif
21+
22+
// store huk info, occupy 96 words
23+
struct huk_info {
24+
// store huk info, occupy 165 words
25+
#define HUK_INFO_LEN 660
26+
27+
uint8_t info[HUK_INFO_LEN];
28+
uint32_t crc;
29+
} PACKED_ATTR;
30+
31+
// store key info, occupy 512 bits
32+
struct key_info {
33+
#define KEY_INFO_LEN 64
34+
uint8_t info[KEY_INFO_LEN];
35+
uint32_t crc;
36+
} PACKED_ATTR;
37+
38+
struct huk_key_block {
39+
#define KEY_HUK_SECTOR_MAGIC 0xDEA5CE5A
40+
uint32_t magic;
41+
uint32_t version; // for backward compatibility
42+
uint8_t reserved[16];
43+
struct huk_info huk_info;
44+
struct key_info key_info[2]; // at most 2 key info (XTS-512_1 and XTS-512_2), at least use 1
45+
} WORD_ALIGNED_ATTR PACKED_ATTR;
46+
47+
/*
48+
* We define two info sectors "active" and "backup" here
49+
* Most rom code would rely only on the "active" sector for the key information
50+
*
51+
* But there could be a situation where the huk and key information must be regenerated
52+
* based on ageing and other factors. For that scenario, we need a "backup" sector
53+
*/
54+
#define KEY_HUK_SECTOR_OFFSET(i) ((i)*0x1000)
55+
#define ACTIVE_SECTOR_OFFSET KEY_HUK_SECTOR_OFFSET(0)
56+
#define BACKUP_SECTOR_OFFSET KEY_HUK_SECTOR_OFFSET(1)
57+
58+
#define KM_PERI_ECDSA (BIT(0))
59+
#define KM_PERI_XTS (BIT(1))
60+
61+
struct km_deploy_ops {
62+
#define KM_KEY_PURPOSE_ECDSA_KEY_192 1
63+
#define KM_KEY_PURPOSE_ECDSA_KEY_256 2
64+
#define KM_KEY_PURPOSE_FLASH_XTS_256_1 3
65+
#define KM_KEY_PURPOSE_FLASH_XTS_256_2 4
66+
#define KM_KEY_PURPOSE_FLASH_XTS_128 5
67+
#define KM_KEY_PURPOSE_HMAC 6
68+
#define KM_KEY_PURPOSE_DS 7
69+
#define KM_KEY_PURPOSE_PSRAM_XTS_256_1 8
70+
#define KM_KEY_PURPOSE_PSRAM_XTS_256_2 9
71+
#define KM_KEY_PURPOSE_PSRAM_XTS_128 10
72+
#define KM_KEY_PURPOSE_ECDSA_KEY_384_L 11
73+
#define KM_KEY_PURPOSE_ECDSA_KEY_384_H 12
74+
int km_key_purpose;
75+
#define KM_DEPLOY_MODE_RANDOM 0
76+
#define KM_DEPLOY_MODE_AES 1
77+
#define KM_DEPLOY_MODE_ECDH0 2
78+
#define KM_DEPLOY_MODE_ECDH1 3
79+
#define KM_DEPLOY_MODE_RECOVER 4
80+
#define KM_DEPLOY_MODE_EXPORT 5
81+
int deploy_mode;
82+
uint8_t *init_key; // 256 bits, only used in aes and ecdh1 deploy mode
83+
int deploy_only_once;
84+
int force_use_km_key;
85+
int km_use_efuse_key;
86+
uint32_t efuse_km_rnd_switch_cycle; // 0 means use default
87+
uint32_t km_rnd_switch_cycle; // 0 means use default
88+
int km_use_sw_init_key;
89+
struct huk_info *huk_info;
90+
struct key_info *key_info;
91+
};
92+
93+
/* state of km */
94+
#define KM_STATE_IDLE 0
95+
#define KM_STATE_LOAD 1
96+
#define KM_STATE_GAIN 2
97+
#define KM_STATE_BUSY 3
98+
#define KM_STATE_INVALID 4
99+
100+
/* state of huk generator
101+
* values defined same as km
102+
*/
103+
#define HUK_STATE_IDLE 0
104+
#define HUK_STATE_LOAD 1
105+
#define HUK_STATE_GAIN 2
106+
#define HUK_STATE_BUSY 3
107+
108+
#define HUK_NOT_GENERATED 0
109+
#define HUK_GEN_VALID 1
110+
#define HUK_GEN_INVALID 2
111+
112+
#if __cplusplus
113+
}
114+
#endif
115+
#endif

‎components/esp_security/include/esp_key_mgr.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@ extern "C" {
2222
#define KEY_MGR_ASSIST_INFO_SIZE 64
2323
#define KEY_MGR_KEY_RECOVERY_INFO_SIZE 64
2424

25-
#define KEY_MGR_HUK_INFO_SIZE HUK_INFO_SIZE
25+
#define KEY_MGR_HUK_INFO_SIZE HUK_INFO_LEN
2626
#define KEY_MGR_HUK_RISK_ALERT_LEVEL HUK_RISK_ALERT_LEVEL
2727

2828
/* AES deploy mode */

‎components/esp_security/src/esp_crypto_periph_clk.c‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -141,9 +141,12 @@ void esp_crypto_ecdsa_enable_periph_clk(bool enable)
141141
void esp_crypto_key_mgr_enable_periph_clk(bool enable)
142142
{
143143
KEY_MANAGER_RCC_ATOMIC() {
144+
key_mgr_ll_power_up();
144145
key_mgr_ll_enable_bus_clock(enable);
145146
key_mgr_ll_enable_peripheral_clock(enable);
146-
key_mgr_ll_reset_register();
147+
if (enable) {
148+
key_mgr_ll_reset_register();
149+
}
147150
}
148151
}
149152
#endif

‎components/esp_security/src/esp_key_mgr.c‎

Lines changed: 41 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -44,27 +44,37 @@ ESP_STATIC_ASSERT(sizeof(esp_key_mgr_huk_info_t) == sizeof(struct huk_info), "Si
4444
static void esp_key_mgr_acquire_key_lock(esp_key_mgr_key_type_t key_type)
4545
{
4646
switch (key_type) {
47-
case ESP_KEY_MGR_ECDSA_KEY:
47+
case ESP_KEY_MGR_ECDSA_192_KEY:
48+
case ESP_KEY_MGR_ECDSA_256_KEY:
49+
case ESP_KEY_MGR_ECDSA_384_KEY:
4850
_lock_acquire(&s_key_mgr_ecdsa_key_lock);
4951
break;
5052
case ESP_KEY_MGR_XTS_AES_128_KEY:
5153
case ESP_KEY_MGR_XTS_AES_256_KEY:
5254
_lock_acquire(&s_key_mgr_xts_aes_key_lock);
5355
break;
56+
default:
57+
ESP_LOGE(TAG, "Invalid key type");
58+
break;
5459
}
5560
ESP_LOGV(TAG, "Key lock acquired for key type %d", key_type);
5661
}
5762

5863
static void esp_key_mgr_release_key_lock(esp_key_mgr_key_type_t key_type)
5964
{
6065
switch (key_type) {
61-
case ESP_KEY_MGR_ECDSA_KEY:
66+
case ESP_KEY_MGR_ECDSA_192_KEY:
67+
case ESP_KEY_MGR_ECDSA_256_KEY:
68+
case ESP_KEY_MGR_ECDSA_384_KEY:
6269
_lock_release(&s_key_mgr_ecdsa_key_lock);
6370
break;
6471
case ESP_KEY_MGR_XTS_AES_128_KEY:
6572
case ESP_KEY_MGR_XTS_AES_256_KEY:
6673
_lock_release(&s_key_mgr_xts_aes_key_lock);
6774
break;
75+
default:
76+
ESP_LOGE(TAG, "Invalid key type");
77+
break;
6878
}
6979
ESP_LOGV(TAG, "Key lock released for key type %d", key_type);
7080
}
@@ -223,7 +233,7 @@ static esp_err_t key_mgr_deploy_key_aes_mode(aes_deploy_config_t *config)
223233
if (!key_recovery_info) {
224234
return ESP_ERR_NO_MEM;
225235
}
226-
// Set key purpose (XTS/ECDSA)
236+
// Set key purpose
227237
ESP_LOGD(TAG, "Key purpose = %d", config->key_purpose);
228238
key_mgr_hal_set_key_purpose(config->key_purpose);
229239

@@ -238,12 +248,10 @@ static esp_err_t key_mgr_deploy_key_aes_mode(aes_deploy_config_t *config)
238248

239249
if (config->key_config->use_pre_generated_sw_init_key) {
240250
key_mgr_hal_use_sw_init_key();
241-
} else {
242-
if (!esp_efuse_find_purpose(ESP_EFUSE_KEY_PURPOSE_KM_INIT_KEY, NULL)) {
243-
ESP_LOGE(TAG, "Could not find key with purpose KM_INIT_KEY");
244-
heap_caps_free(key_recovery_info);
245-
return ESP_FAIL;
246-
}
251+
} else if (!esp_efuse_find_purpose(ESP_EFUSE_KEY_PURPOSE_KM_INIT_KEY, NULL)) {
252+
ESP_LOGE(TAG, "Could not find key with purpose KM_INIT_KEY");
253+
heap_caps_free(key_recovery_info);
254+
return ESP_FAIL;
247255
}
248256

249257
key_mgr_hal_start();
@@ -306,8 +314,10 @@ esp_err_t esp_key_mgr_deploy_key_in_aes_mode(const esp_key_mgr_aes_key_config_t
306314
aes_deploy_config.k1_encrypted = key_config->k1_encrypted[0];
307315

308316
esp_key_mgr_key_type_t key_type = (esp_key_mgr_key_type_t) key_config->key_type;
309-
if (key_type == ESP_KEY_MGR_ECDSA_KEY) {
310-
aes_deploy_config.key_purpose = ESP_KEY_MGR_KEY_PURPOSE_ECDSA;
317+
if (key_type == ESP_KEY_MGR_ECDSA_192_KEY) {
318+
aes_deploy_config.key_purpose = ESP_KEY_MGR_KEY_PURPOSE_ECDSA_192;
319+
} else if (key_type == ESP_KEY_MGR_ECDSA_256_KEY) {
320+
aes_deploy_config.key_purpose = ESP_KEY_MGR_KEY_PURPOSE_ECDSA_256;
311321
} else if (key_type == ESP_KEY_MGR_XTS_AES_128_KEY) {
312322
aes_deploy_config.key_purpose = ESP_KEY_MGR_KEY_PURPOSE_XTS_AES_128;
313323
} else if (key_type == ESP_KEY_MGR_XTS_AES_256_KEY) {
@@ -424,10 +434,12 @@ esp_err_t esp_key_mgr_activate_key(esp_key_mgr_key_recovery_info_t *key_recovery
424434
}
425435

426436
esp_key_mgr_key_purpose_t key_purpose;
427-
ESP_LOGD(TAG, "Activating key of type %d", key_recovery_info->key_type);
437+
ESP_LOGI(TAG, "Activating key of type %d", key_recovery_info->key_type);
428438
esp_key_mgr_key_type_t key_type = (esp_key_mgr_key_type_t) key_recovery_info->key_type;
429-
if (key_type == ESP_KEY_MGR_ECDSA_KEY) {
430-
key_purpose = ESP_KEY_MGR_KEY_PURPOSE_ECDSA;
439+
if (key_type == ESP_KEY_MGR_ECDSA_192_KEY) {
440+
key_purpose = ESP_KEY_MGR_KEY_PURPOSE_ECDSA_192;
441+
} else if (key_type == ESP_KEY_MGR_ECDSA_256_KEY) {
442+
key_purpose = ESP_KEY_MGR_KEY_PURPOSE_ECDSA_256;
431443
} else if (key_type == ESP_KEY_MGR_XTS_AES_128_KEY) {
432444
key_purpose = ESP_KEY_MGR_KEY_PURPOSE_XTS_AES_128;
433445
} else if (key_type == ESP_KEY_MGR_XTS_AES_256_KEY) {
@@ -438,6 +450,7 @@ esp_err_t esp_key_mgr_activate_key(esp_key_mgr_key_recovery_info_t *key_recovery
438450
}
439451

440452
esp_err_t esp_ret = ESP_FAIL;
453+
ESP_LOGI(TAG, "Activating key of type %d", key_recovery_info->key_type);
441454
esp_key_mgr_acquire_key_lock(key_type);
442455
key_recovery_config_t key_recovery_config = {};
443456
key_recovery_config.key_recovery_info = key_recovery_info;
@@ -448,6 +461,7 @@ esp_err_t esp_key_mgr_activate_key(esp_key_mgr_key_recovery_info_t *key_recovery
448461
esp_ret = key_mgr_recover_key(&key_recovery_config);
449462
if (esp_ret != ESP_OK) {
450463
ESP_LOGE(TAG, "Failed to recover key");
464+
esp_key_mgr_release_key_lock(key_type);
451465
goto cleanup;
452466
}
453467

@@ -456,13 +470,15 @@ esp_err_t esp_key_mgr_activate_key(esp_key_mgr_key_recovery_info_t *key_recovery
456470
esp_ret = key_mgr_recover_key(&key_recovery_config);
457471
if (esp_ret != ESP_OK) {
458472
ESP_LOGE(TAG, "Failed to recover key");
473+
esp_key_mgr_release_key_lock(key_type);
459474
goto cleanup;
460475
}
461476
}
462477

463478
// Set the Key Manager Static Register to use own key for the respective key type
464-
key_mgr_hal_set_key_usage(key_recovery_info->key_type, ESP_KEY_MGR_USE_OWN_KEY);
479+
key_mgr_hal_set_key_usage(key_type, ESP_KEY_MGR_USE_OWN_KEY);
465480
ESP_LOGI(TAG, "Key activation for type %d successful", key_recovery_info->key_type);
481+
esp_key_mgr_release_key_lock(key_type);
466482
return ESP_OK;
467483

468484
cleanup:
@@ -585,8 +601,11 @@ esp_err_t esp_key_mgr_deploy_key_in_ecdh0_mode(const esp_key_mgr_ecdh0_key_confi
585601
ecdh0_deploy_config.key_info = key_info;
586602
ecdh0_deploy_config.k1_G = key_config->k1_G[0];
587603

588-
if (key_type == ESP_KEY_MGR_ECDSA_KEY) {
589-
ecdh0_deploy_config.key_purpose = ESP_KEY_MGR_KEY_PURPOSE_ECDSA;
604+
if (key_type == ESP_KEY_MGR_ECDSA_192_KEY) {
605+
ecdh0_deploy_config.key_purpose = ESP_KEY_MGR_KEY_PURPOSE_ECDSA_192;
606+
ecdh0_deploy_config.ecdh0_key_info = ecdh0_key_info->k2_G[0];
607+
} else if (key_type == ESP_KEY_MGR_ECDSA_256_KEY) {
608+
ecdh0_deploy_config.key_purpose = ESP_KEY_MGR_KEY_PURPOSE_ECDSA_256;
590609
ecdh0_deploy_config.ecdh0_key_info = ecdh0_key_info->k2_G[0];
591610
} else if (key_type == ESP_KEY_MGR_XTS_AES_128_KEY) {
592611
ecdh0_deploy_config.key_purpose = ESP_KEY_MGR_KEY_PURPOSE_XTS_AES_128;
@@ -718,8 +737,10 @@ esp_err_t esp_key_mgr_deploy_key_in_random_mode(const esp_key_mgr_random_key_con
718737
random_deploy_config.key_info = key_recovery_info;
719738
esp_key_mgr_key_type_t key_type = (esp_key_mgr_key_type_t) key_config->key_type;
720739

721-
if (key_type == ESP_KEY_MGR_ECDSA_KEY) {
722-
random_deploy_config.key_purpose = ESP_KEY_MGR_KEY_PURPOSE_ECDSA;
740+
if (key_type == ESP_KEY_MGR_ECDSA_192_KEY) {
741+
random_deploy_config.key_purpose = ESP_KEY_MGR_KEY_PURPOSE_ECDSA_192;
742+
} else if (key_type == ESP_KEY_MGR_ECDSA_256_KEY) {
743+
random_deploy_config.key_purpose = ESP_KEY_MGR_KEY_PURPOSE_ECDSA_256;
723744
} else if (key_type == ESP_KEY_MGR_XTS_AES_128_KEY) {
724745
random_deploy_config.key_purpose = ESP_KEY_MGR_KEY_PURPOSE_XTS_AES_128;
725746
} else if (key_type == ESP_KEY_MGR_XTS_AES_256_KEY) {
@@ -748,7 +769,7 @@ esp_err_t esp_key_mgr_deploy_key_in_random_mode(const esp_key_mgr_random_key_con
748769
}
749770

750771
// Set the Key Manager Static Register to use own key for the respective key type
751-
key_mgr_hal_set_key_usage(key_config->key_type, ESP_KEY_MGR_USE_OWN_KEY);
772+
key_mgr_hal_set_key_usage(key_type, ESP_KEY_MGR_USE_OWN_KEY);
752773

753774
esp_key_mgr_release_hardware(true);
754775
return esp_ret;

‎components/esp_security/test_apps/crypto_drivers/main/test_key_mgr.c‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -138,7 +138,7 @@ TEST_CASE("Key Manager random mode: ECDSA key deployment", "[hw_crypto] [key_mgr
138138
static esp_key_mgr_random_key_config_t key_config;
139139
static esp_key_mgr_key_recovery_info_t key_info;
140140
esp_err_t esp_ret = ESP_FAIL;
141-
key_config.key_type = ESP_KEY_MGR_ECDSA_KEY;
141+
key_config.key_type = ESP_KEY_MGR_ECDSA_256_KEY;
142142
esp_ret = esp_key_mgr_deploy_key_in_random_mode(&key_config, &key_info);
143143
TEST_ASSERT_EQUAL(ESP_OK, esp_ret);
144144
}

‎components/hal/ecdsa_hal.c‎

Lines changed: 11 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@
1616
#endif
1717

1818
#ifdef SOC_KEY_MANAGER_ECDSA_KEY_DEPLOY
19-
#include "hal/key_mgr_ll.h"
19+
#include "hal/key_mgr_hal.h"
2020
#endif
2121

2222
#define ECDSA_HAL_P192_COMPONENT_LEN 24
@@ -30,12 +30,20 @@ static void configure_ecdsa_periph(ecdsa_hal_config_t *conf)
3030

3131
#if SOC_KEY_MANAGER_ECDSA_KEY_DEPLOY
3232
// Force Key Manager to use eFuse key for XTS-AES operation
33-
key_mgr_ll_set_key_usage(ESP_KEY_MGR_ECDSA_KEY, ESP_KEY_MGR_USE_EFUSE_KEY);
33+
if (conf->curve == ECDSA_CURVE_SECP192R1) {
34+
key_mgr_hal_set_key_usage(ESP_KEY_MGR_ECDSA_192_KEY, ESP_KEY_MGR_USE_EFUSE_KEY);
35+
} else {
36+
key_mgr_hal_set_key_usage(ESP_KEY_MGR_ECDSA_256_KEY, ESP_KEY_MGR_USE_EFUSE_KEY);
37+
}
3438
#endif
3539
}
3640
#if SOC_KEY_MANAGER_SUPPORTED
3741
else {
38-
key_mgr_ll_set_key_usage(ESP_KEY_MGR_ECDSA_KEY, ESP_KEY_MGR_USE_OWN_KEY);
42+
if (conf->curve == ECDSA_CURVE_SECP192R1) {
43+
key_mgr_hal_set_key_usage(ESP_KEY_MGR_ECDSA_192_KEY, ESP_KEY_MGR_USE_OWN_KEY);
44+
} else {
45+
key_mgr_hal_set_key_usage(ESP_KEY_MGR_ECDSA_256_KEY, ESP_KEY_MGR_USE_OWN_KEY);
46+
}
3947
}
4048
#endif
4149

0 commit comments

Comments
 (0)