Das Problem: ein Feldgerät, das jeder in die Hand bekommt
Ein Energiemonitoring-Gerät im Feld ist physisch angreifbar: Wer es in der Hand hat, kann den Flash auslesen, den Bootloader austauschen oder ein manipuliertes Image einspielen. Passwörter und SSH-Härtung allein schützen nicht vor Manipulation an der Software selbst - sie sichern den Zugang, nicht die Integrität des Codes, der startet.
Der Ausgangspunkt ist ein konkretes, bereits ausgeliefertes System: ein SoC der NXP-i.MX6-Familie (Cortex-A7, mit CAAM), 256 MB RAM, der Bootloader in einem 1 MiB SPI-NOR, das Rootfs als UBIFS auf 256 MiB Raw-NAND (UBI), eine 8-GB-eMMC für Daten. Das Vendor-BSP basiert auf dem Mainline-Kernel, nicht auf NXP linux-imx; gebaut wird mit Yocto Kirkstone, U-Boot 2024.01 und Kernel 6.1. Eine Flotte dieser Geräte ist im Feld - Sicherheit muss also nachrüstbar sein, ohne jedes Gerät zu öffnen.
Regulatorik macht das Thema dringlich: Der EU Cyber Resilience Act (CRA) verlangt Security-by-Design und nachweisbare Schwachstellenbehandlung für Produkte mit digitalen Elementen; ISO/IEC 27400 und NIST 8259 geben Leitplanken für IoT-Sicherheit. Eine durchgängige Vertrauenskette vom Power-On bis zum Root-Filesystem ist eines der wirksamsten Mittel gegen persistente Manipulation.
Drei Begriffe werden oft verwechselt: Secure Boot stellt sicher, dass nur signierte, vertrauenswürdige Komponenten geladen werden, bis das Betriebssystem startet. Verified Boot geht weiter und prüft Authentizität und Integrität jeder Boot-Stufe - die vollständige Vertrauenskette. Measured Boot protokolliert und bewertet den Boot-Prozess, erkennt Abweichungen, verhindert sie aber nicht zwingend. Dieser Artikel beschreibt Verified Boot - als Fallstudie entlang einer realen, anonymisierten Implementierung.
- Nur signierte Software bootet - vom Power-On bis zum Userspace, keine Lücke in der Kette.
- Daten at rest sind verschlüsselt; der Schlüssel liegt nie im Klartext auf dem Gerät.
- Das Gerät bleibt im Feld aktualisierbar: signierte Updates, A/B-Partitionen, Rollback.
- Bestandsgeräte sind migrierbar - ohne USB-Zugang, der im Produktivzustand gesperrt ist.
- Der Entwicklungs-Workflow bleibt handhabbar: ein Entwicklungs-Image nahe am Produktiv-Image.
- Die beschreibbare Oberfläche ist minimal - ein fast vollständig beschreibbares Rootfs ist keine Härtung.
Der Lösungsraum: die Kette und ihre Alternativen
Auf i.MX6 prüft die Boot-ROM den ersten geladenen Code (den SPL) mit NXP High Assurance Boot (HABv4). HAB ist RSA-basiert und im ROM verankert; nach dem Programmieren der entsprechenden eFuses ist es nicht mehr veränderbar. Der SPL prüft das signierte U-Boot, U-Boot prüft das signierte fitImage (Kernel plus Device Tree). Jede Stufe authentifiziert die nächste, bevor sie ihr die Kontrolle übergibt.
Ein signierter Bootloader allein lässt aber das Rootfs als offene Flanke: Wer den Flash beschreiben kann, tauscht das Rootfs aus, ohne die HAB-Kette zu berühren. Deshalb muss die Kette bis zum Rootfs reichen. Dafür gibt es zwei Kernel-Mechanismen: dm-verity legt einen sha256-Hashbaum über ein Blockgerät und prüft jeden Block beim Lesen (read-only, ein einziger signierter Root-Hash als Vertrauensanker); IMA/EVM misst und bewertet dagegen dateiweise und funktioniert auch auf beschreibbaren Dateisystemen. Gewählt wurde dm-verity - einfacher Anker, read-only by design. Wichtig: IMA/EVM ist ohne Verschlüsselung anfällig für Offline-Angriffe (die extended attributes lassen sich offline löschen), dm-verity nicht.
Die Design-Entscheidungen stehen damit früh fest: ein Read-only-SquashFS-Rootfs im A/B-Layout, ein signierter Root-Hash, der von einem in den Kernel kompilierten Initramfs geprüft wird (und damit selbst Teil der HAB-Kette ist), verschlüsselte Daten auf der eMMC und signierte RPM-Updates. Der Rest des Artikels arbeitet diese Kette Schritt für Schritt ab - mit den Kommandos, Konfigurations-Symbolen und Fehler-Signaturen aus dem echten Bring-up.
- Boot-ROM → SPL (HABv4, RSA-Signatur)
- SPL → U-Boot (HABv4)
- U-Boot → fitImage: Kernel + Device Tree (HABv4)
- Kernel-Initramfs → dm-verity-Root-Hash (ECDSA-Signatur)
- dm-verity → jeder gelesene Rootfs-Block (sha256-Hashbaum)
HABv4-PKI: Super Root Keys erzeugen
HAB authentifiziert Images über eine Public-Key-Infrastruktur: Ein Satz Super Root Keys (SRKs) bildet die Wurzel. Ihr gemeinsamer Hash wird in die OTP-Fuses des SoC gebrannt; zur Laufzeit prüft HAB, ob die im Image mitgelieferte SRK-Tabelle zu diesem Fuse-Wert passt. NXP liefert das Code Signing Tool (CST), das Schlüssel erzeugt, CSF-Daten signiert und die SRK-Tabelle berechnet. Die öffentlichen NXP-Dokumente AN4581 (i.MX Secure Boot on HABv4 Supported Devices) und AN12263 (HABv4 RVT Guidelines) sowie das HABv4-API-Handbuch im CST-Paket beschreiben das Verfahren vollständig.
Der PKI-Baum wird mit dem CST-Skript hab4_pki_tree.sh erzeugt. Bewährte Parameter: neue CA, RSA-4096, vier SRKs mit CA-Flag, lange Laufzeit (HAB selbst prüft die Gültigkeitsdauer nicht). Zwei Textdateien steuern den Prozess: serial (8-stellige Seriennummer für die Zertifikate) und key_pass.txt (ein Passwort, zweimal wiederholt, schützt alle privaten Schlüssel im PKCS#8-Format). Die Namen der erzeugten Zertifikate spiegeln die gewählten Optionen - wer andere Werte wählt, muss die Dateinamen in den Folge-Schritten anpassen.
Schlüsselhygiene ist nicht verhandelbar: Private Schlüssel gehören niemals ins Repository. Entwicklungs-Schlüssel dürfen im Build-Container liegen, Produktions-Schlüssel werden offline verwahrt und strikt getrennt. Die folgenden Kommandos zeigen das Muster mit Platzhaltern.
# In the CST keys/ directory: drive the interactive PKI generator
echo 12345678 > serial
echo '<your-password>' > key_pass.txt
echo '<your-password>' >> key_pass.txt
./hab4_pki_tree.sh
# Do you want to use an existing CA key (y/n)?: n
# Do you want to use Elliptic Curve Cryptography (y/n)?: n
# Enter key length in bits for PKI tree: 4096
# Enter PKI tree duration (years): 10
# How many Super Root Keys should be generated? 4
# Do you want the SRK certificates to have the CA flag set? (y/n)?: y
# Private keys -> keys/, X.509 certificates -> crts/SRK-Tabelle und Fuse-Werte
Aus den vier SRK-Zertifikaten erzeugt srktool zwei Artefakte: die SRK-Tabelle (wandert ins Image) und die Fuse-Tabelle (wandert in den Chip). -h 4 wählt vier Hash-Einträge, -d sha256 den Algorithmus, -f 1 das Fuse-Format. Die Reihenfolge der Zertifikate bestimmt die Slot-Indizes - sie muss zu den späteren Source-index-Angaben in den CSF-Dateien passen.
Die Byte-Reihenfolge der Fuse-Worte muss exakt stimmen. Ein Fehler hier macht den Baustein unbootbar, sobald die Sicherheitskonfiguration geschlossen wird - und Fuses sind one-time programmable, nicht korrigierbar. Die Werte sind chipspezifisch; die Fuse-Tabelle aus dem eigenen srktool-Lauf ist die einzige gültige Quelle.
# In the CST crts/ directory: SRK table + fuse values from the four SRK certs
srktool -h 4 -t SRK_1_2_3_4_table.bin -e SRK_1_2_3_4_fuse.bin \
-d sha256 -f 1 \
-c SRK1_sha256_4096_65537_v3_ca_crt.pem,SRK2_sha256_4096_65537_v3_ca_crt.pem,\
SRK3_sha256_4096_65537_v3_ca_crt.pem,SRK4_sha256_4096_65537_v3_ca_crt.pemHAB aktivieren und die Build-Logs lesen
HAB wird in der U-Boot-Konfiguration aktiviert (CONFIG_IMX_HAB=y), sauber als Patch in einer eigenen Layer. Der Build mit Secure-Boot-Support erzeugt vier relevante Dateien: SPL, SPL.log, u-boot-ivt.img und u-boot-ivt.img.log. Sie liegen im Build-Ordner des U-Boot-Rezepts.
Das Image ist dabei bereits 4-KB-aligned und die Image Vector Table (IVT) ist angehängt - daher der Name u-boot-ivt.img. Die HAB-Blocks-Daten (Adresse, Offset, Länge des signierten Bereichs) stehen in den .log-Dateien. Diese Werte werden aus dem Build übernommen, nicht geraten - sie sind die Grundlage der [Authenticate Data]-Blöcke im CSF.
# U-Boot defconfig (patch in your own layer)
CONFIG_IMX_HAB=y
# Build artifacts to collect (from the U-Boot recipe build dir):
# SPL - the secondary program loader
# SPL.log - HAB blocks for the SPL
# u-boot-ivt.img - 4KB-aligned U-Boot with appended IVT
# u-boot-ivt.img.log - HAB blocks for U-BootDas Command Sequence File (CSF)
Das Command Sequence File beschreibt, was HAB prüfen soll: SRK-Tabelle installieren ([Install SRK]), den CSF-Schlüssel authentifizieren ([Install CSFK] + [Authenticate CSF]), den Image-Schlüssel installieren ([Install Key]) und schließlich die Image-Daten authentifizieren ([Authenticate Data]). Die Blocks-Zeile nennt RAM-Ladeadresse, Offset des signierten Bereichs im Image, dessen Länge und die Image-Datei - direkt aus den Build-Logs.
Die Engine ist hier CAAM. Auf SoCs ohne CAAM (etwa i.MX6ULL) muss die Engine auf SW stehen - das ist nicht nur eine Frage der Verfügbarkeit, sondern der Chip-Fehler ERR010449 (siehe AN4581 und die i.MX6ULL-Errata). Das signierte CSF-Binary wird mit cst -i csf.txt -o csf.bin erzeugt und ans Image angehängt; SPL und U-Boot werden danach zu einem flashbaren Image zusammengeführt. Die öffentlichen U-Boot-HABv4-Guides (doc/imx/habv4) zeigen das Verfahren für Nicht-SPL- und SPL-Ziele.
[Header]
Version = 4.1
Hash Algorithm = sha256
Engine = CAAM # SW on SoCs without CAAM (e.g. i.MX6ULL, ERR010449)
Engine Configuration = 0
Certificate Format = X509
Signature Format = CMS
[Install SRK]
File = "../crts/SRK_1_2_3_4_table.bin"
Source index = 0 # which SRK slot signs this image
[Install CSFK]
File = "../crts/CSF1_1_sha256_4096_65537_v3_usr_crt.pem"
[Authenticate CSF]
[Install Key]
Verification index = 0
Target index = 2
File = "../crts/IMG1_1_sha256_4096_65537_v3_usr_crt.pem"
[Authenticate Data]
Verification index = 2
# Address Offset Length Data file
Blocks = <load_address> <offset> <length> "u-boot-ivt.img"Layout-Stolperstein 1: Padding und CSF-Offset
HAB verzeiht keine Layout-Fehler. In einem realen Build ergab sich: tatsächliche Dateigröße 0xac020, intendierte Größe laut Image-Header 0xae060 (712736 Bytes plus 64 Byte Header = 712800 = 0xae060). Die Differenz 0x2040 ist der nötige CSF_PAD_SIZE - der Upstream-Default ist 0x2000, patchbar in arch/arm/include/asm/mach-imx/hab.h. Die intendierte Größe liefert file u-boot-ivt.img; gepadded wird mit objcopy.
Zweiter Stolperstein: Der SPL berechnet den CSF-Offset als Image-Größe minus CONFIG_CSF_SIZE (arch/arm/mach-imx/spl.c). Damit der SPL die IVT des U-Boot-Images findet, muss CONFIG_CSF_SIZE auf CSF_PAD_SIZE plus IVT-Größe (0x20) gesetzt werden - im Beispiel 0x2060. Dieser Wert wurde erst durch Debugging gefunden; er steht in keinem Datenblatt.
Dritter: Das Anhängen des CSF invalidiert die Legacy-CRC. CONFIG_SPL_LEGACY_IMAGE_CRC_CHECK wird deshalb deaktiviert - für Produktion ist eine CRC-Aktualisierung nach dem Signieren der sauberere Weg. Wer den Check einfach auslässt, sollte das bewusst dokumentieren.
# Intended size from the image header (example values, version string genericized)
file u-boot-ivt.img
# u-boot-ivt.img: u-boot legacy uImage, U-Boot 2024.01, Firmware/ARM,
# (Not compressed), 712736 bytes, Load Address: 0x87800000,
# Entry Point: 0x87800000, Header CRC: 0x........, Data CRC: 0x........
# intended size = 712736 + 64 = 712800 = 0xae060
# Pad the signed image to its intended size
objcopy -I binary -O binary --gap-fill 0x00 --pad-to 0xae060 \
u-boot-ivt.img_signed u-boot-ivt.img_signed_pad
# Related config symbols (keep in sync):
# CSF_PAD_SIZE 0x2040 (arch/arm/include/asm/mach-imx/hab.h)
# CONFIG_CSF_SIZE 0x2060 (= CSF_PAD_SIZE + IVT 0x20)
# CONFIG_SPL_LEGACY_IMAGE_CRC_CHECK offLayout-Stolperstein 2: SPL und U-Boot verschmelzen
SPL und U-Boot werden per objcopy zu einem Image verschmolzen: Die SPL-Sections werden gestrippt, auf eine feste Adresse gepadded und das gepaddete U-Boot-Image anschließend konkateniert. Der SPL erwartet U-Boot an CONFIG_SYS_SPI_U_BOOT_OFFS - Padding und dieser Offset müssen synchron bleiben, sonst crasht der SPL und U-Boot startet nicht.
Und: Der SPL wird mit 0x400 Offset ins NOR-Flash gebrannt. Dieser Offset muss in CONFIG_SYS_SPI_U_BOOT_OFFS berücksichtigt werden - die 0x400 gehören zum Padding dazu. Die Section-Liste unten ist die aus dem realen Build; je nach U-Boot-Version können weitere Sections nötig sein.
# Merge stripped SPL + padded U-Boot into one flashable image
# (pad address is build-specific; example: 0x10800)
objcopy -j .text -j .secure_text -j .secure_data -j .rodata -j .hash \
-j .data -j .got -j .got.plt -j __u_boot_list -j .rel.dyn \
-j .binman_sym_table -j .text_rest -j .dtb.init.rodata \
-j .efi_runtime -j .efi_runtime_rel \
-I binary -O binary --pad-to=0x10800 SPL_signed u-boot-with-spl.imx
cat u-boot-ivt.img_signed_pad >> u-boot-with-spl.imx
# Keep CONFIG_SYS_SPI_U_BOOT_OFFS in sync with the pad address (+ 0x400 NOR offset)Yocto-Integration: Signieren im Build
Manuelles Signieren nach jedem Build ist fehleranfällig. Sauber ist eine bbclass in einer eigenen Layer (etwa meta-hab), die CST-Zertifikate und -Schlüssel über Variablen referenziert (CST_CSF_CERT, CST_IMG_CERT, CST_CSF_KEY, CST_IMG_KEY) und die CSF-Dateien je Rezept in recipes-bsp (SPL/U-Boot) und recipes-kernel (fitImage) bereitstellt. Ein normaler bitbake-Lauf erzeugt dann direkt signierte Images.
Wer Schlüsselpfade oder Zertifikate tauschen will, überschreibt die Variablen in der Layer-Konfiguration. Nach einem Schlüsselwechsel gehören die betroffenen Rezepte per cleansstate neu gebaut - sonst bleiben alte Signaturen im sstate-Cache. Das gleiche Muster trägt später die signierten RPM-Updates: Das Rootfs-Image wird als signiertes Paket erzeugt und vom Updater verifiziert.
# meta-hab/classes/hab.bbclass - key/cert references (override in layer conf)
CST_CSF_CERT ?= "${CST_CRT_ROOT}/crts/CSF1_1_sha256_4096_65537_v3_usr_crt.pem"
CST_IMG_CERT ?= "${CST_CRT_ROOT}/crts/IMG1_1_sha256_4096_65537_v3_usr_crt.pem"
CST_CSF_KEY ?= "${CST_CRT_ROOT}/keys/CSF1_1_sha256_4096_65537_v3_usr_key.pem"
CST_IMG_KEY ?= "${CST_CRT_ROOT}/keys/IMG1_1_sha256_4096_65537_v3_usr_key.pem"
# Rebuild signed artifacts after a key change
bitbake u-boot -c cleansstate && bitbake u-boot
bitbake linux -c cleansstate && bitbake linux
bitbake dm-verity-image-initramfs -c cleansstate
bitbake production-imageFuses brennen, hab_status, Gerät schließen
Die SRK-Hash-Worte werden aus der Fuse-Tabelle in die OTP-Fuses programmiert (i.MX6, über die U-Boot-fuse-Nummerierung: Bank 3, Worte 0-7). Das ist ein One-Time-Vorgang - einmal gebrannt, nicht rückgängig zu machen. Die Werte sind chipspezifisch; die folgenden Zeilen zeigen nur das Muster.
Danach bootet das Gerät im offenen Zustand: HAB prüft Signaturen und protokolliert Ereignisse, blockiert aber noch nicht. Der SPL-Log zeigt die Authentifizierung („Authenticate image from DDR location ..."), der U-Boot-Befehl hab_status den Zustand. Erst wenn „No HAB Events Found!" erscheint (Konfiguration 0xf0, State 0x66), ist die Signaturkette nachweislich in Ordnung. Ein einziger HAB-Event bedeutet: nicht schließen, sondern Ursache suchen.
Erst jetzt wird das Gerät geschlossen: Das SEC_CONFIG[1]-Fuse (i.MX6: Bank 0, Wort 6, Wert 0x2 - dokumentiert in AN4581) erzwingt die Signaturprüfung. Ab diesem Moment bootet der Chip nur noch korrekt signierte Images; ist irgendetwas an der Kette falsch, ist das Gerät unbootbar - im Feld ein Totalschaden. Deshalb: erst im offenen Zustand testen, dann schließen. In der Fertigung ist das ein zusätzlicher Schritt (OTP-Brennen); Entwickler-Boards bleiben offen, damit eigene Images booten.
# SRK hash fuses - YOUR values from SRK_1_2_3_4_fuse.bin (one-time!)
fuse prog 3 0 <srk_word_0>
fuse prog 3 1 <srk_word_1>
# ... words 2..7 ...
# SPL boot log in the open state (HAB verifies, does not block):
# hab fuse not enabled
# Authenticate image from DDR location 0x877fffc0...
# Verify in U-Boot
hab_status
# Secure boot disabled
# HAB Configuration: 0xf0, HAB State: 0x66
# No HAB Events Found!
# Close the device (one-time, irreversible)
fuse prog 0 6 0x2Key-Rolling und SRK-Revoke
Schlüssel alternieren zu können ist Teil eines belastbaren Sicherheitskonzepts. HAB erlaubt vier SRK-Slots: Ein Image wird mit Slot 0 signiert, ein Update mit Slot 1. Dazu werden in der bbclass die CSF-/IMG-Zertifikate und -Schlüssel auf die neuen Dateien umgestellt und in den CSF-Dateien der Source index von 0 auf 1 gesetzt. Der SRK-Hash in den Fuses bleibt gleich - er deckt alle vier Schlüssel ab.
Kompromittierte Schlüssel müssen sperrbar sein. Dafür wird die CSF um einen [Unlock]-Abschnitt (Engine = OCOTP, Features = SRK Revoke) erweitert und das SRK_REVOKE-Fuse gesetzt (i.MX6: Bank 5, Wort 7; Bit-Maske je Slot: 0x1 für SRK0, 0x2 für SRK1, 0x4 für SRK2). Wichtig: Nur SRK0-2 sind revocable; der vierte Slot (SRK3) ist die nicht sperrbare Reserve - ihn hält man frei.
Der sichere Ablauf in Feldgeräten: Update mit neuem Schlüssel einspielen, neu booten, validieren - und erst dann den alten Schlüssel per Revoke entwerten. So bleibt das Gerät auch bei fehlgeschlagenem Update bootfähig. Die Reihenfolge ist entscheidend: Wer erst sperrt und dann aktualisiert, riskiert ein unbootbares Gerät.
# In the CSF, after [Authenticate CSF]:
[Unlock]
Engine = OCOTP
Features = SRK Revoke
# Roll to the second SRK slot: set in every CSF (recipes-bsp + recipes-kernel)
Source index = 1
# After the update is validated, revoke the OLD slot-0 key (one-time).
# Mask per slot: SRK0=0x1 SRK1=0x2 SRK2=0x4 (SRK3 not revocable)
fuse prog 5 7 0x1Rootfs-Verifikation: die Dateisystem-Frage
HAB deckt SPL, U-Boot, Kernel und Device Tree ab - das Rootfs ist das nächste Glied. Die erste Hürde ist das bestehende Dateisystem: UBIFS auf UBI ist kein Blockgerät und damit nicht direkt dm-verity-fähig. Der Kernel kann ein UBI-Volume als Blockgerät exponieren (CONFIG_MTD_UBI_BLOCK) und darauf ein SquashFS legen - read-only by design und platzsparend.
Aber: U-Boot liest das fitImage aus dem Rootfs. U-Boot kann SquashFS zwar von Blockgeräten (etwa MMC) lesen, nicht aber von einem UBI-Volume - der ubiblock-äquivalente Pfad ist (Stand 2024.01) nicht mainline; die einschlägige Arbeit ist ein RFC von 2023 („mtd: ubi: Enable accessing RO filesystems in UBI vols"). Drei Optionen wurden bewertet; die Entscheidung fiel auf (b): Das fitImage wird aus dem Rootfs herausgelöst und in eigene Raw-UBI-Partitionen gelegt, das Rootfs bleibt Read-only-SquashFS. U-Boot muss das Rootfs-Dateisystem damit nicht mehr lesen können.
Die Konsequenzen von (b) sind überschaubar, aber real: geänderte U-Boot-Environment-Argumente, zwei neue NAND-Partitionen (für A/B), ein angepasstes dnf-Postinstall-Skript und das Herauslösen des fitImage aus dem Rootfs. Dafür bleibt U-Boot unabhängig vom Rootfs-Typ - ein Vorteil, der spätere Dateisystem-Wechsel offen hält.
- (a) U-Boot einen UBI-Block-Treiber patchen: nicht mainline, muss mit jedem U-Boot-Update gepflegt werden; kein Patch passt out-of-the-box zu 2024.01. Vorteil: eine Partition für Rootfs und Kernel.
- (b) fitImage in eigene Raw-UBI-Partitionen auslagern: U-Boot bleibt vom Rootfs-Typ unabhängig. Nachteil: eine zusätzliche Partition im Update-Mechanismus. Gewählt.
- (c) Rootfs auf eMMC/ext4 (read-only) umziehen: eine Partition, aber Fragen nach eMMC-Größe und künftigem Vorhandensein; U-Boot muss eMMC lesen können.
Partitionslayout und erstes Flashen
Das NAND-Layout bekommt vier Partitionen: root-a/root-b (je 96 MiB SquashFS, rund 67 MB Inhalt) und os-a/os-b (je 20 MiB Raw-UBI für das fitImage, rund 13,5 MB). Auf der eMMC entsteht ein Daten-/Overlay-Bereich: Die sys-overlay-Partition im NAND war zu klein, also wandert sie auf die eMMC - als 3-GiB-ext4-Partition, mit reserviertem Platz für künftiges Rootfs- und U-Boot-A/B.
Das erste Flashen läuft per TFTP aus U-Boot. Voraussetzungen: ein U-Boot mit Verified-Boot-Support, ein signiertes fitImage und ein production-image.squashfs.verity. Nach dem Signieren darf sich das Rootfs nicht mehr ändern - sonst schlägt die Prüfung beim Boot fehl.
# Create the A/B partition table (in U-Boot)
ubi part rootfs
ubi list
ubi remove <old-partitions>
ubi create root-a 0x6000000 # 96 MiB SquashFS
ubi create root-b 0x6000000
ubi create os-a 0x1400000 # 20 MiB raw UBI (fitImage)
ubi create os-b 0x1400000
# Flash initial rootfs and os (in U-Boot, via TFTP)
tftp 0x80000000 production-image.squashfs.verity
ubi write 0x80000000 root-a 0x${filesize}
tftp 0x82000000 fitImage-signed
ubi write 0x82000000 os-a 0x${filesize}
run vendor_bootcmd # starts the systemdm-verity und der signierte Root-Hash
dm-verity legt einen sha256-Hashbaum über ein Blockgerät und prüft jeden Block beim Lesen; das Ziel ist read-only. veritysetup format berechnet Hashbaum und Root-Hash. Der Root-Hash wird signiert (hier ECDSA P-256) und ans Rootfs angehängt - an einem definierten Offset hinter dem Dateisystem.
Ein Initramfs, das in den Kernel kompiliert ist (und damit selbst HAB-geprüft), trägt den beim Build integrierten Public Key. Es prüft eine Markierung am erwarteten Offset, verifiziert die Signatur, gewinnt den Root-Hash, richtet dm-verity ein, mountet das verifizierte Rootfs und übergibt per switch_root an den Userspace. Alternativ kann der Kernel die Root-Hash-Signatur mit DM_VERITY_VERIFY_ROOTHASH_SIG selbst gegen den builtin Trusted Keyring prüfen.
Die Yocto-Integration (meta-hab) erzeugt daraus ein production-image.squashfs.verity und ein signiertes RPM. Nach einem Schlüsselwechsel müssen linux, das dm-verity-Initramfs und das Image per cleansstate neu gebaut werden. Ein Entwickler-Schlüsselpaar darf im Build liegen - Produktions-Schlüssel niemals. Die Kernel-Dokumentation (admin-guide/device-mapper/verity) beschreibt Hashbaum und Parameter im Detail.
# Sign the dm-verity root hash (ECDSA P-256; genericized filenames)
openssl ecparam -name prime256v1 -genkey -noout -out verity_priv.pem
openssl ec -in verity_priv.pem -pubout -out verity_public.pem
# Hash tree + root hash (veritysetup, default --hash sha256)
veritysetup format rootfs.squashfs rootfs.hash
# Root hash: <64 hex chars> <- this value is signed and appended
# Rebuild the signed chain after a key change (Yocto)
bitbake -c cleansstate production-image linux dm-verity-image-initramfs
bitbake production-imageBeschreibbare Pfade: Overlays, Symlinks, Datenklassen
Ein Read-only-Rootfs braucht einige beschreibbare Pfade. Zwei Methoden: Overlayfs (das Image liefert Defaults, Änderungen schatten sie nur bei tatsächlicher Modifikation - Wiederherstellung durch Löschen der oberen Schicht) und Symlinks in einen dedizierten beschreibbaren Bereich. Jeder Ordner bekommt ein eigenes Overlay - das gibt Kontrolle darüber, welcher Teil des Systems zurückgesetzt werden kann.
Sinnvoll ist eine Datenklassifizierung: parameters (jederzeit änderbar, werden bei Factory-Reset und System-Update zurückgesetzt), provisioning (initiales Setup, darf beim Factory-Reset nicht verloren gehen - Schlüssel, Cloud-Endpunkte, Netzkonfiguration) und lifetime (werden nie zurückgesetzt, etwa Betriebsstunden). Richtig klassifiziert ist ein Factory-Reset reine Overlay-Löschung.
Die Wartbarkeitsregel: Jedes Rezept, das Schreibzugriff erweitert, bindet ein gemeinsames base-files-Include ein (require); für geteilte Systemressourcen, die erst nach dem Image-Zusammenbau vollständig sind, gibt es ein ROOTFS_POSTPROCESS_COMMAND. Änderungen nur für class-target. Typische Kandidaten: /home, /var/cache, /var/lib (RPM-Datenbank), Konfiguration in /etc (SSH-Schlüssel, Netzwerk, passwd/shadow) und Anwendungsdaten.
Ehrliche Lehre: Anfangs wurde fast das gesamte Rootfs beschreibbar gemacht, um schnell zu mergen - das ist keine Best Practice. Die Liste wurde danach bewusst minimiert; die Migration kostet (Factory-Reset, verlorene Konfiguration, keine System-Binaries mehr im Overlay, ldconfig kann den Cache nicht mehr aktualisieren - dann LD_LIBRARY_PATH oder Image-Update). Die Angriffsfläche soll minimal bleiben.
# Standalone component: move config into the writable area, symlink back
# (genericized; every such recipe requires the shared base-files include)
require recipes-software/application/base-files.inc
DEPENDS:append:class-target = " base-files"
do_install:append:class-target() {
install -d ${D}${writableRoot}${sysconfdir}
mv ${D}${sysconfdir}/mydaemon ${D}${writableRoot}${sysconfdir}/mydaemon
ln -s ${writableRoot}${sysconfdir}/mydaemon ${D}${sysconfdir}/mydaemon
}
FILES:${PN}:append:class-target = " ${sysconfdir}/mydaemon ${writableRoot}${sysconfdir}/mydaemon"
# Shared resource: a ROOTFS_POSTPROCESS_COMMAND (defined in base-files.inc)
base_files_provision_readonly_etc() {
mv ${IMAGE_ROOTFS}${sysconfdir}/passwd ${IMAGE_ROOTFS}${writableRoot}${sysconfdir}
ln -s ${writableRoot}${sysconfdir}/passwd ${IMAGE_ROOTFS}${sysconfdir}/passwd
}
ROOTFS_POSTPROCESS_COMMAND:append = " base_files_provision_readonly_etc;"Verschlüsselter Speicher: dm-crypt mit CAAM-Keyblobs
Verifikation schützt vor Manipulation, nicht vor Auslesen. Für Daten at rest wird ein dm-crypt-Container auf der eMMC angelegt: eine verschlüsselte Datei, die beim Boot entsperrt und per Loop-Device gemountet wird; beschreibbare Ordner werden per Overlay dorthin umgeleitet. Der Schlüssel darf niemals im Klartext liegen - sonst ist die gesamte Verschlüsselung wirkungslos.
Auf i.MX6 wickelt CAAM den Schlüssel mit dem hardwareseitigen OTPMK (One-Time-Programmable Master Key) zu einem Keyblob; nur der Chip selbst kann ihn wieder entpacken. Hier entscheidet die BSP-Wahl über den Aufwand: NXP beschreibt die Hidden-Key-Funktionen in AN12714 (i.MX Encrypted Storage Using CAAM Secure Keys), setzt dafür aber linux-imx voraus. Ein mainline-basiertes Vendor-BSP bringt diese Treiber nicht mit. Die Lösung war ein bewusster Tradeoff: der öffentliche caam-keyblob-Treiber plus ein Userspace-Beispiel zum Blob-Handling - gut genug für die Sicherheitsanforderung, deutlich weniger Aufwand als ein Kernel-Wechsel. Als langfristige Alternative wurde OP-TEE mit PKCS#11 bewertet (eine TPM-ähnliche Secure Enclave; NXP führt Secure-Keys heute über OP-TEE/PKCS#11) - mehr Aufwand, in dieser Phase zurückgestellt.
Bekanntes Restrisiko: Auf einigen i.MX6-Chips tritt ein temperaturabhängiger CAAM-RNG-Hardwarefehler auf (dokumentiert in der NXP-Community und in OP-TEE Issue #1408); wer mainline fährt, bekommt NXP-Fixes nicht automatisch. Auch NXP AN12838 (CAAM Secure Key für OpenSSL) zielt auf Vendor-BSP-Kernel; die Mainline-Unterstützung ist begrenzt. Solche Restrisiken gehören dokumentiert, nicht verschwiegen.
# CAAM RNG hardware-error signature (temperature-dependent, some i.MX6 chips):
caam_jr 2141000.jr: 2000005b: CCB: desc idx 0: RNG: Hardware error
# The caam-keyblob driver relies on the CAAM RNG, which fails to instantiate
# on affected chips (temperature-dependent). On mainline, NXP fixes for this
# are not integrated automatically.Updates: signierte RPMs, A/B, Unterbrechungssicherheit
Das sichere System muss aktualisierbar bleiben - sonst ist es im Feld nicht wartbar. Updates laufen als signierte RPM-Pakete über DNF; der Public Key liegt im Read-only-Rootfs. Das System-Image (U-Boot, Kernel, Rootfs) wird als signiertes Paket erzeugt; Anwendungen werden separat auf dem beschreibbaren Bereich installiert und aktualisiert.
A/B bedeutet: Ein neues Image landet immer in der inaktiven Systempartition, die neueste Konfiguration wird auch für die aktualisierte Partition aktiv. Der Ablauf ist unterbrechungsfest - mit Zustandsprotokoll und Retry-Zähler. Für Kernel-Panics muss ein Watchdog aus U-Boot heraus aktiviert werden; Rollback gibt es auf System- und auf Anwendungsebene.
Unterschieden wird zwischen behebbaren und nicht behebbaren Fehlern: Power-Loss/Reboot ist recoverable, solange der letzte erfolgreiche Schritt bekannt ist und ein Retry-Zähler mitläuft. Kernel-Panic/System-Stall beim Boot ins neue Image, fehlgeschlagene Datenmigration oder ein inkompatibles Anwendungspaket sind nicht recoverable - hier ist ein Reset per Watchdog bzw. ein Rollback zwingend. Die Schritte im Einzelnen:
- Update-Auftrag vom Backend empfangen.
- Neues System-Image in die inaktive Partition flashen.
- In das neue Image rebooten.
- Default-Start der Anwendungen deaktivieren.
- Backups für den Rollback anlegen.
- /var/lib/rpm und Systemkonfiguration migrieren.
- Neue Anwendungen installieren (mit dem Update-Auftrag geholt).
- Anwendungen im Migrationsmodus starten, dann im Normalbetrieb.
- Abschluss des Update-Auftrags ans Backend melden.
Die RPM-Datenbank-Falle
/var/lib muss ein Overlay sein (die RPM-Datenbank liegt dort). Nach einem System-Image-Update schattet aber die alte Overlay-Datenbank die aktualisierte System-Datenbank ab - und die alte Datenbank kennt die separat installierten Anwendungen, die während der Geräte-Lebenszeit nachinstalliert wurden. Sie muss wieder brauchbar werden.
Ein Spike zeigte: Datenbank-Rebuild (Option 1) oder partieller Rebuild (Option 2) sind nicht tragfähig. Der gangbare Weg: Overlay-RPM-Datenbank löschen, die SquashFS-Datenbank wieder sichtbar machen, das Overlay von Binaries bereinigen und die Datenbank mit den nötigen Paketen neu befüllen (rpm --justdb). Das gehört zu jedem System-Update, das auch die Anwendungen aktualisiert.
# Repopulate the RPM database without reinstalling files or running scripts
rpm --justdb --noscripts --notriggers bash.rpm
rpm -Uvh --justdb bash*rpm
# --justdb update only the database, not the filesystem
# --noscripts do not execute package scriptlets
# --notriggers do not execute trigger scriptletsBootloader-Update und Migration der Flotte
Für den Bootloader gibt es drei dokumentierte Pfade: aus dem laufenden Linux (SCP aufs Gerät, NOR-MTD identifizieren, löschen, dd mit 0x400-Offset, Readback per cmp), per TFTP aus U-Boot (sf probe/erase/write) und per UUU/Fastboot im Serial-Download-Modus. Letzterer ist auf geschlossenen Geräten deaktiviert - ein Angriffspfad, denn ein signierter Bootloader lässt sich aus einem Update-Image extrahieren. Fastboot gehört deshalb nicht in den ausgelieferten Bootloader.
Bestandsgeräte lassen sich migrieren, aber der Ablauf ist heikel: Bei produktiv gesperrten Geräten ist der USB-Zugang deaktiviert, das Bootloader-Update muss also aus dem laufenden Linux erfolgen - ein Fehler hier zerstört das Gerät. Der Pfad: Bootloader aktualisieren, per U-Boot-Konsole neu partitionieren (A/B), Rootfs und fitImage per TFTP schreiben, eMMC einrichten, env save, booten. Beim ersten Start erzeugt das System selbst den verschlüsselten Speicher und die Overlays; danach wird das signierte RPM installiert.
Härtung wird gestaffelt: Das Produktiv-Image enthält die finalen Maßnahmen vorbereitet, aber noch nicht aktiviert (aktiviert per Datei oder Bootloader bei der Provisionierung); das Entwicklungs-Image ist nah am Produktiv-Image, aber ohne aktivierte Sicherheit und mit Entwickler-Werkzeugen. Und ehrlich bleiben: Wo Maßnahmen noch nicht merged oder getestet sind, gehört das dokumentiert - ein Sicherheitskonzept ist nur so gut wie sein nachweisbarer Stand.
# Bootloader update from running Linux (closed device: USB is off)
mtdinfo -a
# mtd1: Name spi1.0, Type nor, Eraseblock 4096 bytes, 1 MiB total <- the NOR
flash_eraseall /dev/mtd1
dd if=/media/card/flash.bin of=/dev/mtd1 bs=1024 seek=1 # 0x400 offset
# Readback + compare MUST show no difference
dd if=/dev/mtd1 of=/media/card/readback.bin bs=1024 skip=1 count=$(stat -c%s /media/card/flash.bin)
cmp /media/card/flash.bin /media/card/readback.bin -n $(stat -c%s /media/card/flash.bin)
# Sanity: the IVT magic at offset 0x400
dd if=/dev/mtd1 of=/media/card/beginning.bin bs=1 count=1040
hexdump /media/card/beginning.bin
# 0000400 00d1 4020 8000 0090 0000 0000 0000 0000Stolperstein-Checkliste
Aus Workshops und Praxis entlang der Vertrauenskette immer wieder dieselben Kandidaten - wer sie früh prüft, spart sich teure Board-Bring-ups:
- SPL-Größe: Passt der signierte SPL noch in den verfügbaren SRAM/Boot-Bereich?
- Separate Boot-Partition: U-Boot kann SquashFS nicht von UBI lesen - fitImage auslagern.
- CSF-Padding: CSF_PAD_SIZE, CONFIG_CSF_SIZE und SPI-Offset synchron halten.
- CRC: Legacy-CRC nach dem Signieren ungültig - Check deaktivieren oder CRC erneuern.
- Schlüsselhandling: Entwicklungs- und Produktionsschlüssel strikt trennen, nie einchecken.
- Key-Rolling: SRK-Slots und Revoke-Mechanik von Anfang an mitdenken (SRK3 ist nicht sperrbar).
- BSP-Support: Mainline-BSPs bringen NXP-HAB/CAAM-Features oft nicht mit - Tradeoffs bewusst entscheiden.
- Fertigung und Rollout: Fuses brennen ist one-way; erst offen testen, dann schließen; Migrationspfad für Bestandsgeräte planen.
Die öffentliche Literatur deckt das Verfahren ab: NXP AN4581 (i.MX Secure Boot on HABv4 Supported Devices), AN12263 (HABv4 RVT Guidelines and Recommendations), AN12056 (Encrypted Boot on HABv4 and CAAM Enabled Devices), AN12714 (i.MX Encrypted Storage Using CAAM Secure Keys), AN12838 (Strengthening Public Key Cryptography using CAAM Secure Key), die U-Boot-HABv4-Guides (doc/imx/habv4), die Kernel-dm-verity- und IMA/EVM-Dokumentation sowie die veritysetup- und rpm-Manpages. Zur SquashFS-Unterstützung in U-Boot: arXiv 2206.12751. Wer tiefer einsteigen will: Die Quarkslab-Analyse zu HAB-Schwachstellen zeigt, warum eine korrekt implementierte Kette mehr ist als nur ein Fuse-Bit.
Der begleitende Artikel „USB-Boot mit HAB-Signaturprüfung" setzt genau diese Kette fort: ein Recovery-Boot vom USB-Stick, der die Verifikation erbt, statt sie zu umgehen. Die zugehörige Fallstudie im Projektbereich ordnet die Arbeit in den realen Engagement-Kontext ein.
