Update STM32H747_updateBootloader sketch to support MCUBoot upload.

  Add MCUBoot v2 binary
  Add default keys to be flashed updating the loader

Author: pennam

libraries/STM32H747_System/examples/STM32H747_updateBootloader/STM32H747_updateBootloader.ino

@@ -1,32 +1,59 @@
 #include "FlashIAP.h"
+#include "QSPIFBlockDevice.h"
+#include "MBRBlockDevice.h"
+#include "LittleFileSystem.h"
+#include "FATFileSystem.h"
 #if defined(ARDUINO_PORTENTA_H7_M7)
 #include "portenta_bootloader.h"
 #include "portenta_lite_bootloader.h"
 #include "portenta_lite_connected_bootloader.h"
+#include "mcuboot_bootloader.h"
+#include "ecdsa-p256-encrypt-key.h"
+#include "ecdsa-p256-signing-key.h"
 #elif defined(ARDUINO_NICLA_VISION)
 #include "nicla_vision_bootloader.h"
 #endif
 
-#ifndef CORE_CM7  
+#ifndef CORE_CM7
   #error Update the bootloader by uploading the sketch to the M7 core instead of the M4 core.
 #endif
 
 #define BOOTLOADER_ADDR   (0x8000000)
+#define SIGNING_KEY_ADDR  (0x8000300)
+#define ENCRYPT_KEY_ADDR  (0x8000400)
+#define ENCRYPT_KEY_SIZE  (0x0000100)
+#define SIGNING_KEY_SIZE  (0x0000100)
+
 mbed::FlashIAP flash;
+QSPIFBlockDevice root(QSPI_SO0, QSPI_SO1, QSPI_SO2, QSPI_SO3,  QSPI_SCK, QSPI_CS, QSPIF_POLARITY_MODE_1, 40000000);
+
+bool writeLoader = false;
+bool writeKeys = false;
+bool video_available = false;
+bool wifi_available = false;
+bool MCUboot = false;
 
 uint32_t bootloader_data_offset = 0x1F000;
 uint8_t* bootloader_data = (uint8_t*)(BOOTLOADER_ADDR + bootloader_data_offset);
 
-bool video_available = false;
-bool wifi_available = false;
+uint32_t bootloader_identification_offset = 0x2F0;
+uint8_t* bootloader_identification = (uint8_t*)(BOOTLOADER_ADDR + bootloader_identification_offset);
 
-void setup() {  
+const unsigned char* bootloader_ptr = &bootloader_mbed_bin[0];
+long bootloader_len = bootloader_mbed_bin_len;
+
+void setup() {
   Serial.begin(115200);
   while (!Serial) {}
 
   uint8_t currentBootloaderVersion = bootloader_data[1];
-  uint8_t availableBootloaderVersion = (bootloader_mbed_bin + bootloader_data_offset)[1];
+  String currentBootloaderIdentifier = String(bootloader_identification, 15);
+
+  if(!currentBootloaderIdentifier.equals("MCUboot Arduino")) {
+    currentBootloaderIdentifier = "Arduino loader";
+  }
 
+  Serial.println(currentBootloaderIdentifier);
   Serial.println("Magic Number (validation): " + String(bootloader_data[0], HEX));
   Serial.println("Bootloader version: " + String(currentBootloaderVersion));
   Serial.println("Clock source: " + getClockSource(bootloader_data[2]));
@@ -41,36 +68,62 @@ void setup() {
   video_available = bootloader_data[8];
   wifi_available = bootloader_data[5];
 
-  if (availableBootloaderVersion > currentBootloaderVersion) {
-    Serial.print("\nA new bootloader version is available: v" + String(availableBootloaderVersion));
-    Serial.println(" (Your version: v" + String(currentBootloaderVersion) + ")");
-    Serial.println("Do you want to update the bootloader? Y/[n]");
-  } else if(availableBootloaderVersion < currentBootloaderVersion){ 
-    Serial.println("\nA newer bootloader version is already installed: v" + String(currentBootloaderVersion));    
-    Serial.println("Do you want to downgrade the bootloader to v" + String(availableBootloaderVersion) + "? Y/[n]");
+#if defined(ARDUINO_PORTENTA_H7_M7)
+  Serial.println("\nDo you want to update the default Arduino bootloader? Y/[n]");
+  Serial.println("If No, MCUBoot bootloader will be updated.");
+  if(waitResponse()) {
+    bootloader_ptr = &bootloader_mbed_bin[0];
+    bootloader_len = bootloader_mbed_bin_len;
+    if (!video_available) {
+      if (wifi_available) {
+        bootloader_ptr = &bootloader_mbed_lite_connected_bin[0];
+        bootloader_len = bootloader_mbed_lite_connected_bin_len;
+      } else {
+        bootloader_ptr = &bootloader_mbed_lite_bin[0];
+        bootloader_len = bootloader_mbed_lite_bin_len;
+      }
+    }
   } else {
-    Serial.println("\nThe latest version of the bootloader is already installed (v" + String(currentBootloaderVersion) + ").");
-    Serial.println("Do you want to update the bootloader anyway? Y/[n]");
+    bootloader_ptr = &mcuboot_bin[0];
+    bootloader_len = mcuboot_bin_len;
   }
-  
-  bool confirmation = false;
-  while (confirmation == false) {
-    if (Serial.available()) {
-      char choice = Serial.read();
-      switch (choice) {
-        case 'y':
-        case 'Y':
-          applyUpdate(BOOTLOADER_ADDR);
-          confirmation = true;
-          break;
-        case 'n':
-        case 'N':
-          confirmation = true;
-          break;
-        default:
-          continue;
-      }
+#endif
+
+  uint8_t availableBootloaderVersion = (bootloader_ptr + bootloader_data_offset)[1];
+  String availableBootloaderIdentifier = String(bootloader_ptr + bootloader_identification_offset, 15);
+
+  if(!availableBootloaderIdentifier.equals("MCUboot Arduino")) {
+    availableBootloaderIdentifier = "Arduino loader";
+  }
+
+  if (currentBootloaderIdentifier == availableBootloaderIdentifier) {
+    if (availableBootloaderVersion > currentBootloaderVersion) {
+      Serial.print("\nA new bootloader version is available: v" + String(availableBootloaderVersion));
+      Serial.println(" (Your version: v" + String(currentBootloaderVersion) + ")");
+      Serial.println("Do you want to update the bootloader? Y/[n]");
+    } else if (availableBootloaderVersion < currentBootloaderVersion) {
+      Serial.println("\nA newer bootloader version is already installed: v" + String(currentBootloaderVersion));
+      Serial.println("Do you want to downgrade the bootloader to v" + String(availableBootloaderVersion) + "? Y/[n]");
+    } else {
+      Serial.println("\nThe latest version of the bootloader is already installed (v" + String(currentBootloaderVersion) + ").");
+      Serial.println("Do you want to update the bootloader anyway? Y/[n]");
     }
+  } else {
+    Serial.println("\nA different bootloader type is available: v" + String(availableBootloaderVersion));
+    Serial.println("Do you want to update the bootloader? Y/[n]");
+  }
+  writeLoader = waitResponse();
+
+  if (writeLoader) {
+    if(availableBootloaderIdentifier.equals("MCUboot Arduino")) {
+      setupMCUBootOTAData();
+      Serial.println("\nThe bootloader comes with a set of default keys to evaluate signing and encryption process");
+      Serial.println("Do you want to load default keys? Y/[n]");
+      writeKeys = waitResponse();
+    }
+    applyUpdate(BOOTLOADER_ADDR);
+  } else {
+    Serial.println("It's now safe to reboot or disconnect your board.");
   }
 }
 
@@ -98,17 +151,91 @@ String getClockSource(uint8_t flag) {
   }
 }
 
-void applyUpdate(uint32_t address) {
-  long len = bootloader_mbed_bin_len;
-#if defined(ARDUINO_PORTENTA_H7_M7)
-  if (!video_available) {
-    if (wifi_available) {
-      len = bootloader_mbed_lite_connected_bin_len;
-    } else {
-      len = bootloader_mbed_lite_bin_len;
+void printProgress(uint32_t offset, uint32_t size, uint32_t threshold, bool reset) {
+  static int percent_done = 0;
+  if (reset == true) {
+    percent_done = 0;
+    Serial.println("Flashed " + String(percent_done) + "%");
+  } else {
+    uint32_t percent_done_new = offset * 100 / size;
+    if (percent_done_new >= percent_done + threshold) {
+      percent_done = percent_done_new;
+      Serial.println("Flashed " + String(percent_done) + "%");
     }
   }
-#endif
+}
+
+bool waitResponse() {
+  bool confirmation = false;
+  while (confirmation == false) {
+    if (Serial.available()) {
+      char choice = Serial.read();
+      switch (choice) {
+        case 'y':
+        case 'Y':
+          confirmation = true;
+          return true;
+          break;
+        case 'n':
+        case 'N':
+          confirmation = true;
+          return false;
+          break;
+        default:
+          continue;
+      }
+    }
+  }
+}
+
+void setupMCUBootOTAData() {
+  mbed::MBRBlockDevice ota_data(&root, 2);
+  mbed::FATFileSystem ota_data_fs("fs");
+  
+  int err = ota_data_fs.reformat(&ota_data);
+  if (err) {
+    Serial.println("Error creating MCUBoot files in OTA partition");
+  }
+
+  FILE* fp = fopen("/fs/scratch.bin", "wb");
+  const int scratch_file_size = 128 * 1024;
+  const char buffer[128] = {0xFF};
+  int size = 0;
+
+  Serial.println("\nCreating scratch file");
+  printProgress(size, scratch_file_size, 10, true);
+  while (size < scratch_file_size) {
+    int ret = fwrite(buffer, sizeof(buffer), 1, fp);
+    if (ret != 1) {
+      Serial.println("Error writing scratch file");
+      break;
+    }
+    size += sizeof(buffer);
+    printProgress(size, scratch_file_size, 10, false);
+  }
+  fclose(fp);
+
+  fp = fopen("/fs/update.bin", "wb");
+  const int update_file_size = 15 * 128 * 1024;
+  size = 0;
+
+  Serial.println("\nCreating update file");
+  printProgress(size, update_file_size, 10, true);
+  while (size < update_file_size) {
+    int ret = fwrite(buffer, sizeof(buffer), 1, fp);
+    if (ret != 1) {
+      Serial.println("Error writing scratch file");
+      break;
+    }
+    size += sizeof(buffer);
+    printProgress(size, update_file_size, 5, false);
+  }
+
+  fclose(fp);
+}
+
+void applyUpdate(uint32_t address) {
+  long len = bootloader_len;
 
   flash.init();
 
@@ -133,19 +260,7 @@ void applyUpdate(uint32_t address) {
     }
 
     // Program page
-#if defined(ARDUINO_PORTENTA_H7_M7)
-  if (video_available) {
-    flash.program(&bootloader_mbed_bin[page_size * pages_flashed], addr, page_size);
-  } else {
-    if (wifi_available) {
-      flash.program(&bootloader_mbed_lite_connected_bin[page_size * pages_flashed], addr, page_size);
-    } else {
-      flash.program(&bootloader_mbed_lite_bin[page_size * pages_flashed], addr, page_size);
-    }
-  }
-#else
-  flash.program(&bootloader_mbed_bin[page_size * pages_flashed], addr, page_size);
-#endif
+    flash.program(&bootloader_ptr[page_size * pages_flashed], addr, page_size);
 
     addr += page_size;
     if (addr >= next_sector) {
@@ -161,12 +276,20 @@ void applyUpdate(uint32_t address) {
       }
     }
   }
+
+#if defined(ARDUINO_PORTENTA_H7_M7)
+  if (writeKeys) {
+    flash.program(&enc_priv_key, ENCRYPT_KEY_ADDR, ENCRYPT_KEY_SIZE);
+    flash.program(&ecdsa_pub_key, SIGNING_KEY_ADDR, SIGNING_KEY_SIZE);
+  }
+#endif
+
   Serial.println("Flashed 100%");
 
   delete[] page_buffer;
 
   flash.deinit();
-  Serial.println("Bootloader update complete. You may now disconnect the board.");
+  Serial.println("\nBootloader update complete. It's now safe to reboot or disconnect your board.");
 }
 
 void loop() {

libraries/STM32H747_System/examples/STM32H747_updateBootloader/ecdsa-p256-encrypt-key.h

@@ -0,0 +1,21 @@
+const unsigned char enc_priv_key[] {
+    0x30, 0x81, 0x87, 0x02, 0x01, 0x00, 0x30, 0x13,
+    0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
+    0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d,
+    0x03, 0x01, 0x07, 0x04, 0x6d, 0x30, 0x6b, 0x02,
+    0x01, 0x01, 0x04, 0x20, 0x79, 0x72, 0xb6, 0xf3,
+    0x62, 0x91, 0x09, 0xbb, 0x35, 0x22, 0xb8, 0x54,
+    0x32, 0x3b, 0xfe, 0x1c, 0x9f, 0xa7, 0x10, 0x6f,
+    0xba, 0xaf, 0x73, 0x64, 0xd3, 0xf5, 0x31, 0xbc,
+    0x28, 0xe7, 0xc9, 0x72, 0xa1, 0x44, 0x03, 0x42,
+    0x00, 0x04, 0x6a, 0xc9, 0x20, 0x4c, 0x96, 0xd6,
+    0x89, 0xe8, 0xd1, 0x6e, 0x51, 0x04, 0x02, 0x86,
+    0xe8, 0x95, 0x0b, 0x22, 0xc4, 0xc9, 0x95, 0x06,
+    0x4f, 0xf5, 0x1b, 0xf6, 0xd0, 0xe3, 0x83, 0xd9,
+    0xd1, 0x81, 0x66, 0x6e, 0xf2, 0x07, 0x3b, 0x03,
+    0xdb, 0xe4, 0xd1, 0xde, 0x7c, 0x43, 0x70, 0x8d,
+    0xa2, 0x89, 0xeb, 0x1b, 0xfa, 0xbe, 0x02, 0x5e,
+    0x5c, 0xa0, 0x12, 0xdc, 0x23, 0x31, 0xc1, 0xe0,
+    0x37, 0xb0,
+};
+const unsigned int enc_priv_key_len = 138;

libraries/STM32H747_System/examples/STM32H747_updateBootloader/ecdsa-p256-signing-key.h

@@ -0,0 +1,15 @@
+const unsigned char ecdsa_pub_key[] {
+    0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86,
+    0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a,
+    0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
+    0x42, 0x00, 0x04, 0xd5, 0x16, 0x35, 0x26, 0xc3,
+    0x3b, 0xad, 0x4d, 0x67, 0x8e, 0x43, 0x24, 0xc4,
+    0x98, 0xe9, 0x6b, 0x2e, 0xbe, 0x0d, 0xa3, 0xf1,
+    0xf4, 0x97, 0x80, 0x7b, 0x31, 0x32, 0x07, 0xd9,
+    0x95, 0xa7, 0x17, 0x57, 0x69, 0x43, 0x7b, 0xe9,
+    0xc8, 0xaa, 0xd0, 0x0a, 0x0c, 0x86, 0x0b, 0xe3,
+    0x7f, 0x99, 0x88, 0x51, 0xc4, 0xf9, 0x22, 0x98,
+    0xbe, 0x5e, 0xaa, 0xfd, 0x90, 0x3c, 0xa2, 0x74,
+    0x18, 0x49, 0x05,
+};
+const unsigned int ecdsa_pub_key_len = 91;