feat(security): finalize P10 CFI hardening & multi-stage boot protections

Author: mannomannX

CMakeLists.txt

@@ -129,7 +129,10 @@ if(TARGET toob_crypto_upstream)
     target_link_libraries(toob_stage1 PRIVATE toob_crypto toob_crypto_upstream)
 endif()
 
-# 5.3.5 eFuse Link-Time Mocking Strategy (P10 Anti-Brick)
+# 5.3.5 Cloud Command Pipeline
+option(TOOB_FEATURE_CLOUD_COMMANDS "Enable Cloud Command Pipeline" ON)
+
+# 5.3.6 eFuse Link-Time Mocking Strategy (P10 Anti-Brick)
 option(TOOB_MOCK_EFUSES "Use Link-Time Mocking for eFuses" ON)
 if(TOOB_MOCK_EFUSES)
     add_compile_definitions(TOOB_MOCK_EFUSES=1)

cli/examples/manifests/device.toml

@@ -1,4 +1,5 @@
 [device]
+vendor = "espressif"
 chip = "esp32c6"
 
 [partitions]

cli/suit/toob_cloud_cmd.cddl

@@ -0,0 +1,8 @@
+toob_cloud_cmd = {
+    1: bstr .size 32,    ; device_id (SHA-256 Hash)
+    2: uint .size 1,     ; command (toob_cloud_cmd_t enum)
+    3: uint .size 4,     ; counter_min (Anti-Replay)
+    4: uint .size 4,     ; issued_at (Unix Timestamp)
+    ? 5: bstr,           ; params (optional, command-specific)
+    101: bstr .size 64,  ; signature_ed25519 (EdDSA Signatur über den Rest der Map)
+}

cli/toob-cli/internal/suit/generator.go

@@ -36,10 +36,13 @@ func Generate(outputDir, compilerRoot, projectRoot, cliVersion string) error {
 		ui.Step("zcbor CLI found locally. Generating strict parsers...")
 	}
 
+	cloudCmdCddl := filepath.Join(compilerRoot, "cli", "suit", "toob_cloud_cmd.cddl")
+
 	commands := [][]string{
 		{"code", "-c", suitCddl, "--decode", "-t", "toob_suit", "--output-c", filepath.Join(outputDir, "boot_suit.c"), "--output-h", filepath.Join(outputDir, "boot_suit.h")},
 		{"code", "-c", telemCddl, "--decode", "-t", "toob_telemetry", "--output-c", filepath.Join(outputDir, "toob_telemetry_decode.c"), "--output-h", filepath.Join(outputDir, "toob_telemetry_decode.h")},
 		{"code", "-c", telemCddl, "--encode", "-t", "toob_telemetry", "--output-c", filepath.Join(outputDir, "toob_telemetry_encode.c"), "--output-h", filepath.Join(outputDir, "toob_telemetry_encode.h")},
+		{"code", "-c", cloudCmdCddl, "--decode", "-t", "toob_cloud_cmd", "--output-c", filepath.Join(outputDir, "boot_cloud_cmd_decode.c"), "--output-h", filepath.Join(outputDir, "boot_cloud_cmd_decode.h")},
 	}
 
 	for _, args := range commands {

cmake/toob_core.cmake

@@ -55,13 +55,15 @@ target_include_directories(toob_heatshrink PUBLIC common/lib/heatshrink)
 # die Datei zur Evaluierungszeit evtl. noch gar nicht im Filebaum liegt.
 set(GENERATED_SUIT_C "${CMAKE_BINARY_DIR}/generated/boot_suit.c")
 set(GENERATED_TELEMETRY_ENCODE_C "${CMAKE_BINARY_DIR}/generated/toob_telemetry_encode.c")
-set_source_files_properties(${GENERATED_SUIT_C} ${GENERATED_TELEMETRY_ENCODE_C} PROPERTIES GENERATED TRUE)
+set(GENERATED_CLOUD_CMD_C "${CMAKE_BINARY_DIR}/generated/boot_cloud_cmd_decode.c")
+set_source_files_properties(${GENERATED_SUIT_C} ${GENERATED_TELEMETRY_ENCODE_C} ${GENERATED_CLOUD_CMD_C} PROPERTIES GENERATED TRUE)
 
 # M-BUILD GAP-Fix: Custom Command zum Aufrufen der SUIT & Config Generation
 add_custom_command(
     OUTPUT ${GENERATED_SUIT_C}
            ${CMAKE_BINARY_DIR}/generated/toob_telemetry_decode.c
            ${GENERATED_TELEMETRY_ENCODE_C}
+           ${GENERATED_CLOUD_CMD_C}
            ${CMAKE_BINARY_DIR}/generated/generated_boot_config.h
            ${CMAKE_BINARY_DIR}/generated/stage0_layout.ld
     COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/generated
@@ -80,11 +82,16 @@ add_custom_command(
 add_custom_target(generate_manifest
     DEPENDS ${GENERATED_SUIT_C}
             ${CMAKE_BINARY_DIR}/generated/toob_telemetry_decode.c
+            ${GENERATED_CLOUD_CMD_C}
             ${CMAKE_BINARY_DIR}/generated/generated_boot_config.h
             ${CMAKE_BINARY_DIR}/generated/stage0_layout.ld
 )
 
 
+# P10 Krypto-Härtung: Optionale echte Double-Execution der Ed25519 Verifikation.
+# Detektiert auch algorithmus-interne Faults auf Kosten von ~30-50ms Boot-Zeit.
+option(TOOB_DOUBLE_VERIFY "Enable double-execution of Ed25519 for highest fault resistance (~+30ms)" OFF)
+
 add_library(toob_core STATIC
     ${TOOB_CORE_DIR}/boot_main.c
     ${TOOB_CORE_DIR}/boot_state.c
@@ -95,13 +102,18 @@ add_library(toob_core STATIC
     ${TOOB_CORE_DIR}/boot_swap.c
     ${TOOB_CORE_DIR}/boot_delta.c
     ${TOOB_CORE_DIR}/boot_rollback.c
+    ${TOOB_CORE_DIR}/boot_cobs.c
     ${TOOB_CORE_DIR}/boot_panic.c
+    ${TOOB_CORE_DIR}/boot_provisioning.c
     ${TOOB_CORE_DIR}/boot_confirm.c
     ${TOOB_CORE_DIR}/boot_diag.c
     ${TOOB_CORE_DIR}/boot_energy.c
     ${TOOB_CORE_DIR}/boot_multiimage.c
+    ${TOOB_CORE_DIR}/boot_identity.c
     ${TOOB_CORE_DIR}/boot_delay.c
+    ${TOOB_CORE_DIR}/boot_cloud_cmd.c
     ${GENERATED_SUIT_C}
+    ${GENERATED_CLOUD_CMD_C}
 )
 
 # Harte Abhängigkeits-Schranke: Schützt vor Race-Conditions bei parallelen Builds (ninja -j8)!
@@ -120,6 +132,10 @@ else()
     target_compile_definitions(toob_core PUBLIC TOOB_MOCK_TEST)
 endif()
 
+if(TOOB_DOUBLE_VERIFY)
+    target_compile_definitions(toob_core PRIVATE TOOB_DOUBLE_VERIFY=1)
+endif()
+
 # ------------------------------------------------------------------------------
 # 3. Include-Pfade & Linking & Härtung
 # ------------------------------------------------------------------------------

cmake/toob_libtoob.cmake

@@ -21,6 +21,7 @@
 add_library(toob_libtoob STATIC
     ${TOOB_SDK_DIR}/libtoob/toob_confirm.c
     ${TOOB_SDK_DIR}/libtoob/toob_update.c
+    ${TOOB_SDK_DIR}/libtoob/toob_cloud_submit.c
     ${TOOB_SDK_DIR}/libtoob/toob_diag.c
     ${TOOB_SDK_DIR}/libtoob/toob_handoff.c
     ${TOOB_SDK_DIR}/libtoob/toob_ota.c

cmake/toob_stage0.cmake

@@ -57,6 +57,10 @@ endif()
 
 target_compile_definitions(toob_stage0 PRIVATE TOOB_MINIMAL_CRYPTO=1)
 
+if(TOOB_ARCH STREQUAL "host" OR CMAKE_BUILD_TYPE STREQUAL "Debug")
+    target_compile_definitions(toob_stage0 PRIVATE TOOB_ALLOW_DEV_BYPASS=1)
+endif()
+
 # 2. Toob-Boot Core-Includes verfügbar machen (boot_types.h) + Generiertes Config
 target_include_directories(toob_stage0 PRIVATE
     ${TOOB_STAGE0_DIR}/include

common/include/boot_hal.h

@@ -22,6 +22,9 @@
 #include <stddef.h>
 #include <stdint.h>
 
+/* RTC-Backup Register Slot Allocation */
+#define RTC_SLOT_AUTH_ATTEMPTS 0
+
 /* --- 1. Flash HAL (Non-Volatile Storage) --- */
 
 #define TOOB_HAL_ABI_V2 0x02000000
@@ -139,13 +142,27 @@ typedef struct {
       const uint8_t *pubkey, size_t pubkey_len);
 
   /* RNG */
+  /**
+   * @brief Generate cryptographic random bytes.
+   * HAL-Contract: Die Implementierung MUSS NIST SP 800-90B
+   * Repetition Count und Adaptive Proportion Tests intern
+   * durchführen. Bei Versagen: BOOT_ERR_CRYPTO zurückgeben.
+   */
   boot_status_t (*random)(uint8_t *buf, size_t len);
 
   uint32_t (*get_last_vendor_error)(void);
 
   /* Hardware Roots (eFuse / OTP) */
   boot_status_t (*read_pubkey)(uint8_t *key, size_t key_len, uint8_t key_index);
+  boot_status_t (*read_chip_uid)(uint8_t *buf, size_t max_len, size_t *out_len);
   boot_status_t (*read_dslc)(uint8_t *buffer, size_t *len);
+  boot_status_t (*write_dslc)(const uint8_t *value, size_t len);
+  /**
+   * @brief Read hardware monotonic counter.
+   * HAL-Contract: Die Implementierung MUSS den gelesenen Wert intern
+   * durch Komplement-Prüfung (read + read_inverted) validieren und
+   * bei Diskrepanz BOOT_ERR_VERIFY zurückgeben.
+   */
   boot_status_t (*read_monotonic_counter)(uint32_t *ctr);
   boot_status_t (*advance_monotonic_counter)(void);
 
@@ -226,9 +243,32 @@ typedef struct {
    */
   bool (*get_recovery_pin_state)(void);
 
+  /**
+   * @brief Power-Cycle-Resiliente RTC-Backup Register.
+   * HAL-Contract: Werte MÜSSEN über Brownout/Software-Reset hinweg
+   * erhalten bleiben. Bei Hardware ohne RTC-Backup: NULL setzen.
+   */
+  boot_status_t (*read_rtc_backup)(uint8_t slot, uint32_t *value);
+  boot_status_t (*write_rtc_backup)(uint8_t slot, uint32_t value);
+
   uint32_t min_battery_mv;
 } soc_hal_t;
 
+/* --- 8. Provisioning HAL (Factory & Lifecycle) --- */
+
+/**
+ * @brief Factory Provisioning and Key-Lock Interface
+ * Extracted from crypto_hal_t to enforce separation of concerns and
+ * ensure that normal firmware cannot accidentally write eFuses.
+ */
+typedef struct {
+    boot_status_t (*burn_pubkey)(const uint8_t *key, size_t len, uint8_t index);
+    boot_status_t (*write_dslc)(uint8_t value);
+    boot_status_t (*set_protection_bits)(uint32_t bitmask);
+    boot_status_t (*enable_secure_boot)(void);
+    boot_status_t (*enable_flash_encryption)(void);
+} provisioning_hal_t;
+
 /* --- Master Platform Container --- */
 
 /**
@@ -241,8 +281,9 @@ typedef struct {
   const crypto_hal_t *crypto;   /**< PFLICHT */
   const clock_hal_t *clock;     /**< PFLICHT */
   const wdt_hal_t *wdt;         /**< PFLICHT */
-  const console_hal_t *console; /**< Optional */
-  const soc_hal_t *soc;         /**< Optional */
+  const console_hal_t *console;           /**< Optional */
+  const soc_hal_t *soc;                   /**< Optional */
+  const provisioning_hal_t *provisioning; /**< Optional */
 } boot_platform_t;
 
 /**

common/include/boot_types.h

@@ -68,7 +68,12 @@ typedef enum {
     BOOT_ERR_WAL_LOCKED        = 0xF5C5C5C5,  /**< Transaktion über WAL-Grenzen verboten */
     BOOT_RECOVERY_REQUESTED    = 0xF6D6D6D6,  /**< Manueller/Hardware-Ausgelöster Fallback auf Serial Rescue */
     BOOT_ERR_ABI_MISMATCH      = 0xF7E7E7E7,  /**< HAL ABI-Version eines Structs ist zu alt/inkompatibel */
-    BOOT_ERR_DOWNGRADE         = 0xF8F8F8F8   /**< Hybrid SVN Check fehlgeschlagen (Anti-Rollback) */
+    BOOT_ERR_DOWNGRADE         = 0xF8F8F8F8,  /**< Hybrid SVN Check fehlgeschlagen (Anti-Rollback) */
+    
+    /* Cloud Command Errors */
+    BOOT_ERR_DEVICE_LOCKED       = 0xF9090909,
+    BOOT_ERR_CMD_REPLAY          = 0xFA1A1A1A,
+    BOOT_ERR_CMD_DEVICE_MISMATCH = 0xFB2B2B2B
 } boot_status_t;
 
 /* --- 2. Hardware Reset Reasons --- */
@@ -88,6 +93,20 @@ typedef enum {
   RESET_REASON_HARD_FAULT = 6 /**< CPU Exception Triggered */
 } reset_reason_t;
 
+/* --- 2.5 Cloud Command Types --- */
+
+/**
+ * @brief Identifiziert den Typ eines signierten Cloud Commands.
+ */
+typedef enum {
+    TOOB_CMD_FORCE_UPDATE  = 0x01,
+    TOOB_CMD_KILLSWITCH    = 0x02,
+    TOOB_CMD_UNLOCK        = 0x03,
+    TOOB_CMD_ROTATE_KEY    = 0x04,
+    TOOB_CMD_WIPE          = 0x05,
+    TOOB_CMD_REVOKE        = 0x06,
+} toob_cloud_cmd_t;
+
 /* --- 3. Stage 1 / Stage 0 Communication & Identity --- */
 
 /**

docs/plan.md

@@ -0,0 +1,137 @@
+Hier ist mein Vorschlag für die Implementierungsreihenfolge, optimiert auf minimale Merge-Konflikte und maximale Testbarkeit nach jeder Phase.
+
+---
+
+## Phase 1: ABI-Fundament (Types, TMR, Handoff)
+
+**Warum zuerst:** Jede spätere Phase baut auf diesen Typen und Struct-Layouts auf. Fehler hier propagieren in alles.
+
+**Kritische Dateien:**
+
+`common/include/boot_types.h` — Neue Enums (`toob_cloud_cmd_t`, `BOOT_ERR_DEVICE_LOCKED`, `BOOT_ERR_CMD_REPLAY`, `BOOT_ERR_CMD_DEVICE_MISMATCH`), neuer WAL-Intent (`WAL_INTENT_CLOUD_CMD = 12`, `WAL_INTENT_DEVICE_LOCKED = 13`). Agent muss die Hamming-Distance-Konvention der Error-Codes strikt einhalten und die bestehenden `_Static_assert`-Ketten nicht brechen.
+
+`toobloader/core/include/boot_journal.h` — `wal_tmr_payload_t` wächst um `uint32_t kdm_sequence` und `uint32_t active_kdm_slot`. Die `_Static_assert(sizeof(wal_tmr_payload_t) == 40, ...)` muss auf den neuen Wert (48) aktualisiert werden. **Höchste Vorsicht:** Der `wal_sector_header_t` enthält die TMR inline und hat ebenfalls eine harte Size-Assert auf 64 Bytes. Die `_padding[8]` muss um die 8 zusätzlichen TMR-Bytes schrumpfen oder der Header wächst — beides hat Kaskadeneffekte auf das gesamte WAL-Layout.
+
+`sdk/libtoob/include/libtoob_types.h` — `toob_handoff_t` bekommt `uint8_t device_id[32]` und `uint8_t wipe_requested`. Die Size-Assert (aktuell 40) und der `crc32_trailer`-Offset-Assert müssen synchron aktualisiert werden. `TOOB_HANDOFF_STRUCT_VERSION` geht auf `0x02000000`. Parallel die `toob_wal_sector_header_t` mit dem `_reserved_tmr_space` anpassen (aktuell 40 Bytes, muss zum neuen TMR passen).
+
+`common/include/boot_hal.h` — `crypto_hal_t` bekommt den neuen Pflicht-Pointer `read_chip_uid`. Optional: `provisioning_hal_t` als neues Struct definieren (kann aber auch Phase H sein).
+
+**Validierung nach Phase 1:** Sandbox-Build (`TOOB_ARCH=host`) muss sauber kompilieren. Alle `_Static_assert`s in `boot_journal.h`, `libtoob_types.h` und `boot_types.h` müssen passen. Bestehende Sandbox-Tests dürfen nicht brechen.
+
+---
+
+## Phase 2: Stage 0 DSLC-Gate
+
+**Warum hier:** Unabhängig von allen anderen Phasen, kleiner Scope, sofort testbar. Blockiert keine anderen Arbeiten.
+
+**Kritische Dateien:**
+
+`toobloader/stage0/stage0_main.c` — Der Majority-Vote DSLC-Check wird **nach** `platform->crypto->init()` und **vor** `stage0_get_active_slot()` eingefügt. Agent muss beachten, dass `stage0_main.c` einen eigenen `boot_panic`-Stub hat (kein echtes Panic-System). Die neue `dead_halt()` muss als `_Noreturn static void` in dieselbe Datei. Der Development-Mode-Bypass (DSLC=0x00 + kein Key) greift in die existierende Signatur-Prüfung bei Punkt 8 ein.
+
+`toobloader/stage0/include/stage0_crypto.h` — Keine neue Funktion nötig, `read_dslc` kommt über `platform->crypto`.
+
+**Achtung:** Stage 0 hat keinen Zugriff auf `boot_journal.h` oder die WAL-Infrastruktur. Der Agent darf keine Core-Header einziehen. Stage 0 nutzt ausschließlich `boot_types.h`, `boot_hal.h`, `boot_crc32.h` und seinen eigenen `stage0_crypto.h`.
+
+---
+
+## Phase 3: CDDL-Schema + zcbor-Codegen
+
+**Warum hier:** Die C-Strukturen für Cloud-Commands müssen existieren, bevor `boot_cloud_cmd.c` geschrieben werden kann.
+
+**Kritische Dateien:**
+
+Neue CDDL-Datei (z.B. `cddl/toob_cloud_cmd.cddl`) — Das Schema aus dem Plan. Agent muss sicherstellen, dass das zcbor-Codegen-Tooling (referenziert in `cmake/toob_core.cmake` unter `generate_manifest`) diese Datei mit aufnimmt.
+
+`cmake/toob_core.cmake` — Der `add_custom_command` für `generate_manifest` muss den neuen CDDL-Input verarbeiten und `boot_cloud_cmd_types.h` / `boot_cloud_cmd_decode.c` generieren. Alternativ die Go-CLI erweitern.
+
+`CMakeLists.txt` — Die neue `TOOB_FEATURE_CLOUD_COMMANDS`-Option einfügen, die `boot_cloud_cmd.c` bedingt kompiliert.
+
+---
+
+## Phase 4: Device-ID Derivation
+
+**Warum hier:** Wird von Phase 5 (Cloud-Command-Verifikation) als Device-ID-Match benötigt, hat aber selbst keine Abhängigkeit auf die Command-Pipeline.
+
+**Kritische Dateien:**
+
+Neue Datei `toobloader/core/boot_identity.c` + `toobloader/core/include/boot_identity.h` — Implementiert `boot_derive_device_id(platform, out_id[32])`. Nutzt `platform->crypto->read_chip_uid()`, `platform->crypto->read_pubkey()` (Index 0), und `platform->crypto->hash_*()`. Agent muss den Domain-Separator-String `"toob-device-id-v1"` exakt wie spezifiziert einhashen.
+
+`toobloader/core/boot_main.c` — In Block 5 (Handoff) die Device-ID berechnen und in `local_handoff.device_id` schreiben. **Vorsicht:** Die `boot_diag_seal()` und der Handoff-CRC müssen nach dem neuen Feld berechnet werden.
+
+`sdk/libtoob/toob_handoff.c` — `toob_get_handoff()` und `toob_validate_handoff()` müssen die neue Struct-Größe und den neuen `TOOB_HANDOFF_STRUCT_VERSION` korrekt prüfen. Hier liegt ein subtiler Migrationspunkt: Geräte im Feld mit Version `0x01000000` dürfen nicht hart abstürzen. Der Agent sollte einen Fallback einbauen.
+
+---
+
+## Phase 5: `boot_cloud_cmd.c` (Kern der Killswitch-Logik)
+
+**Warum hier:** Alle Abhängigkeiten (Types, CDDL-Parser, Device-ID, KDM-Konzept) sind jetzt da.
+
+**Kritische Dateien:**
+
+Neue Datei `toobloader/core/boot_cloud_cmd.c` + `toobloader/core/include/boot_cloud_cmd.h` — Die komplexeste neue Datei. Agent muss strikt das Sequencing-Protokoll einhalten (Parse → Device-ID → Counter → Verify → Advance → Dispatch). Jeder Schritt vor dem Counter-Advance darf **keinen** Seiteneffekt haben. Die KDM-Lade-Logik (A/B-Slot mit TMR-Sequenz-Check) ist eine eigene Subfunktion. Der Agent muss das bestehende Glitch-Shield-Pattern (Double-Check + `BOOT_GLITCH_DELAY()` + CFI-Akkumulator) konsistent anwenden — exakt wie in `boot_verify.c` und `boot_rollback.c`.
+
+`toobloader/core/boot_panic.c` — Der `BOOT_ERR_DEVICE_LOCKED`-Reason muss den Firmware-Flash-Pfad in Block 3 sperren, aber den 2FA-Auth-Pfad (Block 2) weiterhin erlauben, mit der Erweiterung, dass nach erfolgreicher Auth ein UNLOCK-Envelope erwartet wird statt eines Firmware-Streams.
+
+**Besondere Risiken:** Die `crypto_arena` wird von `boot_cloud_cmd.c` exklusiv beansprucht (Zero-Allocation). Der Agent muss sicherstellen, dass kein anderer Code gleichzeitig die Arena nutzt. Da Cloud-Commands vor der Update-Pipeline evaluiert werden, ist das sequenziell sicher — aber nur, wenn die Arena vor Rückgabe gesäubert wird (`boot_secure_zeroize`).
+
+---
+
+## Phase 6: `boot_state.c` Integration
+
+**Warum hier:** Die Command-Pipeline steht, jetzt wird sie in den Orchestrator eingehängt.
+
+**Kritische Dateien:**
+
+`toobloader/core/boot_state.c` — Zwei neue Schritte zwischen Step 2 und Step 3:
+
+Step 2.5: `_handle_cloud_cmd()` — Liest `CHIP_CLOUD_CMD_SLOT`, ruft `boot_cloud_cmd_evaluate()` auf. Bei `TOOB_CMD_KILLSWITCH` schreibt es `WAL_INTENT_DEVICE_LOCKED`. Bei `TOOB_CMD_FORCE_UPDATE` schreibt es `WAL_INTENT_UPDATE_PENDING` (und die normale Pipeline in Step 4 übernimmt). Der CFI-Akkumulator `state_cfi` braucht einen neuen Token (`CFI_STEP_2_5`). **Das ist der heikelste Eingriff:** Der Agent muss den `expected_cfi` am Ende von `state_cleanup` um den neuen Token erweitern und sicherstellen, dass der Token auch bei Skip-Pfaden (kein Command vorhanden) korrekt XOR'd wird.
+
+Step 2.7: Lock-State-Check — Prüft ob `WAL_INTENT_DEVICE_LOCKED` der aktive Intent ist. Wenn ja, nur UNLOCK akzeptieren, sonst → `boot_panic(BOOT_ERR_DEVICE_LOCKED)`.
+
+`toobloader/core/include/boot_state.h` — Kein neues Public-API nötig, aber der Lifecycle-Kommentar muss aktualisiert werden.
+
+---
+
+## Phase 7: libtoob OS-API + Handoff-Erweiterung
+
+**Warum hier:** Die Bootloader-Seite ist fertig, jetzt die OS-Boundary.
+
+**Kritische Dateien:**
+
+`sdk/libtoob/include/libtoob.h` — Neue Funktionen: `toob_submit_cloud_command()`, `toob_get_device_id()`, `toob_is_device_locked()`.
+
+Neue Datei `sdk/libtoob/toob_cloud_submit.c` — Schreibt den Envelope in `CHIP_CLOUD_CMD_SLOT` via `toob_os_flash_erase()` + `toob_os_flash_write()` mit CRC-Read-Back. Danach `toob_wal_naive_append()` mit `TOOB_WAL_INTENT_CLOUD_CMD`. Der Agent muss die bestehende `toob_wal_naive.c`-Lock-Logik beachten: `WAL_INTENT_CLOUD_CMD` darf parallel zu einem `WAL_INTENT_UPDATE_PENDING` existieren (unterschiedliche Slots).
+
+`sdk/libtoob/include/libtoob_config_sandbox.h` — Neue Makros für `CHIP_CLOUD_CMD_SLOT`, `CHIP_KDM_SLOT_A`, `CHIP_KDM_SLOT_B`.
+
+---
+
+## Phase 8: Provisioning-HAL + CLI-Integration
+
+**Warum hier:** Hängt von allem Vorherigen ab, hat aber keinen Einfluss auf den Runtime-Boot-Pfad.
+
+**Kritische Dateien:**
+
+`common/include/boot_hal.h` — Neues `provisioning_hal_t`-Struct. Optional als Feld in `boot_platform_t` (mit NULL-Default für Non-Provisioning-Builds).
+
+`toobloader/core/boot_main.c` — DSLC-Check in Block 2.5 (nach Recovery-Pin, vor State-Machine): Wenn `DSLC == 0x00`, UART-Provisioning-Loop aufrufen statt `boot_state_run()`.
+
+Neue Datei `toobloader/core/boot_provisioning.c` — COBS-basiertes UART-Protokoll, angelehnt an die existierende Logik in `boot_panic.c` Block 2/3.
+
+## Zusammenfassung: Abhängigkeitsgraph
+
+```
+Phase 1 (Types/ABI) ──┬──→ Phase 2 (Stage 0 DSLC)
+                       ├──→ Phase 3 (CDDL/zcbor)
+                       ├──→ Phase 4 (Device-ID)
+                       │
+                       └──→ Phase 3 + 4 ──→ Phase 5 (boot_cloud_cmd.c)
+                                                  │
+                                                  ├──→ Phase 6 (boot_state.c)
+                                                  ├──→ Phase 7 (libtoob API)
+                                                  └──→ Phase 8 (Provisioning)
+                                                            │
+                                                            └──→ Phase 9 (Tests)
+```
+
+Phase 2 kann parallel zu 3-4 laufen. Phase 7 kann parallel zu 6 starten, sofern die Types aus Phase 1 stehen.