tianocore

TianoCore disclosed CVE-2026-97631 (9.5) in EDK II's PXE boot driver. Crafted ICMP errors during network boot may hang affected systems or permit targeted pre-OS code execution. For MSPs/admins: inventory PXE-boot systems, disable network boot where unused, isolate provisioning traffic, and check for vendor firmware updates. Exposure is during PXE boot, not every startup. TianoCore lists no patched release. github.com/tianocore/edk2/security/advisories/GHS…

記事に気付いてなかったから、今後は定期的に巡回しておこうかな… github.com/tianocore/edk2/security/advisories

Pre-boot RCE in EDK II PXE driver CVE-2026-97631

🚨🇺🇸 Critical 16-year-old EDK II flaw enables code execution before Secure Boot A critical buffer overflow in TianoCore EDK II, the open-source foundation used to build much of the world’s UEFI firmware, can allow an unauthenticated attacker to run code before the operating system loads. Tracked as CVE-2026-97631, the vulnerability carries a CVSS score of 9.5 and has existed in the code since November 2010. ⠀ The flaw resides in the PXE network-boot driver, which copies incoming ICMP error messages into a fixed 504-byte buffer without properly limiting their size. ⠀ An attacker who can reach a machine while it is booting over the network can send a crafted ICMP message that: • Crashes the firmware and prevents the operating system from loading • Executes attacker-controlled code in the pre-boot environment • Runs before Secure Boot and measured-boot protections evaluate the operating system ⠀ Reliable code execution requires knowledge of the target’s firmware build. Systems that boot exclusively from local storage are not exposed through this attack path. ⠀ An upstream fix was merged into EDK II on October 15, but no stable EDK II release currently includes it. Server and motherboard vendors must integrate the patch and distribute BIOS or UEFI updates to customers. Source: github.com/tianocore/edk2/security/advisories/GHS…

Ping of death is back 💀 github.com/tianocore/edk2/security/advisories/GHS… TLDR; Ping during PXE boot can crash or get RCE because of vulnerability in UEFI. t.co

A 16-year-old buffer overflow boots before your defenses: CVE-2026-97631 in EDK II's PXE driver --- published: true tags: security, firmware, uefi, infosec description: "A 16-year-old buffer overflow in TianoCore EDK II's PXE driver (CVE-2026-97631, 9.5) runs code in ring 0 before Secure Boot and TPM load. The fix diff, the embargo AMI broke a month early, the fleet audit - and the QEMU harness I built to reproduce it, documented honestly including where it stopped." series: black box --- > There is a buffer overflow in the network-boot driver of TianoCore EDK II - the open-source UEFI reference implementation that virtually every server BIOS on the planet derives from - and it has been there for sixteen years. CVE-2026-97631, rated 9.5: during a PXE network boot, an oversized ICMP error message writes attacker-controlled bytes past a 504-byte struct, corrupting firmware memory - code execution in ring 0, before Secure Boot and TPM even load. Found by Alex Matrosov and Dan Holmes. And the disclosure itself broke: AMI pushed the fix to a public repo a month ahead of the coordinated date, forcing an early advisory. The fifth disclosure-pipeline failure of the month, on the blog that has been counting them. This post: the mechanism from the actual fix diff, what the bug does and doesn't give an attacker, the embargo story, a fleet audit you can run in one line - and the headless QEMU harness I built to reproduce it (now on GitHub: slabbdev/uefi-pxe-cve-2026-97631), documented to the exact point where my hardware said no. The bug, read from the fix The vulnerable code lives in NetworkPkg/UefiPxeBcDxe/PxeBcSupport.c - the handler that processes ICMP error messages arriving while the firmware network-boots. Here is the actual buggy loop, from the repo, before the patch (PR #13200, opened Sept 28): CopiedLen = 0; IcmpError = (UINT8 *)&Mode->IcmpError; // EFI_PXE_BASE_CODE_ICMP_ERROR = 504 bytes for (Index = 0; Index < RxData->FragmentCount; Index++) { CopiedLen += RxData->FragmentTable[Index].FragmentLength; // (1) if (CopiedLen <= sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR)) { CopyMem (IcmpError, ...FragmentBuffer, ...FragmentLength); // (2) } else { CopyMem (IcmpError, ...); // the else branch copied too - truncated in the diff, same object } } Two textbook flaws stacked: the bound is checked against the cumulative length after adding the fragment (1), and a copy happens in both branches (2). Craft an ICMP error whose quoted payload exceeds 504 bytes - trivially, since the ICMP error body is just "original datagram" bytes you control - and the writes run past the end of the IcmpError struct inside the firmware's DXE phase. The fix introduces a FragmentLen variable and copies strictly bounded amounts per fragment. What that buys an attacker, precisely: memory corruption in ring 0, in firmware, during the boot window - before the OS, before Secure Boot's runtime protections matter, before TPM-measured boot captures anything sane. The researchers note it can bypass remote attestation and break disk encryption assumptions. What it does NOT buy: this is not an internet-facing RCE. You need a position on the local network, a target that actually does PXE network boot (datacenter servers, fat clients - not your laptop booting from disk), and per-model tuning of the exploit. It is an insider/nation-state/ransomware escalation tool, not a worm. The disclosure that broke The coordinated embargo targeted January. Then AMI - an IBV whose BIOS AMI, Insyde, Phoenix and OEMs ship - published the fix pull request on September 28, a month early, blowing the timeline and forcing the early advisory. The PR is still there, timestamped, from an AMI engineer. Ars asked AMD, Phoenix, AMI, Microsoft and Amazon for comment; none answered. Intel and Arm claim their products aren't directly affected, though both borrow from EDK II lineage. The month's disclosure-failure scoreboard, for those keeping count: LiteLLM reposted with scrambled dates, ZDI's private queue leaked to the public LKML, eMudhra blamed "amplification", a measured PHP advisory got dressed as BREAKING - and now an IBV broke its own embargo. Five failures, five different mechanisms, one lesson: the pipeline around the vulnerability is the vulnerability. Audit your fleet - one line PXE is on by default on most server firmwares. The audit: # any network-boot entries in the firmware boot order? efibootmgr -v | grep -iE 'pxe|network|ip4|ip6' # BMC angle: many boards can enable network boot remotely - check yours ipmitool lan print 1 # if the BMC is reachable, PXE policy is BMC policy If nothing boots from the network and nothing can turn it on remotely, this CVE is not your fire today - but the patch wave is coming through your BIOS vendors over the next months, and unlike Secure Boot key rollovers, this one is a normal firmware update. Add "EDK II PXE fix" to the checklist of the next BIOS refresh cycle; disable network boot entirely on machines that never PXE. The harness - what I built, what worked, what didn't I tried to reproduce the crash locally, headless, on the exact vulnerable code. The harness (three small files, in the repo) is genuinely reusable for any OVMF boot-testing: - bridge.py - a Python DHCP server + attack tool on the QEMU wire: binds the QEMU socket UDP netdev pair, answers DHCP DISCOVER/REQUEST, waits for the TFTP read request, then fires 6× ICMP type-3 code-1 errors quoting a 1,200-byte fake datagram into a struct with room for 504. Pure stdlib, no scapy. - router.py - a screen-state router: classifies OVMF's screen from screendump pixel statistics (black = UEFI Shell, blue = front page/Boot Manager), then drives the headless firmware through the monitor (sendkey) into the Boot Manager and onto UEFI PXE IPv4 - no display, no VNC. - QEMU config: OVMF pflash, virtio-net on a UDP socket netdev (no multicast flakiness), filter-dump pcap tap on the wire, -d cpu_reset to catch firmware triple-faults. What worked: everything up to the PXE boot attempt, reproducibly. The firmware boots, the router navigates the Boot Manager blindly and lands on the PXE screen (Client MAC banner and all), the wire tap and reset counters are live, the DHCP/attack engine is armed. What didn't: the homebrew QEMU-bundled OVMF builds (IA32 and X64, q35 and i440fx) display the PXE banner and then transmit zero packets - the DHCP Discover never leaves the firmware under TCG emulation, so the ICMP trigger never arrives at the vulnerable handler. Reproducing further needs a serial-debug OVMF build (or a real machine with PXE enabled, which I won't point an overflow at outside a lab). The harness is documented to this exact boundary on purpose: it's the difference between "I ran it" and "I read it", and today this post is honest about being the second with the doors open for the first. TL;DR Sixteen-year-old overflow in the UEFI network-boot driver, ring 0 before your defenses load, local-network attack on PXE-booting fleets - patched in EDK II and rolling out through every BIOS vendor now. Check your boot order (efibootmgr), disable network boot where you don't need it, and add the fix to your firmware refresh checklist. The disclosure broke a month early, which is somehow the least surprising sentence of October. Sources: Ars Technica - Code-execution flaw in UEFI firmware · EDK II fix PR #13200 · EDK II fix PR #13302 · Harness repo: slabbdev/uefi-pxe-cve-2026-97631

CVE-2026-97631 (UEFI PXE pre-boot RCE) It looks like Hetzner dedicated servers are affected by CVE-2026-97631 Is there a good way to protect them until Hetzner rolls out a BIOS update?

@matrosov Отличная работа!🔥🔥🔥 github.com/tianocore/edk2/security/advisories/GHS… edk2#13200 edk2#13302

One ICMP packet can hijack a PXE-booting server before Secure Boot checks the OS. CVE-2026-97631 (9.5): pre-boot RCE in TianoCore EDK II. RCE needs a build-specific payload. By @matrosov (Anthropic) + Dan Holmes-Mitra (Google): github.com/tianocore/edk2/security/advisories/GHS… #UEFI #SecureBoot #RCE t.co

CVE-2026-97631: A 16-Year-Old Buffer Overflow That Runs Before Your Defenses Do Your server's security model has a load-bearing assumption buried in it: the code that runs first is trustworthy. Secure Boot, the TPM, disk encryption, remote attestation — all of it sits on top of firmware that executes before any of those defenses wake up. Yesterday's big story is about what happens when that assumption fails. CVE-2026-97631 is a 9.5-severity memory-corruption flaw in TianoCore EDK II, the open-source reference implementation of UEFI that virtually every firmware vendor — AMI, Insyde, Phoenix, and Microsoft's hardened Project Mu fork — builds on. It is a buffer overflow that has been sitting in the PXE boot driver for sixteen years. And it came to public attention the worst possible way: by accident, months before the coordinated disclosure date. Here is what the bug actually is, why the disclosure timeline matters as much as the code, and what to do about machines you are responsible for. The bug, precisely The vulnerable component is the PXE Base Code driver — NetworkPkg/UefiPxeBcDxe — the part of EDK2 that lets servers, storage gear, and other devices boot from code downloaded over a local network. During a PXE boot, the driver keeps a receive request open for ICMP error messages and copies each received message into a fixed 504-byte field (Mode.IcmpError) in its private context structure. The copy loop's bounds handling is wrong in both the IPv4 and IPv6 handlers: for a message longer than 504 bytes it keeps copying, and it advances the destination pointer by the cumulative length rather than the per-fragment length. Nothing earlier on the receive path restricts the message length at all. The result, per the official advisory (GHSA-99cj-7hg9-mp4m): an unauthenticated network attacker who can deliver ICMP error messages to a machine while it is PXE-booting — over IPv4 or IPv6, by simple unicast, from any network distance, as long as it arrives during the boot window — can corrupt DXE-phase memory. Best case for the attacker, worst case for you: a "counterfeit event" that executes attacker-controlled code on the CPU, in the UEFI firmware environment, at ring 0. Before the operating system loads. Before Secure Boot measures anything. Before the TPM attests to anything. The flaw carries a CVSS v4 score of 9.5: network attack vector, low complexity, no privileges, no user interaction. It was discovered by Alex Matrosov of Anthropic and Dan Holmes of Google, and the CVE record was published on October 22. Why "before your defenses" is the whole story Pre-boot code execution is a different category of bad than the application-layer flaws I usually write about here. The payload itself has no persistence — it runs once. But code running at ring 0 in the firmware environment runs before the chain of trust exists, which means it can poison the chain: install something that does persist, interfere with the measurements the TPM will later make, or get at secrets the boot process still holds. HD Moore put the concrete scenario plainly to Ars Technica: an attacker with short-term network access could use this to break disk encryption by hijacking program flow while the endpoint's TPM is still reachable. Easier still in a theft scenario. It also bypasses attestation — the cryptographic proof a machine gives to a remote server that its hardware and boot state are clean. If you can execute before the measurement, the measurement can be made to say whatever you want. This is the same architectural lesson as LogoFail (image-parsing bugs in firmware logos), PixieFail (the previous PXE boot flaws in EDK2), PKFail (non-production test keys shipped in hundreds of device models for over a decade), BootHole, and BlackLotus. The industry keeps finding that the code running before its defenses is its least-reviewed code. After PixieFail, researchers ran multiple fuzzing campaigns against EDK2 specifically to flush out the rest of this class. Those campaigns missed this one. Sixteen years, in a fixed-size copy loop, in the preeminent UEFI implementation on Earth. The disclosure was botched, and that changes your timeline The discoverers had arranged for the vulnerability to stay under wraps until a coordinated disclosure scheduled for January. Then, last month, AMI — one of the independent BIOS vendors that builds on EDK2 — published a public pull request that described the vulnerability in detail and included the fix. Once that was noticed, TianoCore members published the public advisory last week. The cat, as Dan Goodin wrote in Ars Technica, has left the bag. This is now the second botched security disclosure in a week, after the PHP2Shell mess. The mechanics of why it matters are identical and worth repeating: with public patch code, working out the trigger is not research, it is reading comprehension. Every advanced actor who cares now has both the vulnerability description and a reference fix to diff against. The window between "exploit trivially derivable" and "firmware patched across the fleet" is the exposure, and for UEFI that window is measured in months on a good day — firmware updates move slowly, through vendors, then through OEMs, then through whatever your org's maintenance process looks like. Moore's prediction is blunt: a "forever bug" that will live on in end-of-support systems permanently. One more uncomfortable detail: the upstream EDK2 advisory currently lists no patched version. Vendors are integrating the fix themselves. What this means if you run machines The honest caveats first. This is not a drive-by internet worm. Exploitation requires the ability to deliver ICMP messages to the target during its PXE boot window — meaning some position on the local network, and a target that actually network-boots. That realistically scopes the threat to insiders, ransomware operators who already have low-level internal access and want to elevate, and nation-state actors doing supply-chain or data-center work. For a laptop that boots from its own disk with PXE disabled, the practical risk is far lower. But if you run servers, storage, or anything that network-boots — and data centers do, at scale, by design — the checklist is short and unglamorous: 1. Inventory what actually PXE-boots. The attack window only exists while a machine network-boots. If a machine does not need PXE, disabling it removes the exposure entirely — this is the single cheapest mitigation available. 2. Treat boot-time network segments as trust boundaries. PXE traffic should live on isolated, controlled VLANs. If an attacker who lands in your flat office network can also reach machines during PXE boot, your segmentation is the vulnerability multiplier. 3. Track vendor firmware updates by name, not by OS patch cycle. AMI, Insyde, Phoenix, and Microsoft Project Mu downstreams will ship fixes on their own schedules. OS-level package managers will not save you here; this lives below them. Ask your hardware vendors which EDK2 base they ship and when the ICMP fix lands. 4. Watch EOL hardware. Anything out of support will not be patched. For those machines, mitigation is network-side: disable PXE, isolate the segment, or accept and document the residual risk. The pattern worth keeping Three stories this month rhyme, and the rhyme is the point. PHP2Shell: fix public before disclosure, scanners blind to the real exposure. The .NET out-of-band Brotli patch: the vulnerable decoder shipped everywhere, including in apps that bundle their own runtime. Now CVE-2026-97631: a 16-year-old copy loop in the firmware that runs before anything you call "security" starts. Different layers, same lesson — the trust chain is only as strong as its least-examined link, and the least-examined links are the ones everyone assumes someone else reviewed. Nobody reviewed the PXE driver's ICMP handler for sixteen years. Not because it was hidden, but because it was foundational, and foundational code has a way of becoming invisible. Check your boot path. It is the part of your security model you are currently taking on faith. --- *Sources: TianoCore EDK II security advisory GHSA-99cj-7hg9-mp4m — github.com/tianocore/edk2/security/advisories/GHS…; CVE record CVE-2026-97631 (published 2026-10-22) — cve.org; Ars Technica, "Code-execution flaw in UEFI firmware affects most servers on planet Earth" (October 27, 2026) — arstechnica.com