Aggiornamenti OTA sicuri su ESP32: partizioni, rollback e firma

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.

Mappa di una flash da 4 MB: bootloader all’indirizzo 0x0, tabella delle partizioni a 0x8000, nvs, otadata e phy_init, poi ota_0 a 0x20000 con il firmware in esecuzione e ota_1 a 0x1D0000 che riceve la nuova versione; otadata indica oggi ota_0 e, dopo l’aggiornamento, ota_1
Il firmware in esecuzione non viene mai sovrascritto: la nuova versione va nell’altro slot.

Il ciclo è sempre lo stesso:

  1. Il firmware in esecuzione, per esempio in ota_0, scarica la nuova immagine e la scrive in ota_1.
  2. A download completato verifica l’immagine e aggiorna otadata perché punti a ota_1.
  3. 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:

Testo
# 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 bastano ota_0 e ota_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.csv personalizzato 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:

Diagramma degli stati: dopo esp_https_ota_finish l’immagine è NEW; al riavvio il bootloader la porta in PENDING_VERIFY; se l’autodiagnosi riesce diventa VALID, se fallisce diventa INVALID, se avviene un reset prima della conferma diventa ABORTED; negli ultimi due casi il bootloader avvia di nuovo il firmware precedente
Gli stati di 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 diventa VALID. Se fallisce chiama esp_ota_mark_app_invalid_rollback_and_reboot(): lo slot diventa INVALID e 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, scrive ABORTED e 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:

Configurazione
CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
CONFIG_PARTITION_TABLE_TWO_OTA_LARGE=y
CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=y

Il 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
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:

Configurazione
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"

endmenu

Il main/CMakeLists.txt dichiara i componenti usati:

CMake
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:

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_task chiama confirm_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_attach il 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 in cert_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:

Configurazione
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:

Terminale
openssl genrsa -out firma_firmware.pem 3072

Per 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):

Terminale
idf.py secure-sign-data --keyfile firma_firmware.pem --output ota_sicuro_firmato.bin build/ota_sicuro.bin

In 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_ENABLE attivo 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