Experimental: chacha20 encryption for external partitions

Author: danielinux

Makefile

@@ -125,6 +125,11 @@ ifeq ($(UART_FLASH),1)
   EXT_FLASH=1
 endif
 
+ifeq ($(ENCRYPT),1)
+    CFLAGS+=-DEXT_ENCRYPTED=1
+    WOLFCRYPT_OBJS+=./lib/wolfssl/wolfcrypt/src/chacha.o
+endif
+
 ifeq ($(EXT_FLASH),1)
   CFLAGS+= -DEXT_FLASH=1 -DPART_UPDATE_EXT=1 -DPART_SWAP_EXT=1
   ifeq ($(NO_XIP),1)
@@ -303,6 +308,10 @@ include/target.h: include/target.h.in FORCE
 config: FORCE
 	make -C config
 
+../src/libwolfboot.o: ../src/libwolfboot.c FORCE
+	@echo "\t[CC-$(ARCH)] $@"
+	$(Q)$(CC) $(CFLAGS) -c -o $@ ../src/libwolfboot.c
+
 %.o:%.c
 	@echo "\t[CC-$(ARCH)] $@"
 	$(Q)$(CC) $(CFLAGS) -c -o $@ $^

include/encrypt.h

@@ -0,0 +1,44 @@
+/* encrypt.h
+ *
+ * Functions to encrypt/decrypt external flash content
+ *
+ * Copyright (C) 2020 wolfSSL Inc.
+ *
+ * This file is part of wolfBoot.
+ *
+ * wolfBoot is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * wolfBoot is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
+ */
+
+#ifndef ENCRYPT_H_INCLUDED
+#define ENCRYPT_H_INCLUDED
+#include <stdint.h>
+#include <wolfssl/wolfcrypt/settings.h>
+#include <wolfssl/wolfcrypt/sha256.h>
+
+#include "target.h"
+#include "wolfboot/wolfboot.h"
+
+#include <wolfssl/wolfcrypt/chacha.h>
+#include <wolfssl/wolfcrypt/pwdbased.h>
+
+#define ENCRYPT_BLOCK_SIZE 16 
+#define ENCRYPT_KEY_SIZE 32 /* Chacha20-256 */
+
+int ext_flash_set_encrypt_key(const uint8_t *key, int len);
+int ext_flash_set_encrypt_password(const uint8_t *pwd, int len);
+int ext_flash_encrypt_write(uintptr_t address, const uint8_t *data, int len);
+int ext_flash_decrypt_read(uintptr_t address, uint8_t *data, int len);
+
+#endif /* ENCRYPT_H_INCLUDED */

include/image.h

@@ -98,6 +98,16 @@ uint16_t wolfBoot_find_header(uint8_t *haystack, uint16_t type, uint8_t **ptr);
 # define PART_IS_EXT(x)  PARTN_IS_EXT(((x)->part))
 #include "hal.h"
 
+
+#ifdef EXT_ENCRYPTED
+#include "encrypt.h"
+#define ext_flash_check_write ext_flash_encrypt_write
+#define ext_flash_check_read ext_flash_decrypt_read
+#else
+#define ext_flash_check_write ext_flash_write
+#define ext_flash_check_read ext_flash_read
+#endif
+
 static inline int wb_flash_erase(struct wolfBoot_image *img, uint32_t off, uint32_t size)
 {
     if (PART_IS_EXT(img))
@@ -109,7 +119,7 @@ static inline int wb_flash_erase(struct wolfBoot_image *img, uint32_t off, uint3
 static inline int wb_flash_write(struct wolfBoot_image *img, uint32_t off, const void *data, uint32_t size)
 {
     if (PART_IS_EXT(img))
-        return ext_flash_write((uintptr_t)(img->hdr) + off, data, size);
+        return ext_flash_check_write((uintptr_t)(img->hdr) + off, data, size);
     else
         return hal_flash_write((uintptr_t)(img->hdr) + off, data, size);
 }
@@ -120,12 +130,12 @@ static inline int wb_flash_write_verify_word(struct wolfBoot_image *img, uint32_
     volatile uint32_t copy;
     if (PART_IS_EXT(img))
     {
-        ext_flash_read((uintptr_t)(img->hdr) + off, (void *)&copy, sizeof(uint32_t));
+        ext_flash_check_read((uintptr_t)(img->hdr) + off, (void *)&copy, sizeof(uint32_t));
         while (copy != word) {
-            ret = ext_flash_write((uintptr_t)(img->hdr) + off, (void *)&word, sizeof(uint32_t));
+            ret = ext_flash_check_write((uintptr_t)(img->hdr) + off, (void *)&word, sizeof(uint32_t));
             if (ret < 0)
                 return ret;
-            ext_flash_read((uintptr_t)(img->hdr) + off, (void *)&copy, sizeof(uint32_t));
+            ext_flash_check_read((uintptr_t)(img->hdr) + off, (void *)&copy, sizeof(uint32_t));
         }
     } else {
         volatile uint32_t *pcopy = (volatile uint32_t*)(img->hdr + off);
@@ -154,5 +164,11 @@ static inline int wb_flash_write_verify_word(struct wolfBoot_image *img, uint32_
 /* --- Flattened Device Tree Blob */
 #define UBOOT_FDT_MAGIC	    0xEDFE0DD0UL
 
+#ifndef EXT_ENCRYPTED
+#define WOLFBOOT_MAX_SPACE (WOLFBOOT_PARTITION_SIZE - (TRAILER_SKIP + sizeof(uint32_t) + (WOLFBOOT_PARTITION_SIZE + 1 / (WOLFBOOT_SECTOR_SIZE * 8)))) 
+#else
+#include "encrypt.h"
+#define WOLFBOOT_MAX_SPACE (WOLFBOOT_PARTITION_SIZE - ENCRYPT_TMP_SECRET_OFFSET)
+#endif
 
 #endif /* !IMAGE_H */

include/user_settings.h

@@ -114,6 +114,13 @@
 # define NO_SHA256
 #endif
 
+#ifdef EXT_ENCRYPTED
+#  define HAVE_CHACHA
+#  define HAVE_PWDBASED
+#else
+#  define NO_PWDBASED
+#endif
+
 /* Disables - For minimum wolfCrypt build */
 #define NO_AES
 #define NO_CMAC
@@ -133,7 +140,6 @@
 #define NO_SESSION_CACHE
 #define NO_HC128
 #define NO_DES3
-#define NO_PWDBASED
 #define WC_NO_RNG
 #define WC_NO_HASHDRBG
 #define NO_WRITEV

include/wolfboot/wolfboot.h

@@ -78,6 +78,7 @@
 #define PART_BOOT   0
 #define PART_UPDATE 1
 #define PART_SWAP   2
+#define PART_NONE   0xFF
 
 #define PART_DTS (0x10)
 #define PART_DTS_BOOT       (PART_DTS | PART_BOOT)

src/image.c

@@ -178,29 +178,28 @@ static uint16_t get_header(struct wolfBoot_image *img, uint16_t type, uint8_t **
 }
 
 static uint8_t ext_hash_block[WOLFBOOT_SHA_BLOCK_SIZE];
-
+static uint8_t digest[WOLFBOOT_SHA_DIGEST_SIZE];
 static uint8_t *get_sha_block(struct wolfBoot_image *img, uint32_t offset)
 {
     if (offset > img->fw_size)
         return NULL;
+#ifdef EXT_FLASH
     if (PART_IS_EXT(img)) {
-        ext_flash_read((uintptr_t)(img->fw_base) + offset, ext_hash_block, WOLFBOOT_SHA_BLOCK_SIZE);
+        ext_flash_check_read((uintptr_t)(img->fw_base) + offset, ext_hash_block, WOLFBOOT_SHA_BLOCK_SIZE);
         return ext_hash_block;
     } else
+#endif
         return (uint8_t *)(img->fw_base + offset);
 }
 
-static uint8_t digest[WOLFBOOT_SHA_DIGEST_SIZE];
-
 #ifdef EXT_FLASH
-
 static uint8_t hdr_cpy[IMAGE_HEADER_SIZE];
 static int hdr_cpy_done = 0;
 
 static uint8_t *fetch_hdr_cpy(struct wolfBoot_image *img)
 {
     if (!hdr_cpy_done) {
-        ext_flash_read((uintptr_t)img->hdr, hdr_cpy, IMAGE_HEADER_SIZE);
+        ext_flash_check_read((uintptr_t)img->hdr, hdr_cpy, IMAGE_HEADER_SIZE);
         hdr_cpy_done = 1;
     }
     return hdr_cpy;