//nefariousplan

Unmitigated Binary

A binary compiled without the standard exploit mitigations (PIE, stack canary, FORTIFY_SOURCE, full RELRO). Every memory-safety bug becomes RCE because the build, not the source, decides exploitability.

The CVE record names a buffer overflow or format string in a function. The patch closes the write. The severity label on the record stays "critical, remote, unauthenticated code execution."

The label was never in the function. The label was in the build. A memory-safety bug in a binary with PIE, a stack canary, FORTIFY_SOURCE, and full RELRO is a controlled crash plus a leak-and-pivot exercise that may or may not compose into code execution. The same source bug in a binary carrying none of them is a reboot-stable, cross-deployment, cut-and-paste RCE chain. The compiler flags that decide which of those two artifacts the toolchain emits are documented in every distro's packaging guide and carried by every mainstream toolchain since the late 2000s. When the shipped ELF carries none of them, the next memory bug in the same binary inherits the same amplifier the patched one did.

Mechanism

Four build-level mitigations do the work that separates memory-safety-bug-as-DoS from memory-safety-bug-as-RCE. Position Independent Executable builds plus ASLR randomize the virtual address space, forcing any gadget chain to acquire a base-address leak before it is usable. Stack canaries insert a per-process secret between local variables and the saved return address, so a linear stack overflow that reaches saved RIP must first read the canary out through some other primitive. FORTIFY_SOURCE rewrites length-aware libc calls at compile time to abort on size violations the compiler can prove, turning a subset of overflows into controlled aborts and blocking %n format-string writes into writable GOT entries by rewriting printf to __printf_chk. Full RELRO maps the GOT read-only after dynamic linking, removing the single most common write target an attacker reaches for once they have an arbitrary write primitive. A binary with all four shipping default-on is not unexploitable; it is a binary where exploitation requires a chained second primitive (information leak, write-what-where, arbitrary read) that the one memory bug may or may not provide. A binary with all four off presents the saved RIP, the GOT, and a static gadget table as a single step.

The compilation toolchain decides which of these bytes end up in the shipped ELF. The source code does not; the CVE record does not; the researcher's PoC does not. A vendor that ships a 2026 firmware with a binary carrying no PIE, no canary, no FORTIFY, and partial RELRO has made a build-system choice decades after the toolchain made the safer choice available. The choice is inherited by every binary the same build pipeline emits, so the next CGI handler, the next long-running daemon, and the next IPC helper in the same image carry the same amplifier. When a memory bug is disclosed and patched in one function, the patched release ships the source fix and leaves the amplifier in place. The next source-level bug in the same binary reaches the same amplifier and carries the same exploitability class. The exhibit set shows the shape at three scales: a NAS vendor's CGI with eight sscanf overflows and a format string on a binary with zero mitigations (CVE-2026-6643, ASUSTOR vpnupload.cgi); a drone autopilot with a sixty-byte filepath overflow on a NuttX build whose stack canary coverage is absent on the affected compile unit (CVE-2026-32743, PX4); a firewall VPN daemon whose public exploit lists absolute virtual addresses for its ROP gadgets because the binary is not position-independent (CVE-2025-9242, WatchGuard iked).

The observable signature in a CVE record is the gap between the researcher's working exploit and the maintainer's patch. The exploit's gadget table contains absolute virtual addresses; the overflow reaches saved RIP without a canary-recovery step; %n writes against the GOT succeed without being rewritten to __printf_chk. The patch fixes the bounds check or the format string. The build system is not touched. On the next CVE in the same binary, the attacker reuses the same absolute addresses because the binary is not position-independent, and the exploit that worked on version N works on version N+1 with a single offset change. The amplifier is not a bug in a function. It is the default state of a toolchain configuration nobody reread when the function was patched.

Exhibits

CVE-2026-6643: ASUSTOR's vpnupload.cgi Has Eight Buffer Overflows on a Binary With Zero Mitigations. ASUSTOR's vpnupload.cgi is the smallest possible reproduction of this pattern. The handler ships eight sscanf("%s") buffer overflows and one printf(user_data) format string in a single function, and the binary they live in has no PIE, no stack canary, no FORTIFY_SOURCE, and partial RELRO with a writable GOT. With FORTIFY_SOURCE on, %n writes against the writable GOT would have been blocked at the __printf_chk rewrite. With a stack canary, the saved-RIP overwrite would have required a leak-and-restore choreography the format string would have had to support. With PIE, gadget addresses would not be static. The exhibit shows the substrate as table: four compiler flags, all off, all default in upstream toolchains for fifteen-plus years, all off in a 2026-stamped firmware. The patch closes the eight sscanf bugs and the one printf bug. The build, the substrate that decides whether any future memory bug in any of this firmware's CGI siblings is RCE, ships unchanged.

CVE-2026-32743: PX4's Sixty-Byte Filepath, And A Temporal Cascade That Is A For Loop. PX4 Autopilot ships its NuttX builds without the standard memory-safety exploit mitigations: no PIE, weak or absent stack canaries, no FORTIFY_SOURCE on the affected compile unit. CVE-2026-32743 is a sscanf write past the end of LogEntry::filepath[60]. On a binary with a stack canary it is a controlled crash; on a binary with PIE plus a canary it requires a separate leak before any control of execution. Both public PoCs only demonstrate DoS, not RCE, because neither author chose to climb the substrate-specific exploit ladder, but the substrate is permissive enough that the climb exists. The patch closes the source-level overflow with a width specifier and a larger buffer. The build, the substrate that decides whether the next memory bug in the autopilot's MAVLink stack is RCE, ships unchanged.

CVE-2025-9242: WatchGuard's iked Buffer Is 512 Bytes. The Build Number Comes Before the Overflow.. The watchTowr exploit's gadget table is a list of absolute virtual addresses inside iked: pop rcx; ret at 0x4225ab, mov rax, rcx; ret at 0x5a4fac, pop rsi; ret at 0x508ece, GOT of bind at 0x658028. These addresses are stable across reboots and across every deployment of the same build. They mean iked is not compiled with PIE. The chain that works on one Firebox works on every Firebox running 12.11.3, with no leak step required. CVE-2025-9242's source-level cause is one missing length check; CVE-2025-9242's exploitability as remote unauthenticated RCE is the build flag that did not ship. With PIE the attacker would need a base-address leak before the gadget table is meaningful. With a stack canary the saved-RIP overwrite would require a leak-and-restore choreography the OOB write does not support. The substrate, not the source, decides whether iked memory bugs are RCE. The patch closes one OOB write. It does not rebuild the binary.

Boundaries

Not every recurring-RCE binary is an unmitigated binary. design-debt-driver names a component whose architecture produces bugs of the same class across years; the fertility is in the source design. unmitigated-binary names a build artifact whose compiler flags turn any one such bug into RCE; the fertility is in the toolchain configuration. The two can co-occur in the same artifact, but the amplifier is distinct from the substrate that produces the triggers. One isolated memory bug in an unmitigated binary is sufficient to trigger this class; a recurring source-level pattern is not required.

Not every long-lived attack surface is an unpatchable-primitive. An unpatchable primitive is a design-level capability the component exists to provide; removing it would mean removing the component. Compilation flags are not a design primitive. One Makefile edit, one CMake setting, or one Yocto recipe adjustment removes the amplifier without changing what the binary does. The binary is patchable; the build pipeline is what did not get patched.

Not every opt-in safety mode that shipped off is safe-mode-was-opt-in. That pattern names runtime flags on a library's public API that the library's consumer must set at call time. Build-level mitigations are compiler-driver and linker flags the Makefile author sets once, applied uniformly to every output of the toolchain, and inaccessible to the library's callers. The failure mode lives in the build system, not in a per-call-site omission.

Not every build-flag misconfiguration is an unmitigated binary. debug-flag-left-on names a feature flag defined in production headers that gates a security-relevant capability inside the source. The feature is in the code; the macro is in the code; both are visible to a source audit. Unmitigated binary is the inverse: the source audit shows nothing missing. The missing bytes are compiler-inserted canary probes, linker-inserted RELRO relocations, and position-independent code sequences the toolchain can emit but the build did not request. The audit surface is the ELF, not the repository.

Defender playbook

Run checksec, hardening-check, or BinSkim against every release artifact, including every binary inside firmware images, container layers, and OS install images. Record the mitigation table (PIE, stack canary, FORTIFY_SOURCE, RELRO) next to the version string in release metadata. Treat any missing mitigation as a build-configuration bug equal in severity to the worst memory-safety bug the artifact has ever carried, because the next memory-safety bug in the same artifact will inherit the same amplifier.

Encode the mitigation set as a hard CI gate. The build pipeline must not emit a shipping ELF that fails the hardening audit. The source team cannot opt out by forgetting to opt in, because the gate fires on every artifact. For projects that cross-compile to multiple targets (firmware families, kernel variants, embedded profiles), run the gate per target; a compile unit whose canary coverage was dropped for size reasons in one profile is still an unmitigated binary in that profile.

On CVE triage for any memory-safety bug (stack overflow, heap overflow, UAF, format string, OOB write), fetch the vendor's shipped binary before trusting the patch. Diff the mitigation table between the pre-patch and post-patch release. If the table is unchanged, the patched release is the pre-patch exploit minus one trigger function; the public PoC's absolute gadget addresses, canary absence, or GOT writability still apply to every other reachable memory bug in the same binary. Require the vendor to rebuild with hardening flags as a condition of calling the release "patched."

For memory-unsafe code you cannot replace on the vendor's timeline (legacy daemons, firmware CGIs, embedded blobs), compile-time mitigations are a cheaper intervention than source audits. A single build-system change hardens every binary in the image against every memory bug the image will ever ship, including the bugs no researcher has filed yet. Prioritize PIE and full RELRO first (they foreclose the largest class of reusable gadget-chain exploits), then stack canaries, then FORTIFY_SOURCE.

Kinship

Design Debt Driver. Shares the observation that the substrate, not the current patch, decides the next CVE's severity. Design Debt Driver locates the substrate in the component's source architecture; Unmitigated Binary locates it in the build pipeline that compiled the component. The two can stack: an unmitigated binary compiled from a design-debt-driver's source is where researchers come back year after year with the same shape of chain.

Unpatchable Primitive. Both patterns name a property that outlives the current patch. Unpatchable Primitive is a design-level capability that cannot be removed without changing the component's purpose. Unmitigated Binary is a build-level amplifier that can be removed with one toolchain-flag change but typically is not, because the CVE record and the patch workflow point at the function, not the Makefile.

Default Is The Mitigation. Both patterns describe a fix that moves a value rather than removing a primitive. Default Is The Mitigation moves an application-level default that a request field can still override. Unmitigated Binary leaves the toolchain default (mitigations off) in place and never moves it at all; the amplifier is not even reframed as a value the caller can read.

Every patch in an unmitigated binary closes one trigger. The amplifier ships with the next release.