components/bootloader_support/src/flash_encrypt.c

   1 // Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
   2 //
   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
   6
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   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.
  14
  15 #include <strings.h>
  16
  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"
  25 #include "esp_log.h"
  26 #include "rom/secure_boot.h"
  27
  28 #include "rom/cache.h"
  29 #include "rom/spi_flash.h"   /* TODO: Remove this */
  30
  31 static const char *TAG = "flash_encrypt";
  32
  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);
  39
  40 esp_err_t esp_flash_encrypt_check_and_update(void)
  41 {
  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);
  47
  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 */
  53         }
  54         ESP_LOGI(TAG, "flash encryption is enabled (%d plaintext flashes left)", left);
  55         return ESP_OK;
  56     }
  57     else {
  58         /* Flash is not encrypted, so encrypt it! */
  59         return encrypt_flash_contents(flash_crypt_cnt, flash_crypt_wr_dis);
  60     }
  61 }
  62
  63 static esp_err_t initialise_flash_encryption(void)
  64 {
  65     /* Before first flash encryption pass, need to initialise key & crypto config */
  66
  67     /* Generate key */
  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...");
  82         uint32_t buf[8];
  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]);
  87         }
  88         bzero(buf, sizeof(buf));
  89         esp_efuse_burn_new_values();
  90
  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();
  94     } else {
  95
  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;
  99         }
 100         ESP_LOGW(TAG, "Using pre-loaded flash encryption key in EFUSE block 1");
 101     }
 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.
 104
 105        CRYPT_CONFIG == 0 is effectively AES ECB mode (NOT SUPPORTED)
 106
 107        For now this is hardcoded to XOR all 256 bits of the key.
 108
 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!
 112     */
 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();
 116
 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;
 121 #else
 122     ESP_LOGW(TAG, "Not disabling UART bootloader encryption");
 123 #endif
 124 #ifndef CONFIG_FLASH_ENCRYPTION_UART_BOOTLOADER_ALLOW_DECRYPT
 125     ESP_LOGI(TAG, "Disable UART bootloader decryption...");
 126     new_wdata6 |= EFUSE_DISABLE_DL_DECRYPT;
 127 #else
 128     ESP_LOGW(TAG, "Not disabling UART bootloader decryption - SECURITY COMPROMISED");
 129 #endif
 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;
 133 #else
 134     ESP_LOGW(TAG, "Not disabling UART bootloader MMU cache - SECURITY COMPROMISED");
 135 #endif
 136 #ifndef CONFIG_SECURE_BOOT_ALLOW_JTAG
 137     ESP_LOGI(TAG, "Disable JTAG...");
 138     new_wdata6 |= EFUSE_RD_DISABLE_JTAG;
 139 #else
 140     ESP_LOGW(TAG, "Not disabling JTAG - SECURITY COMPROMISED");
 141 #endif
 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;
 145 #else
 146     ESP_LOGW(TAG, "Not disabling ROM BASIC fallback - SECURITY COMPROMISED");
 147 #endif
 148
 149     if (new_wdata6 != 0) {
 150         REG_WRITE(EFUSE_BLK0_WDATA6_REG, new_wdata6);
 151         esp_efuse_burn_new_values();
 152     }
 153
 154     return ESP_OK;
 155 }
 156
 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)
 159 {
 160     esp_err_t err;
 161     esp_partition_info_t partition_table[ESP_PARTITION_TABLE_MAX_ENTRIES];
 162     int num_partitions;
 163
 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);
 168         return ESP_FAIL;
 169     }
 170
 171     if (flash_crypt_cnt == 0) {
 172         /* Very first flash of encrypted data: generate keys, etc. */
 173         err = initialise_flash_encryption();
 174         if (err != ESP_OK) {
 175             return err;
 176         }
 177     }
 178
 179     err = encrypt_bootloader();
 180     if (err != ESP_OK) {
 181         return err;
 182     }
 183
 184     err = encrypt_and_load_partition_table(partition_table, &num_partitions);
 185     if (err != ESP_OK) {
 186         return err;
 187     }
 188
 189     /* Now iterate the just-loaded partition table, looking for entries to encrypt
 190      */
 191
 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]);
 195         if (err != ESP_OK) {
 196             return err;
 197         }
 198     }
 199
 200     ESP_LOGD(TAG, "All flash regions checked for encryption pass");
 201
 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();
 209
 210     ESP_LOGI(TAG, "Flash encryption completed");
 211
 212     return ESP_OK;
 213 }
 214
 215 static esp_err_t encrypt_bootloader()
 216 {
 217     esp_err_t err;
 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);
 223         if (err != ESP_OK) {
 224             ESP_LOGE(TAG, "Failed to encrypt bootloader in place: 0x%x", err);
 225             return err;
 226         }
 227
 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.
 231             */
 232             ESP_LOGD(TAG, "Encrypting secure bootloader IV & digest...");
 233             err = esp_flash_encrypt_region(FLASH_OFFS_SECURE_BOOT_IV_DIGEST,
 234                                            FLASH_SECTOR_SIZE);
 235             if (err != ESP_OK) {
 236                 ESP_LOGE(TAG, "Failed to encrypt bootloader IV & digest in place: 0x%x", err);
 237                 return err;
 238             }
 239         }
 240     }
 241     else {
 242         ESP_LOGW(TAG, "no valid bootloader was found");
 243     }
 244
 245     return ESP_OK;
 246 }
 247
 248 static esp_err_t encrypt_and_load_partition_table(esp_partition_info_t *partition_table, int *num_partitions)
 249 {
 250     esp_err_t err;
 251     /* Check for plaintext partition table */
 252     err = bootloader_flash_read(ESP_PARTITION_TABLE_OFFSET, partition_table, ESP_PARTITION_TABLE_MAX_LEN, false);
 253     if (err != ESP_OK) {
 254         ESP_LOGE(TAG, "Failed to read partition table data");
 255         return err;
 256     }
 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,
 260                                                  FLASH_SECTOR_SIZE);
 261         if (err != ESP_OK) {
 262             ESP_LOGE(TAG, "Failed to encrypt partition table in place. %x", err);
 263             return err;
 264         }
 265     }
 266     else {
 267         ESP_LOGE(TAG, "Failed to read partition table data - not plaintext?");
 268         return ESP_ERR_INVALID_STATE;
 269     }
 270
 271     /* Valid partition table loded */
 272     return ESP_OK;
 273 }
 274
 275
 276 static esp_err_t encrypt_partition(int index, const esp_partition_info_t *partition)
 277 {
 278     esp_err_t err;
 279     bool should_encrypt = (partition->flags & PART_FLAG_ENCRYPTED);
 280
 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,
 285                            &partition->pos,
 286                            &data_ignored);
 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;
 291     }
 292
 293     if (!should_encrypt) {
 294         return ESP_OK;
 295     }
 296     else {
 297         /* should_encrypt */
 298         ESP_LOGI(TAG, "Encrypting partition %d at offset 0x%x...", index, partition->pos.offset);
 299
 300         err = esp_flash_encrypt_region(partition->pos.offset, partition->pos.size);
 301         if (err != ESP_OK) {
 302             ESP_LOGE(TAG, "Failed to encrypt partition %d", index);
 303         }
 304         return err;
 305     }
 306 }
 307
 308
 309 esp_err_t esp_flash_encrypt_region(uint32_t src_addr, size_t data_length)
 310 {
 311     esp_err_t err;
 312     uint32_t buf[FLASH_SECTOR_SIZE / sizeof(uint32_t)];
 313
 314     if (src_addr % FLASH_SECTOR_SIZE != 0) {
 315         ESP_LOGE(TAG, "esp_flash_encrypt_region bad src_addr 0x%x",src_addr);
 316         return ESP_FAIL;
 317     }
 318
 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);
 322         if (err != ESP_OK) {
 323             goto flash_failed;
 324         }
 325         err = bootloader_flash_erase_sector(sec_start / FLASH_SECTOR_SIZE);
 326         if (err != ESP_OK) {
 327             goto flash_failed;
 328         }
 329         err = bootloader_flash_write(sec_start, buf, FLASH_SECTOR_SIZE, true);
 330         if (err != ESP_OK) {
 331             goto flash_failed;
 332         }
 333     }
 334     return ESP_OK;
 335
 336  flash_failed:
 337     ESP_LOGE(TAG, "flash operation failed: 0x%x", err);
 338     return err;
 339 }