On the morning of Tuesday, November 17, 2026, employees arriving at the National Security Agency’s Fort Meade headquarters found that the network they use for nearly everything would not reliably let them in. That network carries classified email, intelligence sharing and report filing. By evening, an employee voicemail line had gone from “code yellow” (staggered arrivals) to “code green” (report as scheduled) and then abruptly to “code orange”: the campus was closed to most personnel until further notice. Nobody explained the reversal publicly.
What followed was close to four days of disruption. Staff were told to come in and then sent home without ever logging in, more than once. Restoration only held after employees were metered back onto the network in shifts, building by building, so that tens of thousands of simultaneous logins would not knock it over again. On Friday, November 20, the voicemail greeting changed to a line that belongs in any anthology of understated incident communication: “NSA Washington is operating under normal conditions with exceptions.”
The cause, according to the Director of National Intelligence, was not a foreign adversary. It was a software patch. “The patching that has gone on following that has caused some of these systems to not come back up when you patch them as expected,” Jay Clayton, sworn in as the ninth DNI in August 2026, told Fox Business on the day the outage began. “That is what has happened at the NSA today.”
The patches addressed PHP2Shell, tracked as CVE-2026-109618 and CVE-2026-109619, a pair of critical PHP engine flaws that the NSA itself had told the world to fix on October 21. Its advisory said to patch immediately or take vulnerable systems offline. Less than a month later, the agency’s classified network, NSANet, became the most prominent cautionary tale of that advice.
I think this is a correct decision executed inside a system too complex to absorb it cleanly. The vulnerabilities were real, severe and exploited before disclosure, and the patches were necessary. Yet applying them, and in particular restarting systems afterward, appears to have broken the daily work of the most sophisticated signals intelligence organization on earth. To see how that happens, you need to know what PHP2Shell did to the PHP engine and what fixing it did to everything built on top.
What happened during the four-day NSANet outage
The public record comes mainly from CNN, which first reported the outage citing six sources, with corroborating accounts from CBS News, The Record and others. NSANet is the agency’s classified internal network and works essentially as its classified email and information-sharing system. One person familiar with the situation told The Record that the system was never fully shut down but delivered intermittent service, and that it had been unstable for weeks, to the growing frustration of employees. The disruption began early on November 17 and ran far longer than officials expected. On Thursday, a senior administration official acknowledged that the patches needed to restore the system were taking longer than planned.
The NSA’s official statement was carefully worded and much narrower than Clayton’s on-camera account. The agency said it had “experienced temporary degradation during scheduled routine maintenance,” that “mission-critical capabilities remain fully operational,” and that its infrastructure “is designed with multiple layers of redundancy to maintain operations during planned maintenance or unexpected events.” It did not name PHP or a patch, and it did not confirm Clayton’s causal account.
Multiple current US officials briefed on the incident told CNN it was not a cyberattack and appeared tied to the agency’s handling of the PHP updates. Asked about the wider run of failures that week, Secretary of State Marco Rubio was emphatic: “we have zero evidence whatsoever, we have no indication, no evidence, and no reason to believe at all that any of these incidents are related to each other.”
What kept working at the NSA
Officials told CNN that the agency’s most sensitive intelligence-gathering systems ran throughout, with backup networks and workarounds keeping critical intelligence moving. That included urgent intelligence to President Trump while he traveled in Asia and intelligence sharing with the Five Eyes partners. The Record reported that NSA backup centers around the country were expected to pick up the signals-intelligence mission.
A former senior NSA official described NSANet to CNN as a “network of networks” and said a complete outage was unlikely given the redundancy available. What a disruption could hit, the official said, was analysis and reporting. That is what happened. Collection survived and knowledge work stopped, because analysts who could not log in could not produce, and the agency kept most of them home.
📬 Stay Ahead of Cyber Threats
Get the latest cybersecurity news, critical vulnerabilities, threat intelligence, tutorials, and exclusive giveaways delivered straight to your inbox. No spam. Unsubscribe anytime.
Why recovery needed staggered logins
Staff were told to return in staggered arrivals specifically to avoid too many simultaneous logons, and on several occasions those returns ended with people sent home without ever getting in. When the network came back on Friday, the staggering continued: personnel were ordered to follow designated building opening times, with most staff expected back by midday.
Anyone who has run a large VDI estate or a classified enclave knows this shape. A system restored into a reduced capacity envelope treats the login storm of a normal morning as a denial-of-service event. The agency has been here before. In 2000, a technical failure knocked out NSA computers for nearly three days and interrupted intelligence processing at Fort Meade, and The Record notes that recovery took thousands of man-hours and roughly $1.5 million. Twenty-six years later the failure mode rhymed, even though the trigger changed.
The history of PHP2Shell: a PHP bug with a twenty-year paper trail
These vulnerabilities did not appear in October. Calif and the PHP Foundation have documented their history in unusual detail, and it shows how known weaknesses survive in plain sight.
2004 to 2024: a known weakness left in place
In 2004, the PHP security researcher Stefan Esser found the first remote memory-limit vulnerability in PHP. He considered it serious enough that he never released his exploit, though two commercial vendors, CORE and Immunity, built private ones. In 2020, bug report #78876 noted that long variables in multipart form data could cause an out-of-memory condition and leave temporary files uncleaned. It was treated as a housekeeping issue.
In 2024, PHP went through its first external security audit in years, funded by Germany’s Sovereign Tech Agency, organized through OSTIF and carried out by Quarkslab. While fixing one of Quarkslab’s findings, a PHP core developer contracted by the Foundation saw the first signs of the OOM problem that would become CVE-2026-109618. An exploit was theorized, no concrete vector turned up, and the issue slid behind bugs with clearer impact.
The Foundation’s post-mortem is blunt about what came next. The security team developed several competing fixes, and each carried unacceptable costs: backward-compatibility breaks, new denial-of-service potential, or changes across a vast ecosystem of third-party extensions that seemed impossible to coordinate. Working by consensus, the team “struggled to choose between these and feared the repercussions of shipping the wrong choice,” and the work stalled and restarted for months. “We won’t pretend otherwise,” the Foundation wrote, “the delay was a structural failure, caused by both the security team’s decision process and its lack of resources.”
That sentence explains most of what followed. The properties that made the bug hard to fix, its place in the engine’s memory management and error handling where nearly every request passes, are the same ones that made the fix dangerous to deploy.
2026: AI-assisted research connects the chain
What changed in 2026 was the tooling aimed at the code. OpenAI’s Patch the Planet program brought the security firm Calif to PHP, and the audit began July 30. On August 1, researcher Ryan Austin, working with OpenAI’s GPT-5.6 Sol model and guided by his memory of Esser’s twenty-two-year-old finding, surfaced the first controllable OOM-fatal and the first of three interruption points that would chain into remote code execution. Calif reported the first bug to PHP on August 11 and shared a working RCE proof-of-concept on August 14. PHP confirmed it the next day.
Wiz Research found its first PHP vulnerability independently on August 19, using its Atlas platform together with Gemini 4 Argon and GPT-5.6 Sol. Within two days it had confirmed unauthenticated RCE against Drupal and WordPress, and it reported to PHP on August 24. OpenAI reported the same root cause on its own and added further attack vectors in September. From August 11 on, the Foundation said, fixing the bug became the top priority of every person it funded on security, with people working weekends and around the clock.
The disclosure that went sideways
On October 20, the two CVE identifiers leaked on Hacker News and social media with a wrong release time and a wrong CVSS score of 10.0. The PHP team’s actual CVSS v4.0 score is 9.2. PHP moved the release forward a day, to October 21 at 14:00 UTC. Calif mistakenly published a PoC video that kept circulating after deletion. At 07:41 UTC on October 21, more than six hours before the coordinated release, Chainguard broke the embargo and published built images containing the fix, which let anyone diff the patched binaries while the rest of the world’s PHP users still waited.
The PHP security team said it inspected the PoCs circulating after the leak and “did not identify any functional exploits at the time of release/public disclosure.” Amazon’s threat intelligence team, however, had already logged a PHP2Shell exploitation attempt against its MadPot honeypot network on October 17, four days before public disclosure. Where that attacker got the exploit knowledge remains unexplained.
How PHP2Shell turns a failed request into a shell
The technical core fits in one sentence. PHP can leave dangling pointers and partially initialized state behind when a fatal error interrupts native code before its normal cleanup finishes, and a later request in the same worker can consume that state as if it were valid. The memory disclosure, the cross-worker type confusion and the pre-authentication RCE against WordPress and Drupal all follow from where exactly the interruption lands. I am keeping this section at root-cause level on purpose.
Forcing the fatal error
PHP enforces a per-request memory_limit, 128 MiB by default. Exceeding it is a fatal error that aborts the request through zend_bailout(), a longjmp-based unwind that skips whatever cleanup the interrupted C code had not yet done. To use that, an attacker needs to hit the limit at a chosen moment, and Calif found two reliable ways to get there.
The first is that post_max_size is checked against the declared Content-Length rather than the bytes actually consumed. A chunked HTTP/1.1 request or a lengthless HTTP/2 multipart body can therefore pass the 8 MiB default POST cap. The second is more elegant: empty RFC1867 file-upload parts carry no file data and do not count toward max_file_uploads, yet PHP still builds full $_FILES structures for them. Small requests can burn through the default heap while the HTTP body stays far under the cap. Either way the attacker decides which later allocation fatals.
Where the interruption lands
The first interruption point is in _zend_hash_str_add_or_update_i, the function that inserts string keys into PHP’s ubiquitous HashTable. It increments the element counts before allocating the bucket’s key, and that allocation, zend_string_init(), can itself bail out. The count is already published, so teardown walks a bucket whose key, hash and value were never initialized and treats stale heap bytes as live data. This path is reachable during php_request_startup(), while PHP parses POST variables, before any application code runs.
Whether it is exploitable depends on a divergence between SAPIs. After a startup failure, Apache’s mod_php still calls php_request_shutdown() and destroys the malformed $_POST and $_FILES tables. PHP-FPM takes a process-exit branch and discards the evidence along with the worker. That makes this variant an RCE against arbitrary scripts on mod_php, PHP 7.3 and later.
The second interruption point reaches back to PHP 5.4.0 and produces the Heartbleed-style leak. PHP’s session upload-progress feature can initialize session state while the multipart body is still being parsed, before module activation completes. The first file part stores request-owned pointers, including the session ID and the session variables, in the session extension’s globals. If parsing then hits a fatal, the cleanup callback never runs, and request shutdown skips the session module’s own shutdown hook because the activation flag is still false. It frees the request heap anyway. The Apache worker survives with session globals pointing into freed memory.
A follow-up request can then read that dangling session ID as if it were live and reflect reclaimed heap contents back in a response cookie. That is unauthenticated disclosure of worker memory, including passwords, tokens, API keys and TLS private keys from other requests, and it works even against applications that never call session_start(). The same stale state, consumed as a value to be destroyed, gives a use-after-free write path to code execution.
PHP-FPM exits on startup failure, so Calif found a post-startup variant. PHP’s generic unserializer publishes its reference and destructor bookkeeping into global state, and a fatal during decoding skips the cleanup that resets it. This can happen inside session_start() processing an attacker-groomed session record, or inside WordPress’s maybe_unserialize(). Because startup had already succeeded, the FPM worker survives and takes another request, and the stale nesting state makes the decoder treat attacker-reclaimed memory as its live bookkeeping. The decisive flaw is that a signed slot counter is assumed to be non-negative. After reclamation it can go negative and point outside the intended array, which turns PHP’s own bookkeeping into a controlled write primitive. It works under both mod_php and FPM.
Wiz’s two additional paths under CVE-2026-109619
Wiz’s contribution, grouped under CVE-2026-109619, extends the pattern to two more pieces of shared state. First, PHP retains the last fatal error’s backtrace in an executor global. An OOM fatal can free the request heap without clearing that pointer, and a diagnostic emitted early in the next request dereferences the dangling backtrace before the executor reinitializes it. Wiz developed that cross-request use-after-free into pre-auth RCE on Drupal.
Second, OPcache keeps compiled scripts in shared memory across workers. During script persistence it advances a process-local pointer-map frontier but publishes the shared frontier only once persistence completes. An allocation failure between those two events leaves partially persisted objects referencing slots the shared state still considers free. Another worker reuses a slot for a different object, and stale metadata resolves to a pointer of the wrong type. That cross-worker type confusion in shared memory became pre-auth RCE on WordPress.
How exploitable is PHP2Shell in practice?
Two calibration points matter. The CVSS v4.0 vector the PHP team assigned, 9.2 with AC:H/AT:P, encodes high attack complexity and specific preconditions. Sansec’s forensics team stressed that exploitation needs target-specific knowledge and conditions, which makes indiscriminate mass exploitation harder than the first panic suggested.
Hard is not safe, though. Calif confirmed pre-auth RCE against WordPress, Drupal, Joomla, MediaWiki, Roundcube, Magento, phpMyAdmin, Nextcloud, Laravel, Symfony and WHMCS. Trail of Bits confirmed working exploits across PHP 8.2 through 8.5 by October 26. Wiz’s broader argument is that frontier models collapsed the effort curve: a single researcher finished in a week what would previously have taken a world-class team months. The bugs were always there, and AI changed what was practical.
Why applying the PHP2Shell patch was the dangerous part
The PHP Foundation described the remediation problem with a precision that reads, in hindsight, like a warning label for NSANet. Both issues sit in memory management and error handling, “parts of PHP that nearly every request touches,” and that centrality is what made them “so hard to fix without breaking compatibility, hurting performance, or forcing changes on the large ecosystem of third-party extensions.” This was no bounds check added to one function. The fix reworks engine behavior at allocation-failure and request-teardown boundaries, the seams where long-lived workers, embedded SAPIs and compiled extensions hold assumptions about what survives a request.
Installing the package does not patch the running PHP
The operational mechanics add to the risk. Installing an updated PHP package does not patch the PHP that is serving traffic. Google Cloud’s guidance, which incorporates Mandiant input, spells it out: PHP-FPM, Apache with mod_php and other services keep the vulnerable code mapped in memory until they restart. The vulnerable engine lives in the worker processes, and the fix takes effect only when those processes are replaced.
So the moment of maximum risk in a PHP2Shell remediation is the fleet-wide restart, not the package install. Services come back under a changed engine, with extensions loaded against new behavior, shared-memory caches rebuilt and dependent applications exercising code paths the patch altered. Clayton’s description of the failure, systems that “did not come back up when you patch them as expected,” points at exactly that phase.
I want to be precise here. No public forensic account says which component failed on NSANet, whether PHP itself, an extension, the web server layer or the deployment machinery, and the NSA’s own statement never confirmed the PHP link. The causal chain rests on Clayton’s account and the officials who corroborated it to CNN and CBS.
A documented regression in the same PHP releases
What is documented is that these releases carried real deployment risk. PHP developers confirmed a regression in 8.4.27 and 8.5.12 that could crash PHP processes in applications using the SimpleXML extension. It is tracked as php-src issue #24488 and traces to a separate garbage-collector fix bundled into the same releases, not to the security patches. Nothing public connects that regression to the NSA outage, and implying otherwise would be reckless. It does show how a correct, well-coordinated security release can ship behavior changes that break workloads, and a classified environment with limited testing options and heterogeneous legacy applications is where that breakage is hardest to catch in advance.
Interim mitigations had costs too
PHP’s advisory listed memory_limit=-1, set so applications cannot override it, against the OOM corruption path. That removes the trigger by removing the guardrail, which swaps a code-execution risk for a host memory-exhaustion risk, with container or cgroup limits suggested as an availability boundary. Against the stale-state path it listed session.upload_progress.enabled=0 and, on PHP 8.5, fatal_error_backtraces=0. Each changes behavior that applications may depend on, and each needs a restart of every PHP worker to take effect. The PHP team was explicit that updating was the only complete fix.
The CISA KEV deadline and in-the-wild exploitation
The clock was running. CISA added both CVEs to the Known Exploited Vulnerabilities catalog on October 26, with a remediation due date of October 29 for federal civilian agencies, three days out, under guidance that now includes forensic triage requirements. Amazon reported broad exploitation attempts in the wild.
Dream Research documented a campaign that chained a custom PHP2Shell exploit with the Fragnesia Linux kernel privilege-escalation flaw (CVE-2026-46300) to root 24 internet-facing firewalls. Unit 42’s later update identified them as Palo Alto Networks PAN-OS management interfaces, and some appeared to belong to a US government-affiliated environment. For an agency whose own advisory demanded immediate patching across US government departments, waiting was not a serious option. Patching was the right call, and the environment was unforgiving.
Why a classified network runs PHP
The reflexive question, why is the NSA running PHP at all, rests on a misunderstanding of what classified networks contain. NSANet is not a bespoke stack of exotic protocols. It hosts the internal portals, administrative interfaces and line-of-business applications any large enterprise runs, and those sit on the same open-source foundations as the public web. Isolation from the internet changes who can reach a vulnerability. It does not change whether the vulnerability exists or has to be fixed.
CISA’s alert made the inventory problem explicit: PHP is often a component of other software, and its presence “may not be directly observable.” The NVD’s affected-product lists for PHP2Shell read like a tour of infrastructure that has nothing to do with websites, including PAN-OS and Panorama management appliances, Siemens industrial products and hosting control panels. The Dream campaign against firewall management interfaces shows that “we only use PHP internally” was never a defense. An air-gapped network full of embedded PHP is still full of PHP2Shell, and the NSA’s October 21 guidance to patch, or take the system offline until it is fully mitigated, applied to its own estate as much as anyone’s.
Who chose to go offline instead
Much of the world took the second branch of that directive. Following guidance from CERT-EU and national cyber centers, the Dutch government portal Overheid.nl went dark, as did all Finnish government public-facing web services, the French Interior Ministry’s websites, the Danish national school communication platform and some Canadian government sites. The Wikimedia Foundation shut down supporting services including its Phabricator instance, the Internet Archive briefly went offline to patch, and Capcom delisted Street Fighter V and turned off its servers.
Taking systems down was painful, bounded and reversible. Patching in place at enterprise scale, under a three-day federal deadline, with AI-assisted exploits in circulation, was the branch with open-ended failure modes. The NSA took that branch, and it paid for it.
A bad week for American infrastructure: Microsoft, FAA, JPMorgan, United and Apple
The NSANet outage landed in the middle of a six-day stretch of American technical failure, and the timing did more than anything else to feed public anxiety about a coordinated attack that officials repeatedly said did not exist.
Starting Thursday, November 12, a roughly day-long global Microsoft 365 outage disrupted Outlook, Exchange Online and parts of Teams. A senior company official said on Monday that a months-old bug was responsible, and reporting pointed to a latent defect in Microsoft’s networking gateway infrastructure introduced by a July change. Microsoft said it found no indication of malicious activity.
On Friday, November 13, the FAA halted all US departures for more than four hours, the longest nationwide stoppage in 25 years according to the AP. A newly installed router in El Dorado, Arkansas, flooded air-traffic systems with data during routine telecommunications maintenance and overwhelmed older equipment. The FAA then paused new router installations and switched off the Juniper routers already in place. Juniper told the Wall Street Journal its device appeared to work as intended, and the root cause remained under investigation, with the FBI assisting alongside the contractor L3Harris.
On Monday, November 16, a software bug in an on-premises JPMorgan Chase system delayed transaction processing for thousands of customers. The same day, a United Airlines software failure hit crew-facing applications such as pilot flight-planning and weight-and-balance tools and crew communications, and delayed departures. On Tuesday, while NSA staff were being sent home, Apple acknowledged sign-in problems affecting iCloud, the App Store, Apple Music and Apple Pay, without disclosing a cause.
These incidents do not share a root cause, and Rubio was right that no evidence links them. They share a context. Senator Mark Warner, vice-chair of the Senate Intelligence Committee, pointed to the rush to patch AI-discovered flaws on older systems as a growing hazard. Clayton, describing PHP as a “legacy vulnerability,” said the pace of identification and patching “goes on all the time” now.
The structural story is that AI has compressed the gap between a flaw becoming known and its exploitation becoming practical. Remediation (testing, staging, change windows, restart orchestration) still runs at human speed on infrastructure that, as one US intelligence official told CBS, was designed for an earlier internet era. Discovery sped up and deployment did not. By November 19, CNN reported, the White House was replacing its national cyber director amid the outages.
The vulnerability wave has not crested
The PHP Foundation disclosed that its security team has published 15 CVEs since July 1 and processed more than 100 reports that proved invalid, duplicated or unreproducible, the exhaust of an AI-assisted research ecosystem pointed at a codebase maintained, as The Guardian noted, by a foundation with roughly thirteen full- and part-time staff. The AI labs on the other side are capitalized in the billions. By November 18, Tenable was tracking a five-flaw critical nginx bundle called NGINX2Root.
Wiz framed PHP2Shell as an inflection point, the moment complexity stopped being a meaningful barrier to exploitation, and that framing looks less like marketing with each new disclosure. The same models that helped Austin and Wiz build exploits in days are helping defenders find variants, and the Foundation is now using Anthropic’s Claude Mythos and OpenAI’s Daybreak Red for scanning and validation. Every validated finding still becomes somebody’s emergency change window, and the NSA’s four days show what happens when those windows meet a system that cannot be tested the way the public cloud can.
What the record supports and what it does not
Here is what is established. NSANet suffered a disruption of nearly four days beginning November 17. The DNI publicly attributed it to patching for the PHP vulnerabilities, and multiple officials ruled out a cyberattack. Mission-critical collection, presidential intelligence delivery and Five Eyes sharing continued. The NSA’s own statement described only “temporary degradation during scheduled routine maintenance” and never confirmed the PHP connection. Restoration required staggered logins because the recovered system could not absorb normal load.
What is not established is the failure chain. Whether the breakage sat in the PHP engine, an extension compiled against older behavior, the web server integration or the orchestration that rolled the updates across NSANet’s constituent networks is unknown outside the classified environment, and may stay that way. The SimpleXML regression proves these releases could break things. It does not prove they broke this one. Any account more specific than that is speculation.
Lessons for patching PHP2Shell without causing your own outage
Patch management is a risk transaction with a failure distribution of its own, and for fixes that touch a runtime’s core semantics that distribution has fat tails. The organizations that got through PHP2Shell without self-inflicted outages treated the restart as the critical event, not the package install. They used staged rollouts, canary workers under real traffic, verified rollback paths and post-restart health checks that exercise the application rather than just the port.
The staggered-return saga adds a second lesson about recovery capacity. A restored system is not recovered until it can survive its own users, so login-storm headroom belongs in the recovery plan and not in improvisation on the day.
Third, the “patch or disconnect” directive was a genuine fork. Much of the world chose to disconnect and paid a bounded, reversible cost. The agency that patched in place, under deadline, across a heterogeneous classified estate, paid an unbounded one, and given the KEV clock and the exploitation telemetry, it is not obvious that a different choice was open to it. This was not incompetence. A correct decision met an environment where correctness is not enough.
There is a quieter lesson in the PHP Foundation’s admission that the fix stalled for two years because a consensus process could not choose between compatibility-breaking options, and in its plea for funding from the companies and governments that run on PHP. Models can now surface twenty-year-old bugs in a week. Deciding how to change a longstanding design decision in the engine, weighing the compatibility trade-offs and reviewing the patch still takes experienced engineers who know the whole codebase, and there are too few of them, funded too thinly, upstream of everyone. The NSA employs some of the best security engineers in the world and still lost four days. Teams with smaller staffs and looser redundancy are running the same engine.







