Skip to main content

TECH VEDA

Corporate on-site training - Submit proposal Pick your modulesSharpen your kernel skills: deep dives, drivers, Yocto, CVEs, careers — updated daily. Read the blog →
Talks

FIT Signature Verification: What Does the Signature Cover, and What Gets Booted?

What does FIT signature verification cover in a signed image? A report on Ahmad Fatoum's ELC Europe 2026 talk and what has changed since.

FIT Signature Verification: What Does the Signature Cover, and What Gets Booted?

A FIT signature protects only the bytes it covers. At Embedded Linux Conference Europe in October 2026, Ahmad Fatoum of Pengutronix e.K. showed which parts of a FIT the two existing signing modes leave uncovered, how one uncovered property led to CVE-2026-33243, and a proposal to sign the whole image before any of it is parsed. Fixed releases of U-Boot and barebox are available; the whole-image scheme was still an open specification proposal on 13 November 2026.

Most embedded Linux products that use verified boot rely on FIT signature verification in U-Boot or barebox to decide whether a kernel, device tree and ramdisk may run. The talk reported here asks a narrower question than whether the FIT signature is valid: which bytes does it cover, and are those the bytes the bootloader then boots? This article reports what the slides say, then adds what has changed since and what a product team should do. It has not been checked against the recording.

The talk

The talk is “FIT Happens: How Secure Boot Wasn’t”, given by Ahmad Fatoum, Pengutronix e.K., in the Embedded Linux Conference track of Open Source Summit + Embedded Linux Conference Europe 2026 in Prague. It was scheduled for Wednesday 7 October 2026, 11:20 to 12:00 CEST, a 40-minute slot.

The problem: what FIT signature verification is expected to guarantee

A FIT (Flat Image Tree) packs a kernel, device trees, a ramdisk and other boot components into one file, together with configurations that say which components boot together. The file uses the flattened device tree binary format as its container. With verified boot enabled, the bootloader holds a public key, checks a FIT signature stored inside the file, and refuses to boot when the check fails.

The difficulty is that the FIT signature, the list of what it covers and the description of what to boot are all stored inside the same untrusted file, and the bootloader has to parse that file before it can check anything. TECH VEDA described one consequence in July, when six parser flaws in this code were disclosed, in How U-Boot Verified Boot Was Broken by Its Own Image Parser. This talk covers a different consequence: cases where the parser works as written and the signature still does not protect what the integrator believes it protects.

The argument

The slides open with history. FIT replaced the older uImage multi-file format, and the device tree format became its container because it is flexible, tools existed, and U-Boot already contained a parser. According to the slides, more features were then added. Image data may now be stored outside the tree, where the size field of the device tree header does not count it, so the full extent of a FIT cannot be known without parsing every image node. U-Boot itself is commonly loaded from a FIT by the SPL, and the slides state that some device tree checks are left out of the SPL for size reasons.

Signing was added to this format later, in two modes: a FIT signature on each image, or one on each configuration. The speaker’s position is that the first mode is insecure by design and that the second still leaves much of the file unsigned. One slide lists dozens of commit identifiers for fixes to FIT and its dependencies in both bootloaders. The talk then explains CVE-2026-33243, proposes whole-file signing, and ends with advice on updates and testing. The slides also give his opinion that language models make this more urgent, because a signed image, the public source and a fix commit are enough input to produce an image that an unpatched bootloader still accepts.

The points worth your attention

1. An image signature covers the data and nothing else

In image signing, each image node carries its own FIT signature, computed over the image data only. The load address and the entry point are properties of the same node and are not signed. The slides describe the result: an attacker who can write to the FIT adds an unsigned payload and sets the entry point to it, and the signed data still verifies. The slides note that the barebox bootm command never accepted image signatures, and refer to a proof of concept on a BeagleBone Black posted to the U-Boot mailing list on 5 March 2026.

The slides name three places where image signing is still produced: the OE-core uboot-sign.bbclass with SPL_SIGN_ENABLE = "1", which signs TF-A, OP-TEE, the device tree and U-Boot one by one; mkimage -f auto used with its signing options; and, marked as a question, upstream U-Boot SPLs that implement board_fit_image_post_process().

2. Signing and booting use different code to select nodes

Configuration signing covers more. The FIT signature is stored in the configuration node and covers a list of nodes, including the hash node of each image, so a changed entry point or a changed hash algorithm breaks it. The slides list changes that still verify after signing, among them added images and configurations, a changed default configuration, and parts of the signature node itself.

The last item led to the CVE. A FIT signature node has this general shape:

conf-1 {
        kernel = "kernel-1";
        signature-1 {
                algo = "sha256,rsa2048";
                hashed-nodes = "/", "/configurations/conf-1",
                               "/images/kernel-1",
                               "/images/kernel-1/hash-1";
                value = [ ... ];
        };
};

As the slide puts it, “hashed-nodes tells the verifier which nodes were hashed, but is not hashed itself”. In the attack the slides describe, the original kernel node is kept at a new path, hashed-nodes is rewritten to name that path, and a different kernel is placed in the node the configuration refers to. The verifier hashes the first node and the boot code loads the second. The slides generalise this: one piece of code decides what was signed, by comparing full path strings, and another decides what to boot, by node lookup, and one disagreement between them is a signature bypass. They list other ways to cause a disagreement, including unit addresses, case-insensitive name matching and slashes in node names. The slides credit the report to Apple Security Engineering and Architecture and give the fix as rebuilding the node list from the image references in the configuration, in U-Boot v2026.04 and barebox v2026.03.1.

3. Verify first, then parse

The proposal changes the order of operations. According to the slides, the bootloader today parses the tree and resolves image references both before and after verification. In the proposed scheme, a FIT is marked by a magic value in a device tree header field that FIT does not use. A new 24-byte FIT header follows and records the size of the external data. The bootloader then reads a few integers at fixed offsets, checks their bounds, hashes the whole file from the first byte to the end of the external data, and verifies one signature. The slide states the goal as “No FDT parsing before signature verification”.

A metadata trailer of tag-length-value entries follows the signed region and is not covered, so a field such as an installation identifier can be rewritten without re-signing. For compatibility, the slides propose signing both ways during a transition: an old bootloader ignores the new header and checks the configuration signature. They add that device policy must fix which FIT signature is required; the bootloader must not infer it from the magic value. The slides acknowledge existing whole-file approaches, such as CONFIG_IMAGE_PRE_LOAD_SIG in U-Boot, but call for a generic, documented scheme.

What has happened since

We checked the following on 13 November 2026.

  • The whole-image proposal is not merged. The pull request against the FIT specification, opened on 6 April 2026, is still open. A specification maintainer wrote on 2 September that the approach was agreed, provided the parsing is kept simple, and on 3 November the author replied to a query that he will write the next revision. The slides list the definition of a signature entry for the trailer, and the implementation, as steps that follow the merge.
  • The public record for CVE-2026-33243 lists barebox from 2016.03.0 as affected and 2026.03.1 as patched, with a backport in 2025.09.3. The U-Boot flaw is tracked as CVE-2026-46728, and its database entry lists U-Boot before 2026.04 as affected.
  • The current U-Boot release is v2026.10, published on 5 October 2026, so the fix has been in U-Boot releases since v2026.04.
  • The OE-core change that moves the SPL FIT from image signatures to a configuration signature is not merged. Version 3 of the series, posted on 3 June 2026, is marked “Changes Requested”, and the class in the OE-core repository still places signature nodes inside the image nodes.
  • The barebox migration guide for 2025.09.3 now warns that a FIT whose signature left some images out may stop booting after the fix.

What it means for a product team

This section is TECH VEDA’s reading, not the speaker’s.

First, find out which signing mode your build produces. Inspect the FIT that your device verifies, including u-boot.itb if the SPL verifies U-Boot, and see where the FIT signature nodes are. If they are only inside image nodes, every property except the data can be changed, and a Yocto build that uses the unmodified class for the SPL FIT was affected when we checked. Check also that the key in the bootloader’s control device tree is marked as required for configurations.

Second, confirm the fix by commit, not by version string. A vendor fork based on an older release needs the node-list change backported.

Third, add negative tests to your release process. The slides warn that a missing configuration option or a missing mkimage -r flag can leave a device insecure without any error, and ask: “Do you test that an unsigned FIT is indeed refused?” The -r flag marks the key as required; without it, verification with that key is not enforced. A test that boots a correctly signed image does not show this. The speaker also published a web tool which, according to its page, modifies a FIT in these ways; whether a production image may be uploaded to an external site is a matter for your own security policy.

Fourth, make sure the bootloader can be replaced in the field. Every fix above needs a bootloader update.

The slides do not state when whole-image signing will be usable, how its signature will be stored, or how many shipped products use image signing.

What was checked and what could not be verified

We worked from the slide deck attached to the event programme, read on 13 November 2026. A recording was published in early November 2026; this report has not been checked against it, so anything said only aloud is absent, and the three quotations are slide text. The sources read for the later developments are listed in References. The speaker’s tool page names barebox 2026.03.0 as fixed, while the slides, the advisory and the CVE record name 2026.03.1; we used the latter. We tested no bootloader ourselves.

Key takeaways

  • Image signatures in a FIT cover image data only; load address and entry point stay unsigned.
  • A FIT signature on a configuration covers more, but verifiers trusted an unsigned list of hashed nodes until the fixes for CVE-2026-33243 (barebox v2026.03.1) and CVE-2026-46728 (U-Boot v2026.04).
  • Whole-image signing with a FIT header is agreed by a specification maintainer but not merged; the slides list implementation as a later step.
  • Test that your device refuses an unsigned and a modified FIT, not only that it boots a signed one.
Was this worth your time?

Frequently asked questions

What does an image signature in a FIT cover?

Only the image data. The load address and the entry point in the same image node are not signed, so they can be changed without breaking the signature.

What was wrong with the hashed-nodes property?

It lists the nodes that were hashed when the configuration was signed, but the property was not part of the hash. An attacker could rewrite it so that the verifier hashed one node while the bootloader booted another.

Which bootloader versions contain the fix?

U-Boot v2026.04 and barebox v2026.03.1, according to the slides and the public CVE records. The record for CVE-2026-33243 also lists a barebox backport in 2025.09.3.

Can I use whole-image FIT signing today?

Not in the proposed generic form. On 13 November 2026 the specification pull request was still open, and the slides list the signature entry and the implementation as later steps.

References

RB
Raghu Bharadwaj

Founder, TECH VEDA — 20+ years teaching the Linux kernel, device drivers and embedded systems.

Follow on LinkedIn

Get new posts by email

Kernel, embedded Linux and AI-era engineering — a few sharp reads a month. No spam.

We email occasionally and never share your address.