Aggiornamenti OTA sicuri su ESP32: partizioni, rollback e firma

Indice
Un aggiornamento OTA (over the air) sicuro su ESP32 si basa su tre elementi: due slot nella flash, così il firmware nuovo si scrive mentre quello vecchio continua a girare; il rollback, che riporta il dispositivo alla versione precedente se quella nuova non supera un controllo al primo avvio; la firma delle immagini, che impedisce di installare firmware non prodotto da te. Con ESP-IDF i primi due richiedono poche righe di configurazione, il terzo una chiave privata custodita bene.
In questo articolo vediamo come si organizza la flash, come scaricare un firmware via HTTPS con esp_https_ota, come scrivere l’autodiagnosi che conferma o scarta la nuova versione e come firmare le immagini. Il codice si riferisce a ESP-IDF v6.1 e funziona su ESP32-C6 ed ESP32-S3. Riprende la struttura del secondo articolo della serie e usa un task e un event group come visto nell’articolo su FreeRTOS.
Come funziona un aggiornamento OTA
La flash di un ESP32 contiene più partizioni, descritte da una tabella scritta all’indirizzo 0x8000. Per gli aggiornamenti OTA servono almeno due partizioni applicative, ota_0 e ota_1, e una piccola partizione dati, otadata, che indica al bootloader quale delle due avviare.

Il ciclo è sempre lo stesso:
- Il firmware in esecuzione, per esempio in
ota_0, scarica la nuova immagine e la scrive inota_1. - A download completato verifica l’immagine e aggiorna
otadataperché punti aota_1. - Al riavvio il bootloader avvia
ota_1. Al successivo aggiornamento i ruoli si invertono.
Se la corrente manca durante il download, ota_0 è intatto e otadata non è ancora cambiata: il dispositivo riparte con la versione precedente. Anche otadata è protetta: occupa due settori da 4 KB, scritti separatamente con gli stessi dati e un contatore. Se una scrittura si interrompe e i due settori non coincidono, il bootloader usa quello scritto più di recente.
Questa robustezza vale solo per le partizioni applicative. ESP-IDF permette di aggiornare via OTA anche il bootloader, la tabella delle partizioni e le partizioni dati, ma in quei casi l’immagine viene prima scaricata in una partizione temporanea e poi copiata nella destinazione: un’interruzione durante la copia può rendere il dispositivo inutilizzabile. Per un prodotto sul campo conviene progettare la tabella delle partizioni in modo da non doverla mai cambiare.
La tabella delle partizioni
ESP-IDF ha alcune tabelle predefinite. Per un dispositivo con OTA e 4 MB di flash la più comoda è Two large size OTA partitions, che si seleziona in menuconfig o con una riga in sdkconfig.defaults. Corrisponde a questo file:
# Name, Type, SubType, Offset, Size, Flags
nvs, data, nvs, , 0x6000,
otadata, data, ota, , 0x2000,
phy_init, data, phy, , 0x1000,
ota_0, app, ota_0, , 1700K,
ota_1, app, ota_1, , 1700K,Le colonne Offset vuote vengono calcolate dallo strumento di build, che allinea le partizioni applicative a 64 KB. Con idf.py partition-table ottieni gli indirizzi finali: in questo caso ota_0 parte da 0x20000 e ota_1 da 0x1D0000.
Due scelte da fare all’inizio del progetto:
- Con o senza partizione
factory. La tabella Factory app, two OTA definitions aggiunge un terzo slot da 1 MB con il firmware di fabbrica, che non viene mai sovrascritto. È utile per un firmware di recupero, ma riduce lo spazio dei due slot e non partecipa al rollback né all’anti-rollback. Per la maggior parte dei dispositivi bastanoota_0eota_1. - Quanto spazio lasciare. Gli slot hanno dimensione fissa e il firmware tende a crescere con le versioni. Se oggi il binario occupa 1,1 MB, uno slot da 1700 KB lascia circa il 35% di margine. Le versioni più comuni delle schede ESP32-C6-DevKitC-1 ed ESP32-S3-DevKitC-1 hanno almeno 8 MB di flash: puoi usare un file
partitions.csvpersonalizzato con slot più grandi.
Le partizioni nvs e phy_init non vengono toccate dall’aggiornamento: configurazioni, credenziali Wi-Fi e calibrazioni sopravvivono al cambio di firmware. Per questo il nuovo firmware deve saper leggere i dati salvati dalla versione precedente.
Il rollback: un solo tentativo per partire
Un firmware nuovo può essere valido dal punto di vista del formato e della firma, ma non funzionare: un bug che blocca l’avvio, un driver che non riconosce una revisione della scheda, un errore nella configurazione del Wi-Fi che impedisce di ricevere la correzione. Il rollback serve proprio a questo.
Con l’opzione CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE il bootloader tiene traccia dello stato di ogni slot:

esp_ota_img_states_t: senza conferma, il nuovo firmware viene scartato al riavvio successivo.- Dopo il download l’immagine è in stato
NEW. - Al riavvio il bootloader la avvia e la porta subito in
PENDING_VERIFY. - Il firmware esegue un’autodiagnosi. Se va bene chiama
esp_ota_mark_app_valid_cancel_rollback()e lo stato diventaVALID. Se fallisce chiamaesp_ota_mark_app_invalid_rollback_and_reboot(): lo slot diventaINVALIDe il dispositivo riparte con la versione precedente. - Se prima della conferma arriva un reset qualsiasi (un crash, un watchdog, un blackout), al riavvio il bootloader trova ancora
PENDING_VERIFY, scriveABORTEDe torna alla versione precedente.
Il nuovo firmware ha quindi un solo tentativo. È un comportamento voluto: un firmware che va in crash durante l’avvio non può entrare in un ciclo infinito di riavvii.
Un dettaglio che sorprende spesso: finché il firmware in esecuzione è in PENDING_VERIFY, non può avviare un nuovo aggiornamento. esp_ota_begin() restituisce ESP_ERR_OTA_ROLLBACK_INVALID_STATE. La conferma deve quindi arrivare prima del controllo degli aggiornamenti.
Cosa controllare nell’autodiagnosi
L’autodiagnosi deve rispondere a una sola domanda: questo firmware è in grado di ricevere il prossimo aggiornamento? Se la risposta è sì, qualunque altro problema si può correggere con una nuova versione. Di solito si verifica che:
- il dispositivo si connetta alla rete e raggiunga il server degli aggiornamenti;
- le periferiche essenziali rispondano: il sensore principale, la memoria esterna, il modem;
- la configurazione salvata in NVS sia leggibile e valida per la nuova versione.
La documentazione di Espressif raccomanda di eseguire l’autodiagnosi il prima possibile, perché un’interruzione di corrente prima della conferma provoca il rollback. C’è un compromesso da valutare: se il controllo include la connessione Wi-Fi e la rete è assente proprio in quel momento, un firmware corretto viene scartato. Non è grave, perché il dispositivo riproverà l’aggiornamento più tardi, ma conviene dare un limite di tempo ragionevole e registrare nel log il motivo del rollback.
Un esempio completo
L’esempio si connette al Wi-Fi, conferma il firmware se è al primo avvio dopo un aggiornamento e ogni sei ore controlla se sul server c’è una versione diversa da quella installata. Il server può essere qualsiasi indirizzo HTTPS che restituisca il file .bin prodotto da idf.py build.
Configurazione del progetto
Il file sdkconfig.defaults, nella cartella del progetto, imposta la tabella delle partizioni e attiva il rollback:
CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
CONFIG_PARTITION_TABLE_TWO_OTA_LARGE=y
CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=yIl rollback è gestito dal bootloader: se attivi l’opzione su dispositivi già installati, devi riprogrammare anche il bootloader via cavo. Per questo va decisa prima della produzione.
La versione del firmware è una stringa che ESP-IDF scrive nell’immagine. Si imposta nel CMakeLists.txt principale, prima di includere project.cmake:
cmake_minimum_required(VERSION 3.22)
set(PROJECT_VER "1.0.0")
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(ota_sicuro)Senza PROJECT_VER, ESP-IDF usa il contenuto del file version.txt o, in mancanza, il risultato di git describe. Nel firmware la leggi con esp_app_get_description()->version.
Rete Wi-Fi e indirizzo del firmware sono opzioni di menuconfig, definite in main/Kconfig.projbuild, così non finiscono nel codice:
menu "Applicazione"
config APP_WIFI_SSID
string "SSID della rete Wi-Fi"
config APP_WIFI_PASSWORD
string "Password della rete Wi-Fi"
config APP_OTA_URL
string "URL HTTPS del firmware"
default "https://firmware.example.com/ota_sicuro.bin"
endmenuIl main/CMakeLists.txt dichiara i componenti usati:
idf_component_register(SRCS "main.c"
INCLUDE_DIRS "."
REQUIRES app_update esp_app_format esp_event esp_http_client
esp_https_ota esp_netif esp_wifi mbedtls nvs_flash)Il codice
Questo è main/main.c:
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_app_desc.h"
#include "esp_crt_bundle.h"
#include "esp_event.h"
#include "esp_https_ota.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "esp_ota_ops.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "nvs_flash.h"
#define WIFI_CONNECTED_BIT BIT0
#define SELF_TEST_TIMEOUT_MS (60 * 1000)
#define OTA_CHECK_PERIOD_MS (6 * 60 * 60 * 1000)
static const char *TAG = "ota";
static EventGroupHandle_t wifi_events;
static void wifi_event_handler(void *arg, esp_event_base_t base, int32_t id, void *data)
{
if (base == WIFI_EVENT &&
(id == WIFI_EVENT_STA_START || id == WIFI_EVENT_STA_DISCONNECTED)) {
xEventGroupClearBits(wifi_events, WIFI_CONNECTED_BIT);
esp_wifi_connect(); // Riprova a ogni disconnessione
} else if (base == IP_EVENT && id == IP_EVENT_STA_GOT_IP) {
xEventGroupSetBits(wifi_events, WIFI_CONNECTED_BIT);
}
}
static void wifi_start(void)
{
wifi_events = xEventGroupCreate();
ESP_ERROR_CHECK(esp_netif_init());
ESP_ERROR_CHECK(esp_event_loop_create_default());
esp_netif_create_default_wifi_sta();
wifi_init_config_t init = WIFI_INIT_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_wifi_init(&init));
ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID,
wifi_event_handler, NULL));
ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP,
wifi_event_handler, NULL));
wifi_config_t config = { 0 };
strlcpy((char *)config.sta.ssid, CONFIG_APP_WIFI_SSID, sizeof(config.sta.ssid));
strlcpy((char *)config.sta.password, CONFIG_APP_WIFI_PASSWORD,
sizeof(config.sta.password));
ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &config));
ESP_ERROR_CHECK(esp_wifi_start());
}
// Il nuovo firmware è in grado di ricevere il prossimo aggiornamento?
static bool self_test(void)
{
EventBits_t bits = xEventGroupWaitBits(wifi_events, WIFI_CONNECTED_BIT, pdFALSE,
pdTRUE, pdMS_TO_TICKS(SELF_TEST_TIMEOUT_MS));
if (!(bits & WIFI_CONNECTED_BIT)) {
ESP_LOGE(TAG, "Autodiagnosi: nessuna connessione entro %d s",
SELF_TEST_TIMEOUT_MS / 1000);
return false;
}
// Qui vanno i controlli del tuo dispositivo: sensori, memoria, configurazione.
return true;
}
static void confirm_or_rollback(void)
{
const esp_partition_t *running = esp_ota_get_running_partition();
esp_ota_img_states_t state;
if (esp_ota_get_state_partition(running, &state) != ESP_OK ||
state != ESP_OTA_IMG_PENDING_VERIFY) {
return; // Non è il primo avvio dopo un aggiornamento
}
if (self_test()) {
ESP_ERROR_CHECK(esp_ota_mark_app_valid_cancel_rollback());
ESP_LOGI(TAG, "Nuovo firmware confermato");
} else {
ESP_LOGE(TAG, "Autodiagnosi fallita: torno alla versione precedente");
esp_ota_mark_app_invalid_rollback_and_reboot();
}
}
static esp_err_t ota_update(void)
{
esp_http_client_config_t http = {
.url = CONFIG_APP_OTA_URL,
.crt_bundle_attach = esp_crt_bundle_attach, // Verifica il certificato del server
.timeout_ms = 10000,
.keep_alive_enable = true,
};
esp_https_ota_config_t config = { .http_config = &http };
esp_https_ota_handle_t ota = NULL;
esp_err_t err = esp_https_ota_begin(&config, &ota);
if (err != ESP_OK) {
return err;
}
// L'intestazione arriva con i primi byte: si decide prima di scaricare tutto.
esp_app_desc_t incoming;
err = esp_https_ota_get_img_desc(ota, &incoming);
if (err != ESP_OK) {
esp_https_ota_abort(ota);
return err;
}
const char *current = esp_app_get_description()->version;
if (strncmp(incoming.version, current, sizeof(incoming.version)) == 0) {
ESP_LOGI(TAG, "Nessun aggiornamento: la versione %s è già installata", current);
esp_https_ota_abort(ota);
return ESP_OK;
}
ESP_LOGI(TAG, "Scarico la versione %s (installata: %s)", incoming.version, current);
do {
err = esp_https_ota_perform(ota);
} while (err == ESP_ERR_HTTPS_OTA_IN_PROGRESS);
if (err != ESP_OK || !esp_https_ota_is_complete_data_received(ota)) {
esp_https_ota_abort(ota);
return err != ESP_OK ? err : ESP_FAIL;
}
// Verifica l'immagine (e la firma, se attiva) e aggiorna otadata.
err = esp_https_ota_finish(ota);
if (err != ESP_OK) {
return err;
}
ESP_LOGI(TAG, "Aggiornamento installato: riavvio");
esp_restart();
return ESP_OK; // Non raggiunto
}
static void ota_task(void *arg)
{
confirm_or_rollback(); // Sempre prima del controllo degli aggiornamenti
while (true) {
xEventGroupWaitBits(wifi_events, WIFI_CONNECTED_BIT, pdFALSE, pdTRUE,
portMAX_DELAY);
esp_err_t err = ota_update();
if (err != ESP_OK) {
ESP_LOGW(TAG, "Aggiornamento non riuscito: %s", esp_err_to_name(err));
}
vTaskDelay(pdMS_TO_TICKS(OTA_CHECK_PERIOD_MS));
}
}
void app_main(void)
{
ESP_LOGI(TAG, "Firmware %s avviato dalla partizione %s",
esp_app_get_description()->version,
esp_ota_get_running_partition()->label);
esp_err_t err = nvs_flash_init();
if (err == ESP_ERR_NVS_NO_FREE_PAGES || err == ESP_ERR_NVS_NEW_VERSION_FOUND) {
// Solo dopo un cambio della tabella delle partizioni: cancella i dati salvati.
ESP_ERROR_CHECK(nvs_flash_erase());
err = nvs_flash_init();
}
ESP_ERROR_CHECK(err);
wifi_start();
xTaskCreate(ota_task, "ota", 8192, NULL, 5, NULL);
}Le scelte del codice
- La conferma arriva prima di tutto.
ota_taskchiamaconfirm_or_rollback()come prima istruzione: finché il firmware non è confermato, un nuovo aggiornamento non può partire. - Un crash all’avvio provoca il rollback. Se una delle chiamate
ESP_ERROR_CHECK()fallisce nel nuovo firmware, il dispositivo si riavvia prima della conferma e il bootloader torna alla versione precedente. Non serve gestire questi casi a parte. - La versione si controlla dall’intestazione.
esp_https_ota_get_img_desc()legge la descrizione dell’immagine dai primi byte scaricati: se la versione è la stessa, il download si interrompe prima di scrivere nella flash. - Una versione diversa, non una versione maggiore. Il confronto accetta anche un firmware più vecchio: così, per ritirare una versione difettosa, basta pubblicare di nuovo la precedente sul server. Per impedire il ritorno a versioni vulnerabili c’è l’anti-rollback, che vediamo più avanti.
- Il server è verificato. Con
crt_bundle_attachil client controlla il certificato HTTPS con il bundle di certificati radice incluso in ESP-IDF, attivo per impostazione predefinita. Se il server usa un certificato interno, passa il certificato radice incert_pem. - Il controllo è periodico e distribuito. Ogni dispositivo controlla gli aggiornamenti sei ore dopo l’ultimo tentativo, quindi gli orari si distribuiscono in base all’accensione. Per una flotta numerosa, un ritardo casuale evita che tutti i dispositivi scarichino nello stesso momento.
Per provare il rollback, compila una versione 1.0.1 in cui self_test() restituisce sempre false, pubblica il file build/ota_sicuro.bin sul server e attendi il controllo successivo. Il monitor mostrerà il download, il riavvio, l’autodiagnosi fallita e il ritorno alla 1.0.0. Per non aspettare sei ore durante le prove, riduci OTA_CHECK_PERIOD_MS.
Il primo firmware si programma via cavo con idf.py -p PORT flash, che scrive bootloader, tabella delle partizioni e applicazione. Da quel momento i successivi possono arrivare via rete.
La firma delle immagini
HTTPS protegge il canale: garantisce che il file arrivi dal tuo server senza modifiche. Non protegge da un server compromesso, da un DNS manipolato con un certificato emesso per errore o da un URL modificato in NVS. La firma sposta la fiducia dal server alla chiave: il dispositivo installa solo immagini firmate con la tua chiave privata, chiunque le abbia distribuite.
ESP-IDF offre due livelli, con lo stesso formato di firma.
Firma senza Secure Boot
Le opzioni CONFIG_SECURE_SIGNED_APPS_NO_SECURE_BOOT e CONFIG_SECURE_SIGNED_ON_UPDATE_NO_SECURE_BOOT fanno firmare le immagini durante la build e verificano la firma di ogni aggiornamento OTA prima di accettarlo:
CONFIG_SECURE_SIGNED_APPS_NO_SECURE_BOOT=y
CONFIG_SECURE_SIGNED_ON_UPDATE_NO_SECURE_BOOT=y
CONFIG_SECURE_SIGNED_APPS_RSA_SCHEME=y
CONFIG_SECURE_BOOT_SIGNING_KEY="chiavi/firma_firmware.pem"Se la firma non è valida, esp_https_ota_finish() restituisce ESP_ERR_OTA_VALIDATE_FAILED e otadata non cambia. Non si scrive nessun eFuse e la configurazione resta reversibile: è il punto di partenza consigliato durante lo sviluppo. Il limite è che protegge dagli attacchi via rete, non da chi ha accesso fisico alla scheda e può riprogrammare il bootloader via cavo.
Secure Boot v2
Con Secure Boot v2 la verifica diventa parte della catena di avvio. La ROM del chip verifica la firma del bootloader, il bootloader verifica la firma dell’applicazione a ogni avvio e a ogni aggiornamento. Il digest SHA-256 della chiave pubblica viene scritto negli eFuse del chip: da quel momento il dispositivo accetta solo codice firmato con quella chiave, anche se programmato via cavo.
Gli schemi disponibili dipendono dal chip:
| Chip | Schemi Secure Boot v2 | Note |
|---|---|---|
| ESP32-S3 | RSA-3072 | Unico schema disponibile |
| ESP32-C6 | RSA-3072 o ECDSA P-256 | La ROM verifica il bootloader in circa 10,2 ms con RSA e 83,9 ms con ECDSA, con la CPU a 40 MHz |
Su ESP32-C6 la documentazione consiglia RSA quando conta il tempo di avvio ed ECDSA quando conta la lunghezza della chiave. Su un chip si può usare un solo schema, e si possono registrare fino a tre chiavi pubbliche, revocabili singolarmente: è il meccanismo per sostituire una chiave compromessa senza buttare il dispositivo.
Prima di attivarlo su una scheda, tieni presente che:
- è irreversibile. Gli eFuse si programmano una sola volta: se perdi la chiave privata, il dispositivo non accetterà più nessun firmware;
- il bootloader non si programma più con
idf.py flash. La build stampa il comando per scriverlo, da eseguire a mano una volta; - il download via UART passa in modalità sicura per impostazione predefinita; per i prodotti finiti la documentazione indica come scelta più sicura disabilitarlo del tutto;
- non cifra niente. La firma garantisce l’origine del codice, ma il firmware resta leggibile da chi legge la flash. Per proteggere il codice e i dati salvati va attivata anche la cifratura della flash (flash encryption).
Fai le prove su una scheda dedicata, che consideri sacrificabile, e passa ai dispositivi di produzione solo con una procedura scritta.
Generare e custodire la chiave
idf.py secure-generate-signing-key crea una chiave adatta alle prove. Per la produzione la documentazione raccomanda di generarla con OpenSSL su un sistema con una buona sorgente di entropia:
openssl genrsa -out firma_firmware.pem 3072Per lo schema ECDSA su ESP32-C6 il comando è openssl ecparam -name prime256v1 -genkey -noout -out firma_firmware.pem.
La sicurezza dell’intero sistema dipende dalla segretezza di questo file. Non va nel repository, non va in un’immagine Docker e, idealmente, non va nemmeno sulla macchina che compila. ESP-IDF supporta la firma remota: disattivando CONFIG_SECURE_BOOT_BUILD_SIGNED_BINARIES la build produce un binario non firmato, che si firma poi su una macchina separata o con un modulo hardware di sicurezza (HSM):
idf.py secure-sign-data --keyfile firma_firmware.pem --output ota_sicuro_firmato.bin build/ota_sicuro.binIn una pipeline di integrazione continua, il passaggio di firma è il punto in cui una persona autorizza la pubblicazione di una versione.
Anti-rollback: impedire il ritorno a versioni vulnerabili
Il rollback e la firma da soli lasciano aperta una porta: un attaccante può installare una vecchia versione firmata che contiene una vulnerabilità già corretta. L’anti-rollback la chiude.
Con CONFIG_BOOTLOADER_APP_ANTI_ROLLBACK ogni immagine porta un numero di sicurezza, impostato con CONFIG_BOOTLOADER_APP_SECURE_VERSION, distinto dalla versione visibile all’utente. Il chip conserva negli eFuse il numero più alto confermato e il bootloader rifiuta le immagini con un numero inferiore. Quando un firmware con un numero più alto viene confermato da esp_ota_mark_app_valid_cancel_rollback(), il valore negli eFuse si aggiorna.
Tre regole pratiche:
- Aumenta il numero di sicurezza solo per le correzioni di sicurezza, non a ogni versione. Il campo negli eFuse è limitato: di base consente 16 incrementi in tutta la vita del dispositivo.
- Aumentalo solo dopo aver verificato la versione sul campo. Dopo l’incremento, il rollback è possibile solo verso versioni con lo stesso numero.
- Non usare una partizione
factory. Lo schema di anti-rollback non la supporta.
Per evitare download inutili, puoi confrontare incoming.secure_version con esp_efuse_read_secure_version() subito dopo esp_https_ota_get_img_desc() e interrompere se è inferiore.
Checklist prima della produzione
- Tabella delle partizioni con due slot OTA e un margine di spazio per le versioni future: non potrai cambiarla in sicurezza dopo.
CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLEattivo e un’autodiagnosi che verifichi almeno la capacità di ricevere il prossimo aggiornamento.- Download solo via HTTPS, con verifica del certificato del server.
- Immagini firmate: almeno con la verifica senza Secure Boot; con Secure Boot v2 e cifratura della flash se il dispositivo è esposto ad accessi fisici.
- Chiave privata fuori dal repository e dalla macchina di build, con una copia di sicurezza custodita.
- Anti-rollback pianificato, con una regola scritta su quando aumentare il numero di sicurezza.
- Una prova di rollback reale per ogni nuova versione del bootloader o della tabella delle partizioni.
Nel prossimo articolo della serie misureremo i consumi in deep sleep e vedremo come scendere sotto i 10 µA, anche in un dispositivo che controlla gli aggiornamenti.
Fonti
- Over The Air Updates (OTA), Espressif Systems
- ESP HTTPS OTA, Espressif Systems
- Partition Tables, Espressif Systems
- Secure Boot v2 per ESP32-C6 ed ESP32-S3, Espressif Systems
- Flash Encryption, Espressif Systems
- Esempio advanced_https_ota, ESP-IDF v6.1