Flash encryption: Support enabling flash encryption in bootloader, app support

* App access functions are all flash encryption-aware
* Documentation for flash encryption
* Partition read/write is flash aware
* New encrypted write function

components/bootloader_support/src/bootloader_flash.c

@@ -46,38 +46,68 @@ void bootloader_munmap(const void *mapping)
     map = 0;
 }
 
-esp_err_t bootloader_flash_read(size_t src, void *dest, size_t size)
+esp_err_t bootloader_flash_read(size_t src, void *dest, size_t size, bool allow_decrypt)
 {
     return spi_flash_read(src, dest, size);
 }
 
+esp_err_t bootloader_flash_write(size_t dest_addr, void *src, size_t size, bool write_encrypted)
+{
+    if (write_encrypted) {
+        return spi_flash_write_encrypted(dest_addr, src, size);
+    } else {
+        return spi_flash_write(dest_addr, src, size);
+    }
+}
+
+esp_err_t bootloader_flash_erase_sector(size_t sector)
+{
+    return spi_flash_erase_sector(sector);
+}
+
 #else
 /* Bootloader version, uses ROM functions only */
+#include <soc/dport_reg.h>
 #include <rom/spi_flash.h>
 #include <rom/cache.h>
 
 static const char *TAG = "bootloader_flash";
 
+/* Use first 50 blocks in MMU for bootloader_mmap,
+   50th block for bootloader_flash_read
+*/
+#define MMU_BLOCK0_VADDR  0x3f400000
+#define MMU_BLOCK50_VADDR 0x3f720000
+#define MMU_FLASH_MASK    0xffff0000
+#define MMU_BLOCK_SIZE    0x00010000
+
 static bool mapped;
 
+static uint32_t current_read_mapping = UINT32_MAX;
+
 const void *bootloader_mmap(uint32_t src_addr, uint32_t size)
 {
     if (mapped) {
         ESP_LOGE(TAG, "tried to bootloader_mmap twice");
         return NULL; /* can't map twice */
     }
+    if (size > 0x320000) {
+        /* Allow mapping up to 50 of the 51 available MMU blocks (last one used for reads) */
+        ESP_LOGE(TAG, "bootloader_mmap excess size %x", size);
+        return NULL;
+    }
 
-    uint32_t src_addr_aligned = src_addr & 0xffff0000;
-    uint32_t count = (size + (src_addr - src_addr_aligned) + 0xffff) / 0x10000;
+    uint32_t src_addr_aligned = src_addr & MMU_FLASH_MASK;
+    uint32_t count = (size + (src_addr - src_addr_aligned) + 0xffff) / MMU_BLOCK_SIZE;
     Cache_Read_Disable(0);
     Cache_Flush(0);
     ESP_LOGD(TAG, "mmu set paddr=%08x count=%d", src_addr_aligned, count );
-    cache_flash_mmu_set( 0, 0, 0x3f400000, src_addr_aligned, 64, count );
+    cache_flash_mmu_set( 0, 0, MMU_BLOCK0_VADDR, src_addr_aligned, 64, count );
     Cache_Read_Enable( 0 );
 
     mapped = true;
 
-    return (void *)(0x3f400000 + (src_addr - src_addr_aligned));
+    return (void *)(MMU_BLOCK0_VADDR + (src_addr - src_addr_aligned));
 }
 
 void bootloader_munmap(const void *mapping)
@@ -88,25 +118,12 @@ void bootloader_munmap(const void *mapping)
         Cache_Flush(0);
         mmu_init(0);
         mapped = false;
+        current_read_mapping = UINT32_MAX;
     }
 }
 
-esp_err_t bootloader_flash_read(size_t src_addr, void *dest, size_t size)
+static esp_err_t spi_to_esp_err(SpiFlashOpResult r)
 {
-    if(src_addr & 3) {
-        ESP_LOGE(TAG, "bootloader_flash_read src_addr 0x%x not 4-byte aligned", src_addr);
-        return ESP_FAIL;
-    }
-    if((intptr_t)dest & 3) {
-        ESP_LOGE(TAG, "bootloader_flash_read dest 0x%x not 4-byte aligned", (intptr_t)dest);
-        return ESP_FAIL;
-    }
-
-    Cache_Read_Disable(0);
-    Cache_Flush(0);
-    SpiFlashOpResult r = SPIRead(src_addr, dest, size);
-    Cache_Read_Enable(0);
-
     switch(r) {
     case SPI_FLASH_RESULT_OK:
         return ESP_OK;
@@ -119,4 +136,101 @@ esp_err_t bootloader_flash_read(size_t src_addr, void *dest, size_t size)
     }
 }
 
+static esp_err_t bootloader_flash_read_no_decrypt(size_t src_addr, void *dest, size_t size)
+{
+    Cache_Read_Disable(0);
+    Cache_Flush(0);
+    SpiFlashOpResult r = SPIRead(src_addr, dest, size);
+    Cache_Read_Enable(0);
+
+    return spi_to_esp_err(r);
+}
+
+static esp_err_t bootloader_flash_read_allow_decrypt(size_t src_addr, void *dest, size_t size)
+{
+    uint32_t *dest_words = (uint32_t *)dest;
+
+    /* Use the 51st MMU mapping to read from flash in 64KB blocks.
+       (MMU will transparently decrypt if encryption is enabled.)
+    */
+    for (int word = 0; word < size / 4; word++) {
+        uint32_t word_src = src_addr + word * 4;  /* Read this offset from flash */
+        uint32_t map_at = word_src & MMU_FLASH_MASK; /* Map this 64KB block from flash */
+        uint32_t *map_ptr;
+        if (map_at != current_read_mapping) {
+            /* Move the 64KB mmu mapping window to fit map_at */
+            Cache_Read_Disable(0);
+            Cache_Flush(0);
+            ESP_LOGD(TAG, "mmu set block paddr=0x%08x (was 0x%08x)", map_at, current_read_mapping);
+            int e = cache_flash_mmu_set(0, 0, MMU_BLOCK50_VADDR, map_at, 64, 1);
+            if (e != 0) {
+                ESP_LOGE(TAG, "cache_flash_mmu_set failed: %d\n", e);
+                Cache_Read_Enable(0);
+                return ESP_FAIL;
+            }
+            current_read_mapping = map_at;
+            Cache_Read_Enable(0);
+        }
+        map_ptr = (uint32_t *)(MMU_BLOCK50_VADDR + (word_src - map_at));
+        dest_words[word] = *map_ptr;
+    }
+    return ESP_OK;
+}
+
+esp_err_t bootloader_flash_read(size_t src_addr, void *dest, size_t size, bool allow_decrypt)
+{
+    if (src_addr & 3) {
+        ESP_LOGE(TAG, "bootloader_flash_read src_addr 0x%x not 4-byte aligned", src_addr);
+        return ESP_FAIL;
+    }
+    if (size & 3) {
+        ESP_LOGE(TAG, "bootloader_flash_read size 0x%x not 4-byte aligned", size);
+        return ESP_FAIL;
+    }
+    if ((intptr_t)dest & 3) {
+        ESP_LOGE(TAG, "bootloader_flash_read dest 0x%x not 4-byte aligned", (intptr_t)dest);
+        return ESP_FAIL;
+    }
+
+    if (allow_decrypt) {
+        return bootloader_flash_read_allow_decrypt(src_addr, dest, size);
+    } else {
+        return bootloader_flash_read_no_decrypt(src_addr, dest, size);
+    }
+}
+
+esp_err_t bootloader_flash_write(size_t dest_addr, void *src, size_t size, bool write_encrypted)
+{
+    esp_err_t err;
+    size_t alignment = write_encrypted ? 32 : 4;
+    if ((dest_addr % alignment) != 0) {
+        ESP_LOGE(TAG, "bootloader_flash_write dest_addr 0x%x not %d-byte aligned", dest_addr, alignment);
+        return ESP_FAIL;
+    }
+    if ((size % alignment) != 0) {
+        ESP_LOGE(TAG, "bootloader_flash_write size 0x%x not %d-byte aligned", size, alignment);
+        return ESP_FAIL;
+    }
+    if (((intptr_t)src % 4) != 0) {
+        ESP_LOGE(TAG, "bootloader_flash_write src 0x%x not 4 byte aligned", (intptr_t)src);
+        return ESP_FAIL;
+    }
+
+    err = spi_to_esp_err(SPIUnlock());
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    if (write_encrypted) {
+        return spi_to_esp_err(SPI_Encrypt_Write(dest_addr, src, size));
+    } else {
+        return spi_to_esp_err(SPIWrite(dest_addr, src, size));
+    }
+}
+
+esp_err_t bootloader_flash_erase_sector(size_t sector)
+{
+    return spi_to_esp_err(SPIEraseSector(sector));
+}
+
 #endif

components/bootloader_support/src/bootloader_random.c

@@ -0,0 +1,53 @@
+// Copyright 2010-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "bootloader_random.h"
+#include "soc/wdev_reg.h"
+
+#ifndef BOOTLOADER_BUILD
+#include "esp_system.h"
+#endif
+
+void bootloader_fill_random(void *buffer, size_t length)
+{
+    uint8_t *buffer_bytes = (uint8_t *)buffer;
+    uint32_t random;
+
+    /* TODO: enable HW RNG clock
+
+       Until this clock is enabled, this is not secure
+     */
+
+    for (int i = 0; i < length; i++) {
+        if (i == 0 || i % 4 == 0) { /* redundant check is for a compiler warning */
+#ifdef BOOTLOADER_BUILD
+            /* HW RNG generates 32 bits entropy per 16 APB cycles,
+               in bootloader CPU clock == APB clock.
+
+               We are being conservative here and waiting at least
+               that long, as loop shift overhead, etc will add more
+               cycles.
+            */
+            asm volatile("nop; nop; nop; nop;");
+            asm volatile("nop; nop; nop; nop;");
+            asm volatile("nop; nop; nop; nop;");
+            asm volatile("nop; nop; nop; nop;");
+            random = REG_READ(WDEV_RND_REG);
+#else
+            random = esp_random();
+#endif
+        }
+
+        buffer_bytes[i] = random >> ((i % 4) * 8);
+    }
+}

components/bootloader_support/src/efuse.c

@@ -0,0 +1,47 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "esp_efuse.h"
+
+#define EFUSE_CONF_WRITE 0x5A5A /* efuse_pgm_op_ena, force no rd/wr disable */
+#define EFUSE_CONF_READ 0x5AA5 /* efuse_read_op_ena, release force */
+
+#define EFUSE_CMD_PGM 0x02
+#define EFUSE_CMD_READ 0x01
+
+void esp_efuse_burn_new_values(void)
+{
+    REG_WRITE(EFUSE_CONF_REG, EFUSE_CONF_WRITE);
+    REG_WRITE(EFUSE_CMD_REG,  EFUSE_CMD_PGM);
+    while (REG_READ(EFUSE_CMD_REG) != 0) {
+    }
+    REG_WRITE(EFUSE_CONF_REG, EFUSE_CONF_READ);
+    REG_WRITE(EFUSE_CMD_REG,  EFUSE_CMD_READ);
+    while (REG_READ(EFUSE_CMD_REG) != 0) {
+    }
+    esp_efuse_reset();
+}
+
+void esp_efuse_reset(void)
+{
+    REG_WRITE(EFUSE_CONF_REG, EFUSE_CONF_READ);
+    const uint32_t block_start[4] = { EFUSE_BLK0_WDATA0_REG, EFUSE_BLK1_WDATA0_REG,
+                                      EFUSE_BLK2_WDATA0_REG, EFUSE_BLK3_WDATA0_REG };
+    const uint32_t block_end[4] = { EFUSE_BLK0_WDATA6_REG, EFUSE_BLK1_WDATA7_REG,
+                                    EFUSE_BLK2_WDATA7_REG, EFUSE_BLK3_WDATA7_REG };
+    for (int i = 0; i < 4; i++) {
+      for (uint32_t r = block_start[i]; r <= block_end[i]; r+= 4) {
+        REG_WRITE(r, 0);
+      }
+    }
+}

components/bootloader_support/src/esp_image_format.c

@@ -22,26 +22,30 @@ static const char *TAG = "esp_image";
 #define SIXTEEN_MB 0x1000000
 #define ESP_ROM_CHECKSUM_INITIAL 0xEF
 
-esp_err_t esp_image_load_header(uint32_t src_addr, esp_image_header_t *image_header)
+esp_err_t esp_image_load_header(uint32_t src_addr, bool log_errors, esp_image_header_t *image_header)
 {
     esp_err_t err;
     ESP_LOGD(TAG, "reading image header @ 0x%x", src_addr);
 
-    err = bootloader_flash_read(src_addr, image_header, sizeof(esp_image_header_t));
+    err = bootloader_flash_read(src_addr, image_header, sizeof(esp_image_header_t), true);
 
     if (err == ESP_OK) {
         if (image_header->magic != ESP_IMAGE_HEADER_MAGIC) {
-            ESP_LOGE(TAG, "image at 0x%x has invalid magic byte", src_addr);
+            if (log_errors) {
+                ESP_LOGE(TAG, "image at 0x%x has invalid magic byte", src_addr);
+            }
             err = ESP_ERR_IMAGE_INVALID;
         }
-        if (image_header->spi_mode > ESP_IMAGE_SPI_MODE_SLOW_READ) {
-            ESP_LOGW(TAG, "image at 0x%x has invalid SPI mode %d", src_addr, image_header->spi_mode);
-        }
-        if (image_header->spi_speed > ESP_IMAGE_SPI_SPEED_80M) {
-            ESP_LOGW(TAG, "image at 0x%x has invalid SPI speed %d", src_addr, image_header->spi_speed);
-        }
-        if (image_header->spi_size > ESP_IMAGE_FLASH_SIZE_MAX) {
-            ESP_LOGW(TAG, "image at 0x%x has invalid SPI size %d", src_addr, image_header->spi_size);
+        if (log_errors) {
+            if (image_header->spi_mode > ESP_IMAGE_SPI_MODE_SLOW_READ) {
+                ESP_LOGW(TAG, "image at 0x%x has invalid SPI mode %d", src_addr, image_header->spi_mode);
+            }
+            if (image_header->spi_speed > ESP_IMAGE_SPI_SPEED_80M) {
+                ESP_LOGW(TAG, "image at 0x%x has invalid SPI speed %d", src_addr, image_header->spi_speed);
+            }
+            if (image_header->spi_size > ESP_IMAGE_FLASH_SIZE_MAX) {
+                ESP_LOGW(TAG, "image at 0x%x has invalid SPI size %d", src_addr, image_header->spi_size);
+            }
         }
     }
 
@@ -51,23 +55,27 @@ esp_err_t esp_image_load_header(uint32_t src_addr, esp_image_header_t *image_hea
     return err;
 }
 
-esp_err_t esp_image_load_segment_header(uint8_t index, uint32_t src_addr, const esp_image_header_t *image_header, esp_image_segment_header_t *segment_header, uint32_t *segment_data_offset)
+esp_err_t esp_image_load_segment_header(uint8_t index, uint32_t src_addr, const esp_image_header_t *image_header, bool log_errors, esp_image_segment_header_t *segment_header, uint32_t *segment_data_offset)
 {
     esp_err_t err = ESP_OK;
     uint32_t next_addr = src_addr + sizeof(esp_image_header_t);
 
     if(index >= image_header->segment_count) {
-        ESP_LOGE(TAG, "index %d higher than segment count %d", index, image_header->segment_count);
+        if (log_errors) {
+            ESP_LOGE(TAG, "index %d higher than segment count %d", index, image_header->segment_count);
+        }
         return ESP_ERR_INVALID_ARG;
     }
 
     for(int i = 0; i <= index && err == ESP_OK; i++) {
         ESP_LOGV(TAG, "loading segment header %d at offset 0x%x", i, next_addr);
-        err = bootloader_flash_read(next_addr, segment_header, sizeof(esp_image_segment_header_t));
+        err = bootloader_flash_read(next_addr, segment_header, sizeof(esp_image_segment_header_t), true);
         if (err == ESP_OK) {
             if ((segment_header->data_len & 3) != 0
                 || segment_header->data_len >= SIXTEEN_MB) {
-                ESP_LOGE(TAG, "invalid segment length 0x%x", segment_header->data_len);
+                if (log_errors) {
+                    ESP_LOGE(TAG, "invalid segment length 0x%x", segment_header->data_len);
+                }
                 err = ESP_ERR_IMAGE_INVALID;
             }
             next_addr += sizeof(esp_image_segment_header_t);
@@ -85,15 +93,14 @@ esp_err_t esp_image_load_segment_header(uint8_t index, uint32_t src_addr, const
     return err;
 }
 
-esp_err_t esp_image_basic_verify(uint32_t src_addr, uint32_t *p_length)
+esp_err_t esp_image_basic_verify(uint32_t src_addr, bool log_errors, uint32_t *p_length)
 {
     esp_err_t err;
-    uint8_t buf[16];
+    uint8_t buf[128];
     uint8_t checksum = ESP_ROM_CHECKSUM_INITIAL;
     esp_image_header_t image_header;
     esp_image_segment_header_t segment_header = { 0 };
     uint32_t segment_data_offs = 0;
-    const uint8_t *segment_data;
     uint32_t end_addr;
     uint32_t length;
 
@@ -101,7 +108,7 @@ esp_err_t esp_image_basic_verify(uint32_t src_addr, uint32_t *p_length)
         *p_length = 0;
     }
 
-    err = esp_image_load_header(src_addr, &image_header);
+    err = esp_image_load_header(src_addr, log_errors, &image_header);
     if (err != ESP_OK) {
         return err;
     }
@@ -110,34 +117,38 @@ esp_err_t esp_image_basic_verify(uint32_t src_addr, uint32_t *p_length)
 
     /* Checksum each segment's data */
     for (int i = 0; i < image_header.segment_count; i++) {
-        err = esp_image_load_segment_header(i, src_addr, &image_header,
+        err = esp_image_load_segment_header(i, src_addr, &image_header, log_errors,
                                       &segment_header, &segment_data_offs);
         if (err != ESP_OK) {
             return err;
         }
 
-        segment_data = bootloader_mmap(segment_data_offs, segment_header.data_len);
-        if (segment_data == NULL) {
-            ESP_LOGE(TAG, "bootloader_mmap(0x%x, 0x%x) failed", segment_data_offs, segment_header.data_len);
-            return ESP_FAIL;
+        for (int i = 0; i < segment_header.data_len; i += sizeof(buf)) {
+            err = bootloader_flash_read(segment_data_offs + i, buf, sizeof(buf), true);
+            if (err != ESP_OK) {
+                return err;
+            }
+            for (int j = 0; j < sizeof(buf) && i + j < segment_header.data_len; j++) {
+                checksum ^= buf[j];
+            }
         }
-        for(int i = 0; i < segment_header.data_len; i++) {
-            checksum ^= segment_data[i];
-        }
-        bootloader_munmap(segment_data);
     }
 
     /* End of image, verify checksum */
     end_addr = segment_data_offs + segment_header.data_len;
 
     if (end_addr < src_addr) {
-        ESP_LOGE(TAG, "image offset has wrapped");
+        if (log_errors) {
+            ESP_LOGE(TAG, "image offset has wrapped");
+        }
         return ESP_ERR_IMAGE_INVALID;
     }
 
     length = end_addr - src_addr;
     if (length >= SIXTEEN_MB) {
-        ESP_LOGE(TAG, "invalid total length 0x%x", length);
+        if (log_errors) {
+            ESP_LOGE(TAG, "invalid total length 0x%x", length);
+        }
         return ESP_ERR_IMAGE_INVALID;
     }
 
@@ -147,10 +158,12 @@ esp_err_t esp_image_basic_verify(uint32_t src_addr, uint32_t *p_length)
     length = length - (length % 16);
     ESP_LOGV(TAG, "padded image length 0x%x", length);
     ESP_LOGD(TAG, "reading checksum block at 0x%x", src_addr + length - 16);
-    bootloader_flash_read(src_addr + length - 16, buf, 16);
+    bootloader_flash_read(src_addr + length - 16, buf, 16, true);
     if (checksum != buf[15]) {
-        ESP_LOGE(TAG, "checksum failed. Calculated 0x%x read 0x%x",
-                 checksum, buf[15]);
+        if (log_errors) {
+            ESP_LOGE(TAG, "checksum failed. Calculated 0x%x read 0x%x",
+                     checksum, buf[15]);
+        }
         return ESP_ERR_IMAGE_INVALID;
     }
 

components/bootloader_support/src/flash_encrypt.c

@@ -0,0 +1,310 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <strings.h>
+
+#include "bootloader_flash.h"
+#include "bootloader_random.h"
+#include "esp_image_format.h"
+#include "esp_flash_encrypt.h"
+#include "esp_flash_partitions.h"
+#include "esp_flash_data_types.h"
+#include "esp_secure_boot.h"
+#include "esp_efuse.h"
+#include "esp_log.h"
+#include "rom/secure_boot.h"
+
+#include "rom/cache.h"
+#include "rom/spi_flash.h"   /* TODO: Remove this */
+
+static const char *TAG = "flash_encrypt";
+
+/* Static functions for stages of flash encryption */
+static esp_err_t initialise_flash_encryption(void);
+static esp_err_t encrypt_flash_contents(uint32_t flash_crypt_cnt, bool flash_crypt_wr_dis);
+static esp_err_t encrypt_bootloader();
+static esp_err_t encrypt_and_load_partition_table(esp_partition_info_t *partition_table, int *num_partitions);
+static esp_err_t encrypt_partition(int index, const esp_partition_info_t *partition);
+
+esp_err_t esp_flash_encrypt_check_and_update(void)
+{
+    uint32_t efuse_blk0 = REG_READ(EFUSE_BLK0_RDATA0_REG);
+    ESP_LOGV(TAG, "efuse_blk0 raw value %08x", efuse_blk0);
+    uint32_t flash_crypt_cnt = (efuse_blk0 & EFUSE_RD_FLASH_CRYPT_CNT_M) >> EFUSE_RD_FLASH_CRYPT_CNT_S;
+    bool flash_crypt_wr_dis = efuse_blk0 & EFUSE_WR_DIS_FLASH_CRYPT_CNT;
+    ESP_LOGV(TAG, "efuse FLASH_CRYPT_CNT 0x%x WR_DIS_FLASH_CRYPT_CNT 0x%x", flash_crypt_cnt, flash_crypt_wr_dis);
+
+    if (__builtin_parity(flash_crypt_cnt) == 1) {
+        /* Flash is already encrypted */
+        int left = (7 - __builtin_popcount(flash_crypt_cnt)) / 2;
+        if (flash_crypt_wr_dis) {
+            left = 0; /* can't update FLASH_CRYPT_CNT, no more flashes */
+        }
+        ESP_LOGI(TAG, "flash encryption is enabled (%d plaintext flashes left)", left);
+        return ESP_OK;
+    }
+    else {
+        /* Flash is not encrypted, so encrypt it! */
+        return encrypt_flash_contents(flash_crypt_cnt, flash_crypt_wr_dis);
+    }
+}
+
+static esp_err_t initialise_flash_encryption(void)
+{
+    /* Before first flash encryption pass, need to initialise key & crypto config */
+
+    /* Generate key */
+    uint32_t dis_reg = REG_READ(EFUSE_BLK0_RDATA0_REG);
+    bool efuse_key_read_protected = dis_reg & EFUSE_RD_DIS_BLK1;
+    bool efuse_key_write_protected = dis_reg & EFUSE_WR_DIS_BLK1;
+    if (efuse_key_read_protected == false
+        && efuse_key_write_protected == false
+        && REG_READ(EFUSE_BLK1_RDATA0_REG) == 0
+        && REG_READ(EFUSE_BLK1_RDATA1_REG) == 0
+        && REG_READ(EFUSE_BLK1_RDATA2_REG) == 0
+        && REG_READ(EFUSE_BLK1_RDATA3_REG) == 0
+        && REG_READ(EFUSE_BLK1_RDATA4_REG) == 0
+        && REG_READ(EFUSE_BLK1_RDATA5_REG) == 0
+        && REG_READ(EFUSE_BLK1_RDATA6_REG) == 0
+        && REG_READ(EFUSE_BLK1_RDATA7_REG) == 0) {
+        ESP_LOGI(TAG, "Generating new flash encryption key...");
+        uint32_t buf[8];
+        bootloader_fill_random(buf, sizeof(buf));
+        for (int i = 0; i < 8; i++) {
+            ESP_LOGV(TAG, "EFUSE_BLK1_WDATA%d_REG = 0x%08x", i, buf[i]);
+            REG_WRITE(EFUSE_BLK1_WDATA0_REG + 4*i, buf[i]);
+        }
+        bzero(buf, sizeof(buf));
+        esp_efuse_burn_new_values();
+
+        ESP_LOGI(TAG, "Read & write protecting new key...");
+        REG_WRITE(EFUSE_BLK0_WDATA0_REG, EFUSE_WR_DIS_BLK1 | EFUSE_RD_DIS_BLK1);
+        esp_efuse_burn_new_values();
+    } else {
+
+        if(!(efuse_key_read_protected && efuse_key_write_protected)) {
+            ESP_LOGE(TAG, "Flash encryption key has to be either unset or both read and write protected");
+            return ESP_ERR_INVALID_STATE;
+        }
+        ESP_LOGW(TAG, "Using pre-loaded flash encryption key in EFUSE block 1");
+    }
+    /* CRYPT_CONFIG determines which bits of the AES block key are XORed
+       with bits from the flash address, to provide the key tweak.
+
+       CRYPT_CONFIG == 0 is effectively AES ECB mode (NOT SUPPORTED)
+
+       For now this is hardcoded to XOR all 256 bits of the key.
+
+       If you need to override it, you can pre-burn this efuse to the
+       desired value and then write-protect it, in which case this
+       operation does nothing. Please note this is not recommended!
+    */
+    ESP_LOGI(TAG, "Setting CRYPT_CONFIG efuse to 0xF");
+    REG_WRITE(EFUSE_BLK0_WDATA5_REG, EFUSE_FLASH_CRYPT_CONFIG_M);
+    esp_efuse_burn_new_values();
+
+#ifndef CONFIG_FLASH_ENCRYPTION_UART_BOOTLOADER_ALLOW_WRITE
+    ESP_LOGI(TAG, "Disable UART bootloader write...");
+    //REG_WRITE(EFUSE_BLK0_
+
+#endif
+    return ESP_OK;
+}
+
+/* Encrypt all flash data that should be encrypted */
+static esp_err_t encrypt_flash_contents(uint32_t flash_crypt_cnt, bool flash_crypt_wr_dis)
+{
+    esp_err_t err;
+    esp_partition_info_t partition_table[ESP_PARTITION_TABLE_MAX_ENTRIES];
+    int num_partitions;
+
+    /* If the last flash_crypt_cnt bit is burned or write-disabled, the
+       device can't re-encrypt itself. */
+    if (flash_crypt_wr_dis || flash_crypt_cnt == 0xFF) {
+        ESP_LOGE(TAG, "Cannot re-encrypt data (FLASH_CRYPT_CNT 0x%02x write disabled %d", flash_crypt_cnt, flash_crypt_wr_dis);
+        return ESP_FAIL;
+    }
+
+    if (flash_crypt_cnt == 0) {
+        /* Very first flash of encrypted data: generate keys, etc. */
+        err = initialise_flash_encryption();
+        if (err != ESP_OK) {
+            return err;
+        }
+    }
+
+    err = encrypt_bootloader();
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    err = encrypt_and_load_partition_table(partition_table, &num_partitions);
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    /* Now iterate the just-loaded partition table, looking for entries to encrypt
+     */
+
+    /* Go through each partition and encrypt if necessary */
+    for (int i = 0; i < num_partitions; i++) {
+        err = encrypt_partition(i, &partition_table[i]);
+        if (err != ESP_OK) {
+            return err;
+        }
+    }
+
+    ESP_LOGD(TAG, "All flash regions checked for encryption pass");
+
+    /* Set least significant 0-bit in flash_crypt_cnt */
+    int ffs_inv = __builtin_ffs((~flash_crypt_cnt) & 0xFF);
+    /* ffs_inv shouldn't be zero, as zero implies flash_crypt_cnt == 0xFF */
+    uint32_t new_flash_crypt_cnt = flash_crypt_cnt + (1 << (ffs_inv - 1));
+    ESP_LOGD(TAG, "FLASH_CRYPT_CNT 0x%x -> 0x%x", flash_crypt_cnt, new_flash_crypt_cnt);
+    REG_SET_FIELD(EFUSE_BLK0_WDATA0_REG, EFUSE_FLASH_CRYPT_CNT, new_flash_crypt_cnt);
+    esp_efuse_burn_new_values();
+
+    ESP_LOGI(TAG, "Flash encryption completed");
+
+    return ESP_OK;
+}
+
+static esp_err_t encrypt_bootloader()
+{
+    esp_err_t err;
+    uint32_t image_length;
+    /* Check for plaintext bootloader */
+    if (esp_image_basic_verify(ESP_BOOTLOADER_OFFSET, false, &image_length) == ESP_OK) {
+        ESP_LOGD(TAG, "bootloader is plaintext. Encrypting...");
+        err = esp_flash_encrypt_region(ESP_BOOTLOADER_OFFSET, image_length);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "Failed to encrypt bootloader in place: 0x%x", err);
+            return err;
+        }
+
+        if (esp_secure_boot_enabled()) {
+            /* If secure boot is enabled and bootloader was plaintext, also
+               need to encrypt secure boot IV+digest.
+            */
+            ESP_LOGD(TAG, "Encrypting secure bootloader IV & digest...");
+            err = esp_flash_encrypt_region(FLASH_OFFS_SECURE_BOOT_IV_DIGEST,
+                                           FLASH_SECTOR_SIZE);
+            if (err != ESP_OK) {
+                ESP_LOGE(TAG, "Failed to encrypt bootloader IV & digest in place: 0x%x", err);
+                return err;
+            }
+        }
+    }
+    else {
+        ESP_LOGW(TAG, "no valid bootloader was found");
+    }
+
+    return ESP_OK;
+}
+
+static esp_err_t encrypt_and_load_partition_table(esp_partition_info_t *partition_table, int *num_partitions)
+{
+    esp_err_t err;
+    /* Check for plaintext partition table */
+    err = bootloader_flash_read(ESP_PARTITION_TABLE_OFFSET, partition_table, ESP_PARTITION_TABLE_MAX_LEN, false);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to read partition table data");
+        return err;
+    }
+    if (esp_partition_table_basic_verify(partition_table, false, num_partitions) == ESP_OK) {
+        ESP_LOGD(TAG, "partition table is plaintext. Encrypting...");
+        esp_err_t err = esp_flash_encrypt_region(ESP_PARTITION_TABLE_OFFSET,
+                                                 FLASH_SECTOR_SIZE);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "Failed to encrypt partition table in place. %x", err);
+            return err;
+        }
+    }
+    else {
+        ESP_LOGE(TAG, "Failed to read partition table data - not plaintext?");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    /* Valid partition table loded */
+    return ESP_OK;
+}
+
+
+static esp_err_t encrypt_partition(int index, const esp_partition_info_t *partition)
+{
+    esp_err_t err;
+    uint32_t image_len = partition->pos.size;
+    bool should_encrypt = (partition->flags & PART_FLAG_ENCRYPTED);
+
+    if (partition->type == PART_TYPE_APP) {
+        /* check if the partition holds an unencrypted app */
+        if (esp_image_basic_verify(partition->pos.offset, false, &image_len) == ESP_OK) {
+            if(image_len > partition->pos.size) {
+                ESP_LOGE(TAG, "partition entry %d has image longer than partition (%d vs %d)", index, image_len, partition->pos.size);
+                should_encrypt = false;
+            } else {
+                should_encrypt = true;
+            }
+        } else {
+            should_encrypt = false;
+        }
+    }
+
+    if (!should_encrypt) {
+        return ESP_OK;
+    }
+    else {
+        /* should_encrypt */
+        ESP_LOGI(TAG, "Encrypting partition %d at offset 0x%x...", index, partition->pos.offset);
+
+        err = esp_flash_encrypt_region(partition->pos.offset, partition->pos.size);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "Failed to encrypt partition %d", index);
+        }
+        return err;
+    }
+}
+
+
+esp_err_t esp_flash_encrypt_region(uint32_t src_addr, size_t data_length)
+{
+    esp_err_t err;
+    uint32_t buf[FLASH_SECTOR_SIZE / sizeof(uint32_t)];
+
+    if (src_addr % FLASH_SECTOR_SIZE != 0) {
+        ESP_LOGE(TAG, "esp_flash_encrypt_region bad src_addr 0x%x",src_addr);
+        return ESP_FAIL;
+    }
+
+    for (size_t i = 0; i < data_length; i += FLASH_SECTOR_SIZE) {
+        uint32_t sec_start = i + src_addr;
+        err = bootloader_flash_read(sec_start, buf, FLASH_SECTOR_SIZE, false);
+        if (err != ESP_OK) {
+            goto flash_failed;
+        }
+        err = bootloader_flash_erase_sector(sec_start / FLASH_SECTOR_SIZE);
+        if (err != ESP_OK) {
+            goto flash_failed;
+        }
+        err = bootloader_flash_write(sec_start, buf, FLASH_SECTOR_SIZE, true);
+        if (err != ESP_OK) {
+            goto flash_failed;
+        }
+    }
+    return ESP_OK;
+
+ flash_failed:
+    ESP_LOGE(TAG, "flash operation failed: 0x%x", err);
+    return err;
+}

components/bootloader_support/src/flash_partitions.c

@@ -0,0 +1,49 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include "esp_flash_partitions.h"
+#include "esp_log.h"
+
+static const char *TAG = "flash_parts";
+
+esp_err_t esp_partition_table_basic_verify(const esp_partition_info_t *partition_table, bool log_errors, int *num_partitions)
+{
+  int num_parts;
+  *num_partitions = 0;
+
+  for(num_parts = 0; num_parts < ESP_PARTITION_TABLE_MAX_ENTRIES; num_parts++) {
+    const esp_partition_info_t *part = &partition_table[num_parts];
+
+    if(part->magic == 0xFFFF
+       && part->type == PART_TYPE_END
+       && part->subtype == PART_SUBTYPE_END) {
+      /* TODO: check md5 */
+      ESP_LOGD(TAG, "partition table verified, %d entries", num_parts);
+      *num_partitions = num_parts;
+      return ESP_OK;
+    }
+
+    if(part->magic != ESP_PARTITION_MAGIC) {
+        if (log_errors) {
+            ESP_LOGE(TAG, "partition %d invalid magic number 0x%x", num_parts, part->magic);
+        }
+        return ESP_ERR_INVALID_STATE;
+    }
+  }
+
+  if (log_errors) {
+      ESP_LOGE(TAG, "partition table has no terminating entry, not valid");
+  }
+  return ESP_ERR_INVALID_STATE;
+}
+

components/bootloader_support/src/secure_boot.c

@@ -20,7 +20,6 @@
 
 #include "rom/cache.h"
 #include "rom/ets_sys.h"
-#include "rom/spi_flash.h"
 #include "rom/secure_boot.h"
 
 #include "soc/dport_reg.h"
@@ -31,15 +30,14 @@
 #include "sdkconfig.h"
 
 #include "bootloader_flash.h"
+#include "bootloader_random.h"
 #include "esp_image_format.h"
 #include "esp_secure_boot.h"
+#include "esp_flash_encrypt.h"
+#include "esp_efuse.h"
 
 static const char* TAG = "secure_boot";
 
-#define HASH_BLOCK_SIZE 128
-#define IV_LEN HASH_BLOCK_SIZE
-#define DIGEST_LEN 64
-
 /**
  *  @function :     secure_boot_generate
  *  @description:   generate boot digest (aka "abstract") & iv
@@ -47,39 +45,26 @@ static const char* TAG = "secure_boot";
  *  @inputs:        image_len - length of image to calculate digest for
  */
 static bool secure_boot_generate(uint32_t image_len){
-    SpiFlashOpResult spiRet;
-    /* buffer is uint32_t not uint8_t to meet ROM SPI API signature */
-    uint32_t buf[IV_LEN / sizeof(uint32_t)];
-    const void *image;
+    esp_err_t err;
+    esp_secure_boot_iv_digest_t digest;
+    const uint32_t *image;
 
     /* hardware secure boot engine only takes full blocks, so round up the
        image length. The additional data should all be 0xFF.
     */
-    if (image_len % HASH_BLOCK_SIZE != 0) {
-        image_len = (image_len / HASH_BLOCK_SIZE + 1) * HASH_BLOCK_SIZE;
+    if (image_len % sizeof(digest.iv) != 0) {
+        image_len = (image_len / sizeof(digest.iv) + 1) * sizeof(digest.iv);
     }
     ets_secure_boot_start();
-    ets_secure_boot_rd_iv(buf);
+    ets_secure_boot_rd_iv((uint32_t *)digest.iv);
     ets_secure_boot_hash(NULL);
-    Cache_Read_Disable(0);
     /* iv stored in sec 0 */
-    spiRet = SPIEraseSector(0);
-    if (spiRet != SPI_FLASH_RESULT_OK)
+    err = bootloader_flash_erase_sector(0);
+    if (err != ESP_OK)
     {
-        ESP_LOGE(TAG, "SPI erase failed %d", spiRet);
+        ESP_LOGE(TAG, "SPI erase failed: 0x%x", err);
         return false;
     }
-    Cache_Read_Enable(0);
-
-    /* write iv to flash, 0x0000, 128 bytes (1024 bits) */
-    ESP_LOGD(TAG, "write iv to flash.");
-    spiRet = SPIWrite(0, buf, IV_LEN);
-    if (spiRet != SPI_FLASH_RESULT_OK)
-    {
-        ESP_LOGE(TAG, "SPI write failed %d", spiRet);
-        return false;
-    }
-    bzero(buf, sizeof(buf));
 
     /* generate digest from image contents */
     image = bootloader_mmap(0x1000, image_len);
@@ -87,22 +72,22 @@ static bool secure_boot_generate(uint32_t image_len){
         ESP_LOGE(TAG, "bootloader_mmap(0x1000, 0x%x) failed", image_len);
         return false;
     }
-    for (int i = 0; i < image_len; i+= HASH_BLOCK_SIZE) {
-        ets_secure_boot_hash(image + i/sizeof(void *));
+    for (int i = 0; i < image_len; i+= sizeof(digest.iv)) {
+        ets_secure_boot_hash(&image[i/sizeof(uint32_t)]);
     }
     bootloader_munmap(image);
 
     ets_secure_boot_obtain();
-    ets_secure_boot_rd_abstract(buf);
+    ets_secure_boot_rd_abstract((uint32_t *)digest.digest);
     ets_secure_boot_finish();
 
-    ESP_LOGD(TAG, "write digest to flash.");
-    spiRet = SPIWrite(0x80, buf, DIGEST_LEN);
-    if (spiRet != SPI_FLASH_RESULT_OK) {
-        ESP_LOGE(TAG, "SPI write failed %d", spiRet);
+    ESP_LOGD(TAG, "write iv+digest to flash");
+    err = bootloader_flash_write(FLASH_OFFS_SECURE_BOOT_IV_DIGEST, &digest,
+                           sizeof(digest), esp_flash_encryption_enabled());
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "SPI write failed: 0x%x", err);
         return false;
     }
-    ESP_LOGD(TAG, "write digest to flash.");
     Cache_Read_Enable(0);
     return true;
 }
@@ -113,12 +98,7 @@ static inline void burn_efuses()
 #ifdef CONFIG_SECURE_BOOT_TEST_MODE
     ESP_LOGE(TAG, "SECURE BOOT TEST MODE. Not really burning any efuses!");
 #else
-    REG_WRITE(EFUSE_CONF_REG, 0x5A5A);  /* efuse_pgm_op_ena, force no rd/wr disable */
-    REG_WRITE(EFUSE_CMD_REG,  0x02);    /* efuse_pgm_cmd */
-    while (REG_READ(EFUSE_CMD_REG));    /* wait for efuse_pagm_cmd=0 */
-    REG_WRITE(EFUSE_CONF_REG, 0x5AA5);  /* efuse_read_op_ena, release force */
-    REG_WRITE(EFUSE_CMD_REG,  0x01);    /* efuse_read_cmd */
-    while (REG_READ(EFUSE_CMD_REG));    /* wait for efuse_read_cmd=0 */
+    esp_efuse_burn_new_values();
 #endif
 }
 
@@ -131,7 +111,7 @@ esp_err_t esp_secure_boot_permanently_enable(void) {
         return ESP_OK;
     }
 
-    err = esp_image_basic_verify(0x1000, &image_len);
+    err = esp_image_basic_verify(0x1000, true, &image_len);
     if (err != ESP_OK) {
         ESP_LOGE(TAG, "bootloader image appears invalid! error %d", err);
         return err;
@@ -151,12 +131,8 @@ esp_err_t esp_secure_boot_permanently_enable(void) {
         && REG_READ(EFUSE_BLK2_RDATA6_REG) == 0
         && REG_READ(EFUSE_BLK2_RDATA7_REG) == 0) {
         ESP_LOGI(TAG, "Generating new secure boot key...");
-        /* reuse the secure boot IV generation function to generate
-           the key, as this generator uses the hardware RNG. */
-        uint32_t buf[32];
-        ets_secure_boot_start();
-        ets_secure_boot_rd_iv(buf);
-        ets_secure_boot_finish();
+        uint32_t buf[8];
+        bootloader_fill_random(buf, sizeof(buf));
         for (int i = 0; i < 8; i++) {
             ESP_LOGV(TAG, "EFUSE_BLK2_WDATA%d_REG = 0x%08x", i, buf[i]);
             REG_WRITE(EFUSE_BLK2_WDATA0_REG + 4*i, buf[i]);
@@ -199,7 +175,7 @@ esp_err_t esp_secure_boot_permanently_enable(void) {
     new_wdata6 |= EFUSE_RD_DISABLE_JTAG;
     #endif
 
-    #ifdef CONFIG_SECURE_BOOT_DISABLE_UART_BOOTLOADER
+    #ifdef CONFIG_SECURE_BOOT_DISABLE_ROM_BASIC
     ESP_LOGI(TAG, "disabling UART bootloader...");
     new_wdata6 |= EFUSE_RD_CONSOLE_DEBUG_DISABLE_S;
     #endif

components/bootloader_support/src/secure_boot_signatures.c

@@ -27,11 +27,6 @@ typedef SHA_CTX sha_context;
 #include "hwcrypto/sha.h"
 #endif
 
-typedef struct {
-    uint32_t version;
-    uint8_t signature[64];
-} signature_block_t;
-
 static const char* TAG = "secure_boot";
 
 extern const uint8_t signature_verification_key_start[] asm("_binary_signature_verification_key_bin_start");
@@ -47,7 +42,7 @@ esp_err_t esp_secure_boot_verify_signature(uint32_t src_addr, uint32_t length)
     uint8_t digest[32];
     ptrdiff_t keylen;
     const uint8_t *data;
-    const signature_block_t *sigblock;
+    const esp_secure_boot_sig_block_t *sigblock;
     bool is_valid;
 #ifdef BOOTLOADER_BUILD
     const uint8_t *digest_data;
@@ -56,13 +51,13 @@ esp_err_t esp_secure_boot_verify_signature(uint32_t src_addr, uint32_t length)
 
     ESP_LOGD(TAG, "verifying signature src_addr 0x%x length 0x%x", src_addr, length);
 
-    data = bootloader_mmap(src_addr, length + sizeof(signature_block_t));
+    data = bootloader_mmap(src_addr, length + sizeof(esp_secure_boot_sig_block_t));
     if(data == NULL) {
-        ESP_LOGE(TAG, "bootloader_mmap(0x%x, 0x%x) failed", src_addr, length+sizeof(signature_block_t));
+        ESP_LOGE(TAG, "bootloader_mmap(0x%x, 0x%x) failed", src_addr, length+sizeof(esp_secure_boot_sig_block_t));
         return ESP_FAIL;
     }
 
-    sigblock = (const signature_block_t *)(data + length);
+    sigblock = (const esp_secure_boot_sig_block_t *)(data + length);
 
     if (sigblock->version != 0) {
         ESP_LOGE(TAG, "src 0x%x has invalid signature version field 0x%08x", src_addr, sigblock->version);