November 13, 2026
State That Outlives the Check
Six public exploit chains from the autumn of 2026 share one skeleton: the check was present, the check was correct, and the state itβ¦

By N5R1
11 min read
Six public exploit chains from the autumn of 2026 share one skeleton: the check was present, the check was correct, and the state it described had already moved.
0. A corpus, and a claim
This is not a disclosure. Nothing in this article is a new finding, and none of the six chains below is my work. Each one was published by the researchers who found it, and each one is cited at the end. What follows is a comparative analysis of public material: over the autumn of 2026 I dissected more than thirty public exploit chains one by one, and six of them turned out to share a skeleton worth naming.
The claim is narrow. In these six chains, the security check was usually present. It usually worked. The failure sat one step later, in an assumption nobody wrote down: that the state the check had just described would still be true at the moment the code acted on it. A path was validated, and then the path moved. A decoder state was measured against one window, and then the window shrank. A worker finished a request, and part of that request stayed behind for the next one. In every case, something the system remembered outlived the moment it had been checked.
Two sentences from my own notes kept recurring while I worked through the corpus. On the 7-Zip case: the bug is not in the parser, it is in what the decoder remembers. On the PHP case: an interrupted request leaves half-built state behind, and the next request on the same worker reuses it. This article takes those two observations seriously and tests them against six chains, using the same three questions for each: What is the state object? Which boundary did it cross? And where did the check sit relative to the change?
1. A name for the pattern: state-lifetime mismatch
A state-lifetime mismatch occurs when a component makes a decision based on a piece of state, and that state remains alive, reachable, or trusted beyond the point where the decision stops being valid. The check and the use are both real. What is missing is a binding between them: nothing guarantees that the thing checked is the thing used, or that the state left over from a previous step was ever re-examined.
Across the six cases, the pattern separates into five classes:
- Check/use gap. The classic time-of-check to time-of-use race. The state changes between validation and action, inside a single operation.
- Cross-request state. State outlives the request that created it and is inherited, silently, by the next request on the same worker or process.
- Half-built state. An error path skips cleanup, and the partial state left behind is later treated as if it had been fully constructed.
- Cross-artifact state. State is carried across a boundary between artifacts: archive volumes, snapshots, staged copies. The receiving side trusts it as if it had been produced locally.
- Shared-mutable concurrency. Shared state has no single owner and no lock discipline, so two execution contexts write the same memory under assumptions each believes are exclusive.
One measurement belongs up front, because it explains why this pattern is easy to miss. In the official vulnerability records, the six cases do not sit together. Two of them are filed under CWE-367, the TOCTOU category. The others are scattered across CWE-787 (out-of-bounds write), CWE-362 (race condition), and use-after-free headings. A single root pattern is distributed across at least four buckets of the official weakness taxonomy, so anyone browsing by category sees four unrelated bugs. The taxonomy files by symptom and mechanism. It does not file by the lifetime of the state involved, and that is precisely the dimension these six chains share.
2. PHP2Shell: the worker remembers the previous request
The state object. Per-request data inside a long-lived PHP worker process, together with global state that points into it.
The boundary crossed. The boundary between two consecutive requests handled by the same worker, and the boundary between a half-built request and the cleanup code that later walks it.
Where the check sat. There was no missing bounds check here in the usual sense. The failure was in the lifecycle: when a request bails out, the bailout mechanism (a longjmp) skips the cleanup that would have torn the request state down in order.
PHP2Shell is the collective name for two vulnerabilities in the PHP interpreter, analysed by CyStack from the work of researchers Calif and Wiz, and written up in depth by a2coder. In the first, CVE-2026β109618, request data that was only partially constructed is treated as valid during cleanup after a bailout, because the teardown path walks structures that were never finished. In the second, CVE-2026β109619, global state holding pointers into freed memory survives the end of the request and is used by the next request without being reset. The worker, in other words, finishes one request and begins the next one still remembering things it should have forgotten, some of them pointing at memory that no longer belongs to anyone.
This is class 2 and class 3 at once. The state crossed the request boundary (class 2), and part of it was never completely built in the first place (class 3). The most telling detail is the fix: both CVEs were closed by a single commit, and the commit is named "Avoid state corruption via bailout". The maintainers did not patch two unrelated memory errors. They patched the lifecycle that produced both. The affected range underlines the point: the vulnerable code runs from PHP 5.4 through 8.5, which means the assumption survived roughly a decade of scrutiny aimed at everything except the lifetime question.
There is a final echo worth recording. Applying the patch is not sufficient on its own; the worker processes must be restarted. A worker that is not restarted keeps executing the old code with its old memory intact. Even the fix, in other words, can be defeated by state that outlives it.
3. Claude Code CVE-2026β88968: the check was a photograph, not a binding
The state object. A filesystem path, validated once by name and symlink resolution.
The boundary crossed. The boundary of the sandbox workspace, crossed after validation and before the write.
Where the check sat. Before the change, and bound to nothing. The validation result was not tied to an inode or an open file descriptor, so it described a path string at an instant, not the object the write eventually reached.
The Claude Code Edit tool checked its target path once: name resolution and symlink resolution said the destination was inside the workspace, and the check was correct at the moment it ran. But code executing inside the sandbox could then replace a parent directory with a symlink, atomically, in the gap between the check and the write. When the Edit operation proceeded, it followed the new resolution and wrote outside the workspace. The advisory is GHSA-5xjx-9qx6-jcrv; Wiz's database entry records CWE-367 together with CWE-59 (improper link resolution), a CVSS score of 7.7, and the fix in version 2.1.251. Sessionboxer's analysis walks the same race in detail.
This is class 1, the textbook check/use gap, and its lesson is about what a check has to be bound to. A path is a name, and names are re-resolvable. A check bound to a name certifies the name at one instant. A check bound to the object itself, through a descriptor held open across the operation, certifies the thing actually written. The distance between those two designs is the whole vulnerability.
Nor was this an isolated slip. The same product had published an advisory in the same class a month earlier, GHSA-5j29-h97v-84ch, fixed in 2.1.129. When the same class recurs in the same product within weeks, the honest reading is not that one check was written badly. It is that the pattern, validate the name and then act on the name later, is a habit, and habits produce families of bugs rather than single instances.
4. 7-Zip CVE-2026β125742: the decoder remembers a larger window
The state object. The LZX decoder's history window position, carried inside the decoder across the volumes of a multi-volume CAB archive.
The boundary crossed. The boundary between archive volumes. State produced while decoding one volume is applied, unexamined, to the next.
Where the check sat. Inside the bounds logic, but keyed to an equality condition: the remembered position was reset only when it happened to equal the window size exactly.
The LZX decoder keeps a sliding history window, and in a multi-volume CAB that history legitimately crosses from one volume to the next. The defect, documented in the VulnCheck advisory for CVE-2026β125742 (CWE-787, affecting versions before 26.06) and visible in the 26.05 source of LzxDecoder.cpp, is in how the position is reconciled with the window. The stored position is reset only when it exactly equals the current window size. When a continuation volume declares a smaller window, for example when the geometry drops from a window measured in megabytes down to 32 KB, a stale position from the larger configuration is not reset. It passes the bounds logic written for the smaller window, and the resulting write lands far beyond the 32 KB buffer it was supposed to stay inside.
Nobody forged this state and nobody raced it. The decoder produced it itself, in correct operation, one volume earlier. The check that should have caught it was not absent; it was conditional in a way that left the general case, position larger than the new window, entirely unhandled. This is class 4: state crossing an artifact boundary and being trusted on the far side as though its provenance did not matter. The fix commit in the 7-Zip repository addresses exactly that reconciliation, which is another way of saying the bug was never really about the write. It was about what the decoder remembered, and for how long it was allowed to remember it.
5. WordPress CVE-2026β119977: transitional state is production state
The state object. A complete installation copy staged by a core update, sitting in a predictable, web-accessible directory.
The boundary crossed. The boundary between "an update in progress" and "the live site". For the length of the window, the staged copy was reachable as if it were production.
Where the check sat. Nowhere on the staged installer. The live site's authentication model simply did not extend to the transitional copy, and the window, though only seconds long, was long enough.
During a full package upgrade, WordPress unpacks an installation copy into the staging directory wp-content/upgrade. According to the Wordfence threat intelligence record, the staged installer in that directory answers requests without authentication, and the upgrade window lasts seconds. Seconds were enough. Wordfence telemetry recorded more than 18,500 probes in the first 21 hours after disclosure, and more than 240,000 blocked attempts by 5 November. The NVD record for CVE-2026β119977 files the case under CWE-367; the fix shipped in WordPress 7.1.4.
The class here is 1, but with a twist the other races do not have: the vulnerable window is opened by the act of patching itself. The state that outlives its check is a whole transitional installation, and the assumption that failed is that transitional states are somehow outside the attack surface. Attackers clearly did not share that assumption; the probe volume is the measurement of how quickly a seconds-wide window gets found when it is predictable. Transience is not a security property. Reachability is.
6. Firecracker CVE-2026β122192: restored state is inherited state
The state object. Memory accounting inside the virtual machine monitor, carried across a snapshot restore.
The boundary crossed. The snapshot boundary. A guest is restored, and the VMM continues to trust bookkeeping that describes memory from before the restore.
Where the check sat. The restore path accepted the inherited state as a starting condition rather than re-deriving it, so every subsequent decision inherited the error.
Coinspect's research, published on 4 November 2026, built an escape from Firecracker, the microVM monitor, out of a chain whose skeleton is instructive even in outline: snapshot restore, balloon discard, a MAP_FIXED remap, a stale KVM memory slot mapping, VMM-controlled memory, and finally code execution. No single step is the escape. Each step is only possible because it stands on state the previous step left behind, and the first step is the restore, the moment where state crosses from a saved artifact into a live monitor.
This is class 4 again, in its purest form. A snapshot is state that was checked, implicitly, in a previous life of the machine. Restoring it does not re-run those checks; it inherits their conclusions. When the balloon device discards pages and the memory slot mappings no longer describe what the VMM believes they describe, the monitor is reasoning about a machine that no longer exists, using numbers that were correct for the machine that was snapshotted. The lesson generalises well beyond virtualisation: any mechanism that saves and restores state, snapshots, sessions, caches, staged copies, is a place where yesterday's verified state becomes today's unverified assumption.
7. Apache mod_http2 CVE-2026β119618: shared state with no owner
The state object. A header table in mod_http2, fed from the connection's lock-free shared allocator.
The boundary crossed. The boundary between threads. The worker thread and the connection thread reach the same memory with different assumptions about who else is writing.
Where the check sat. There was no synchronisation decision to audit, because the design premise was that the allocator's lock-free sharing made one unnecessary. The assumption lived in the architecture, not in any single line.
Analyses by Praetorian and Sythe Labs of CVE-2026β119618 (CWE-362 in the NVD record, fixed in Apache HTTP Server 2.4.71) describe how assign_headers() writes into a header table backed by that shared allocator while another thread can be mutating the same structures. One correction first, because honesty about this case matters more than the case itself: the exploitation status is disputed in the public record. Red Hat has referred to credible exploitation research while Wiz stated, as of 11 November, that it was not aware of exploitation. This article takes no side in that dispute, and the case is not used here as an exploitation claim. It is used for what is not disputed: the state-ownership failure.
That failure is class 5. In the other five cases, state outlived a check. Here, state never had a single owner to begin with, so there was no moment at which a check could have certified it. Concurrency bugs are often taught as a separate discipline from lifecycle bugs, but from the state side they are the same question asked twice: who is allowed to change this, and at what moment did the reader's copy of the truth expire? In mod_http2 the answer to the first question was "more than one thread" and to the second, "immediately". A design that cannot answer the ownership question cannot answer the lifetime question either.
8. Synthesis: the questions that find this class
Six chains, five classes, one recurring sentence: the component remembered something for longer than the check that vouched for it stayed valid. A PHP worker remembered a previous request. A decoder remembered a larger window. A sandbox remembered a path as it was before the symlink moved. An installer existed in a state its own security model did not cover. A monitor reasoned from memory numbers inherited across a restore. A header table belonged to everyone and therefore to no one.
For a reader who hunts or audits, the pattern compresses into four questions that can be asked of any component:
- What does this component remember, and across which boundary does the memory travel: a request, a volume, a snapshot, a directory change, a thread?
- Where does the check sit relative to the change: before it, after it, or (the dangerous answer) in a different lifecycle entirely?
- Can anything act in the gap between the check and the use, including the component's own error paths?
- Who resets the state, and which failure path skips that reset?
The fourth question deserves emphasis, because it is the one the PHP case teaches best. Cleanup code is security code. Every bailout, exception, early return, and partial construction is a place where state can be left standing after the logic that understood it has exited.
The claim also has a boundary, and it should be stated as plainly as the claim itself. The same corpus contains chains this pattern does not explain. The Rails Active Storage case turns on a coder being selected by content type, a dispatch decision, not a lifetime failure. The Confection case is a missing authorisation check on a settings record; the check was not outlived, it was absent. The MLflow case grows out of a default unauthenticated configuration becoming an SSRF surface, a configuration problem rather than stale state. State-lifetime mismatch is not a universal law of vulnerabilities and this article does not argue otherwise. It is a recurring class that the official taxonomy fragments across at least four categories, and a class that stays invisible as long as each of its members is filed, and read, separately.
9. Closing
The instinctive audit question is whether a check exists. These six chains suggest a better one. Checks exist in most mature code, and they mostly work, at the moment they run. What decides the outcome is everything that happens to the state afterwards: who can move it, who inherits it, who forgets to clear it, and which boundary it quietly crosses while everyone is looking at the check.
Do not ask whether the check exists. Ask how long the state it checked stays true.
References
PHP2Shell (CVE-2026β109618, CVE-2026β109619)
- CyStack, PHP2Shell vulnerability research: https://cystack.net/research/php2shell-vulnerability
- a2coder, PHP2Shell write-up: https://www.a2coder.dev/blog/php2shell
Claude Code (CVE-2026β88968)
- GitHub Advisory GHSA-5xjx-9qx6-jcrv: https://github.com/advisories/GHSA-5xjx-9qx6-jcrv
- Wiz vulnerability database, CVE-2026β88968: https://www.wiz.io/vulnerability-database/cve/cve-2026β88968
- Sessionboxer, Claude Code Edit tool symlink race: https://sessionboxer.talayolabs.com/blog/claude-code-edit-tool-symlink-race/
WordPress (CVE-2026β119977)
- Wordfence threat intelligence record: https://www.wordfence.com/threat-intel/vulnerabilities/wordpress-core/wordpress-core-470β713-unauthenticated-upgrade-window-staged-installer-remote-code-execution
- NVD, CVE-2026β119977: https://nvd.nist.gov/vuln/detail/CVE-2026β119977
- WordPress 7.1.4 release announcement: https://wordpress.org/news/2026/10/wordpress-7β1β4
7-Zip (CVE-2026β125742)
- VulnCheck advisory, 7-Zip LZX decoder heap out-of-bounds write in CAB extraction: https://www.vulncheck.com/advisories/7-zip-before-26.06-heap-out-of-bounds-write-via-lzx-decoder-in-cab-extraction
- 7-Zip fix commit: https://github.com/ip7z/7zip/commit/d3296e39e1f1f92c7b41c0c3848e65640428d42d
- LzxDecoder.cpp, version 26.05, lines 1496β1513: https://github.com/ip7z/7zip/blob/26.05/CPP/7zip/Compress/LzxDecoder.cpp#L1496-L1513
Firecracker (CVE-2026β122192)
- Coinspect, Firecracker escape research: https://coinspect.com/blog/firecracker-escape
Apache HTTP Server mod_http2 (CVE-2026β119618)
- Praetorian, CVE-2026β119618 analysis: https://www.praetorian.com/blog/cve-2026β119618/
- Sythe Labs, CVE-2026β119618 Apache http2 analysis: https://sythelabs.com/blog/cve-2026β119618-apache-http2
- NVD, CVE-2026β119618: https://nvd.nist.gov/vuln/detail/CVE-2026β119618