1 // Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
7 // http://www.apache.org/licenses/LICENSE-2.0
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
17 #include "bootloader_flash.h"
18 #include "bootloader_random.h"
19 #include "esp_image_format.h"
20 #include "esp_flash_encrypt.h"
21 #include "esp_flash_partitions.h"
22 #include "esp_flash_data_types.h"
23 #include "esp_secure_boot.h"
24 #include "esp_efuse.h"
26 #include "rom/secure_boot.h"
28 #include "rom/cache.h"
29 #include "rom/spi_flash.h" /* TODO: Remove this */
31 static const char *TAG
= "flash_encrypt";
33 /* Static functions for stages of flash encryption */
34 static esp_err_t
initialise_flash_encryption(void);
35 static esp_err_t
encrypt_flash_contents(uint32_t flash_crypt_cnt
, bool flash_crypt_wr_dis
);
36 static esp_err_t
encrypt_bootloader();
37 static esp_err_t
encrypt_and_load_partition_table(esp_partition_info_t
*partition_table
, int *num_partitions
);
38 static esp_err_t
encrypt_partition(int index
, const esp_partition_info_t
*partition
);
40 esp_err_t
esp_flash_encrypt_check_and_update(void)
42 uint32_t efuse_blk0
= REG_READ(EFUSE_BLK0_RDATA0_REG
);
43 ESP_LOGV(TAG
, "efuse_blk0 raw value %08x", efuse_blk0
);
44 uint32_t flash_crypt_cnt
= (efuse_blk0
& EFUSE_RD_FLASH_CRYPT_CNT_M
) >> EFUSE_RD_FLASH_CRYPT_CNT_S
;
45 bool flash_crypt_wr_dis
= efuse_blk0
& EFUSE_WR_DIS_FLASH_CRYPT_CNT
;
46 ESP_LOGV(TAG
, "efuse FLASH_CRYPT_CNT 0x%x WR_DIS_FLASH_CRYPT_CNT 0x%x", flash_crypt_cnt
, flash_crypt_wr_dis
);
48 if (__builtin_parity(flash_crypt_cnt
) == 1) {
49 /* Flash is already encrypted */
50 int left
= (7 - __builtin_popcount(flash_crypt_cnt
)) / 2;
51 if (flash_crypt_wr_dis
) {
52 left
= 0; /* can't update FLASH_CRYPT_CNT, no more flashes */
54 ESP_LOGI(TAG
, "flash encryption is enabled (%d plaintext flashes left)", left
);
58 /* Flash is not encrypted, so encrypt it! */
59 return encrypt_flash_contents(flash_crypt_cnt
, flash_crypt_wr_dis
);
63 static esp_err_t
initialise_flash_encryption(void)
65 /* Before first flash encryption pass, need to initialise key & crypto config */
68 uint32_t dis_reg
= REG_READ(EFUSE_BLK0_RDATA0_REG
);
69 bool efuse_key_read_protected
= dis_reg
& EFUSE_RD_DIS_BLK1
;
70 bool efuse_key_write_protected
= dis_reg
& EFUSE_WR_DIS_BLK1
;
71 if (efuse_key_read_protected
== false
72 && efuse_key_write_protected
== false
73 && REG_READ(EFUSE_BLK1_RDATA0_REG
) == 0
74 && REG_READ(EFUSE_BLK1_RDATA1_REG
) == 0
75 && REG_READ(EFUSE_BLK1_RDATA2_REG
) == 0
76 && REG_READ(EFUSE_BLK1_RDATA3_REG
) == 0
77 && REG_READ(EFUSE_BLK1_RDATA4_REG
) == 0
78 && REG_READ(EFUSE_BLK1_RDATA5_REG
) == 0
79 && REG_READ(EFUSE_BLK1_RDATA6_REG
) == 0
80 && REG_READ(EFUSE_BLK1_RDATA7_REG
) == 0) {
81 ESP_LOGI(TAG
, "Generating new flash encryption key...");
83 bootloader_fill_random(buf
, sizeof(buf
));
84 for (int i
= 0; i
< 8; i
++) {
85 ESP_LOGV(TAG
, "EFUSE_BLK1_WDATA%d_REG = 0x%08x", i
, buf
[i
]);
86 REG_WRITE(EFUSE_BLK1_WDATA0_REG
+ 4*i
, buf
[i
]);
88 bzero(buf
, sizeof(buf
));
89 esp_efuse_burn_new_values();
91 ESP_LOGI(TAG
, "Read & write protecting new key...");
92 REG_WRITE(EFUSE_BLK0_WDATA0_REG
, EFUSE_WR_DIS_BLK1
| EFUSE_RD_DIS_BLK1
);
93 esp_efuse_burn_new_values();
96 if(!(efuse_key_read_protected
&& efuse_key_write_protected
)) {
97 ESP_LOGE(TAG
, "Flash encryption key has to be either unset or both read and write protected");
98 return ESP_ERR_INVALID_STATE
;
100 ESP_LOGW(TAG
, "Using pre-loaded flash encryption key in EFUSE block 1");
102 /* CRYPT_CONFIG determines which bits of the AES block key are XORed
103 with bits from the flash address, to provide the key tweak.
105 CRYPT_CONFIG == 0 is effectively AES ECB mode (NOT SUPPORTED)
107 For now this is hardcoded to XOR all 256 bits of the key.
109 If you need to override it, you can pre-burn this efuse to the
110 desired value and then write-protect it, in which case this
111 operation does nothing. Please note this is not recommended!
113 ESP_LOGI(TAG
, "Setting CRYPT_CONFIG efuse to 0xF");
114 REG_WRITE(EFUSE_BLK0_WDATA5_REG
, EFUSE_FLASH_CRYPT_CONFIG_M
);
115 esp_efuse_burn_new_values();
117 uint32_t new_wdata6
= 0;
118 #ifndef CONFIG_FLASH_ENCRYPTION_UART_BOOTLOADER_ALLOW_ENCRYPT
119 ESP_LOGI(TAG
, "Disable UART bootloader encryption...");
120 new_wdata6
|= EFUSE_DISABLE_DL_ENCRYPT
;
122 ESP_LOGW(TAG
, "Not disabling UART bootloader encryption");
124 #ifndef CONFIG_FLASH_ENCRYPTION_UART_BOOTLOADER_ALLOW_DECRYPT
125 ESP_LOGI(TAG
, "Disable UART bootloader decryption...");
126 new_wdata6
|= EFUSE_DISABLE_DL_DECRYPT
;
128 ESP_LOGW(TAG
, "Not disabling UART bootloader decryption - SECURITY COMPROMISED");
130 #ifndef CONFIG_FLASH_ENCRYPTION_UART_BOOTLOADER_ALLOW_CACHE
131 ESP_LOGI(TAG
, "Disable UART bootloader MMU cache...");
132 new_wdata6
|= EFUSE_DISABLE_DL_CACHE
;
134 ESP_LOGW(TAG
, "Not disabling UART bootloader MMU cache - SECURITY COMPROMISED");
136 #ifndef CONFIG_SECURE_BOOT_ALLOW_JTAG
137 ESP_LOGI(TAG
, "Disable JTAG...");
138 new_wdata6
|= EFUSE_RD_DISABLE_JTAG
;
140 ESP_LOGW(TAG
, "Not disabling JTAG - SECURITY COMPROMISED");
142 #ifndef CONFIG_SECURE_BOOT_ALLOW_ROM_BASIC
143 ESP_LOGI(TAG
, "Disable ROM BASIC interpreter fallback...");
144 new_wdata6
|= EFUSE_RD_CONSOLE_DEBUG_DISABLE
;
146 ESP_LOGW(TAG
, "Not disabling ROM BASIC fallback - SECURITY COMPROMISED");
149 if (new_wdata6
!= 0) {
150 REG_WRITE(EFUSE_BLK0_WDATA6_REG
, new_wdata6
);
151 esp_efuse_burn_new_values();
157 /* Encrypt all flash data that should be encrypted */
158 static esp_err_t
encrypt_flash_contents(uint32_t flash_crypt_cnt
, bool flash_crypt_wr_dis
)
161 esp_partition_info_t partition_table
[ESP_PARTITION_TABLE_MAX_ENTRIES
];
164 /* If the last flash_crypt_cnt bit is burned or write-disabled, the
165 device can't re-encrypt itself. */
166 if (flash_crypt_wr_dis
|| flash_crypt_cnt
== 0xFF) {
167 ESP_LOGE(TAG
, "Cannot re-encrypt data (FLASH_CRYPT_CNT 0x%02x write disabled %d", flash_crypt_cnt
, flash_crypt_wr_dis
);
171 if (flash_crypt_cnt
== 0) {
172 /* Very first flash of encrypted data: generate keys, etc. */
173 err
= initialise_flash_encryption();
179 err
= encrypt_bootloader();
184 err
= encrypt_and_load_partition_table(partition_table
, &num_partitions
);
189 /* Now iterate the just-loaded partition table, looking for entries to encrypt
192 /* Go through each partition and encrypt if necessary */
193 for (int i
= 0; i
< num_partitions
; i
++) {
194 err
= encrypt_partition(i
, &partition_table
[i
]);
200 ESP_LOGD(TAG
, "All flash regions checked for encryption pass");
202 /* Set least significant 0-bit in flash_crypt_cnt */
203 int ffs_inv
= __builtin_ffs((~flash_crypt_cnt
) & 0xFF);
204 /* ffs_inv shouldn't be zero, as zero implies flash_crypt_cnt == 0xFF */
205 uint32_t new_flash_crypt_cnt
= flash_crypt_cnt
+ (1 << (ffs_inv
- 1));
206 ESP_LOGD(TAG
, "FLASH_CRYPT_CNT 0x%x -> 0x%x", flash_crypt_cnt
, new_flash_crypt_cnt
);
207 REG_SET_FIELD(EFUSE_BLK0_WDATA0_REG
, EFUSE_FLASH_CRYPT_CNT
, new_flash_crypt_cnt
);
208 esp_efuse_burn_new_values();
210 ESP_LOGI(TAG
, "Flash encryption completed");
215 static esp_err_t
encrypt_bootloader()
218 uint32_t image_length
;
219 /* Check for plaintext bootloader (verification will fail if it's already encrypted) */
220 if (esp_image_verify_bootloader(&image_length
) == ESP_OK
) {
221 ESP_LOGD(TAG
, "bootloader is plaintext. Encrypting...");
222 err
= esp_flash_encrypt_region(ESP_BOOTLOADER_OFFSET
, image_length
);
224 ESP_LOGE(TAG
, "Failed to encrypt bootloader in place: 0x%x", err
);
228 if (esp_secure_boot_enabled()) {
229 /* If secure boot is enabled and bootloader was plaintext, also
230 need to encrypt secure boot IV+digest.
232 ESP_LOGD(TAG
, "Encrypting secure bootloader IV & digest...");
233 err
= esp_flash_encrypt_region(FLASH_OFFS_SECURE_BOOT_IV_DIGEST
,
236 ESP_LOGE(TAG
, "Failed to encrypt bootloader IV & digest in place: 0x%x", err
);
242 ESP_LOGW(TAG
, "no valid bootloader was found");
248 static esp_err_t
encrypt_and_load_partition_table(esp_partition_info_t
*partition_table
, int *num_partitions
)
251 /* Check for plaintext partition table */
252 err
= bootloader_flash_read(ESP_PARTITION_TABLE_OFFSET
, partition_table
, ESP_PARTITION_TABLE_MAX_LEN
, false);
254 ESP_LOGE(TAG
, "Failed to read partition table data");
257 if (esp_partition_table_basic_verify(partition_table
, false, num_partitions
) == ESP_OK
) {
258 ESP_LOGD(TAG
, "partition table is plaintext. Encrypting...");
259 esp_err_t err
= esp_flash_encrypt_region(ESP_PARTITION_TABLE_OFFSET
,
262 ESP_LOGE(TAG
, "Failed to encrypt partition table in place. %x", err
);
267 ESP_LOGE(TAG
, "Failed to read partition table data - not plaintext?");
268 return ESP_ERR_INVALID_STATE
;
271 /* Valid partition table loded */
276 static esp_err_t
encrypt_partition(int index
, const esp_partition_info_t
*partition
)
279 bool should_encrypt
= (partition
->flags
& PART_FLAG_ENCRYPTED
);
281 if (partition
->type
== PART_TYPE_APP
) {
282 /* check if the partition holds a valid unencrypted app */
283 esp_image_metadata_t data_ignored
;
284 err
= esp_image_load(ESP_IMAGE_VERIFY
,
287 should_encrypt
= (err
== ESP_OK
);
288 } else if (partition
->type
== PART_TYPE_DATA
&& partition
->subtype
== PART_SUBTYPE_DATA_OTA
) {
289 /* check if we have ota data partition and the partition should be encrypted unconditionally */
290 should_encrypt
= true;
293 if (!should_encrypt
) {
298 ESP_LOGI(TAG
, "Encrypting partition %d at offset 0x%x...", index
, partition
->pos
.offset
);
300 err
= esp_flash_encrypt_region(partition
->pos
.offset
, partition
->pos
.size
);
302 ESP_LOGE(TAG
, "Failed to encrypt partition %d", index
);
309 esp_err_t
esp_flash_encrypt_region(uint32_t src_addr
, size_t data_length
)
312 uint32_t buf
[FLASH_SECTOR_SIZE
/ sizeof(uint32_t)];
314 if (src_addr
% FLASH_SECTOR_SIZE
!= 0) {
315 ESP_LOGE(TAG
, "esp_flash_encrypt_region bad src_addr 0x%x",src_addr
);
319 for (size_t i
= 0; i
< data_length
; i
+= FLASH_SECTOR_SIZE
) {
320 uint32_t sec_start
= i
+ src_addr
;
321 err
= bootloader_flash_read(sec_start
, buf
, FLASH_SECTOR_SIZE
, false);
325 err
= bootloader_flash_erase_sector(sec_start
/ FLASH_SECTOR_SIZE
);
329 err
= bootloader_flash_write(sec_start
, buf
, FLASH_SECTOR_SIZE
, true);
337 ESP_LOGE(TAG
, "flash operation failed: 0x%x", err
);