A pre-authentication RCE that has been hiding in NGINX’s HTTP/2 stack for a decade got its emergency patch today - with public exploit code already circulating. Separately, Optimizely’s trusted A/B testing platform was turned into a malware delivery mechanism against 178 major websites, and a Russian threat actor demonstrated that one cloud breach is enough to chain into the next organization.
In the News
NGINX HTTP/2 Flaw Enables Pre-Auth RCE After 10 Years
CVE-2026-123007 is a memory corruption vulnerability in NGINX’s HTTP/2 implementation that has been present in every version since 1.9.5, released in September 2015. The flaw allows an unauthenticated attacker to send crafted HTTP/2 frames that trigger a buffer overflow in the connection handling code, leading to arbitrary code execution with the privileges of the NGINX worker process.
F5 shipped emergency patches in NGINX versions 1.31.9 and 1.30.7 on November 19. Proof-of-concept exploits are public. The pre-authentication nature of this flaw - no credentials, no session, no prior access required - makes it immediately exploitable at scale against any Internet-facing NGINX instance with HTTP/2 enabled.
The blast radius is significant. NGINX serves as a reverse proxy, load balancer, and API gateway across millions of deployments worldwide. Organizations that cannot patch immediately should disable HTTP/2 at the listener level as an interim mitigation. IPS and WAF vendors are expected to ship detection signatures within hours; monitor your vendor’s advisory feeds.
What defenders should do: Inventory all NGINX instances, check HTTP/2 status, and patch to 1.31.9 or 1.30.7. If patching is delayed, disable HTTP/2 on affected listeners. Deploy IPS signatures as they become available.
Optimizely Supply-Chain Attack Hits 178 Sites
Attackers compromised Optimizely’s A/B testing platform and used it to deliver card skimmers, credential stealers, and iOS browser exploits to visitors of 178 high-profile websites including CNN, BBC, Zoom, and Salesforce. The irony of using an A/B testing platform to A/B test malware was not lost on researchers - the malicious JavaScript was rebuilt 26 times in a single 24-hour period, suggesting the attackers were iterating on evasion and payload effectiveness in real time.
This attack demonstrates a structural problem with third-party script loading. Every one of the 178 affected sites included Optimizely’s JavaScript as a trusted resource. Most did not enforce Content Security Policy headers strict enough to prevent the modified script from loading additional resources or exfiltrating data. Subresource Integrity (SRI) hashing - which would have detected the modified script - was not in use on the affected sites.
The supply-chain vector here is not novel in concept, but the scale and sophistication of execution are notable. When a single third-party platform serves JavaScript to hundreds of major websites, compromising that platform provides a force multiplier that individual site compromises cannot match. This maps to MITRE ATT&CK T1195.002 (Supply Chain Compromise: Compromise Software Supply Chain).
What defenders should do: Audit third-party scripts on production sites. Enforce strict CSP headers with script-src allowlists. Implement SRI hashing for all externally loaded JavaScript. Monitor for anomalous outbound connections from client-side scripts.
Cold Relic Chains Google Workspace Breach to Hit Second U.S. Organization
Google Mandiant confirmed that Russian threat actor Cold Relic used data stolen from one U.S. organization’s Google Workspace environment to impersonate employees and compromise a second U.S. organization. The chain is straightforward: breach tenant A, harvest employee identities and internal communications, then use that information to social-engineer access into tenant B - an organization that trusted tenant A’s employees.
No zero-day was required for the second compromise. Cold Relic relied on valid credentials, social engineering, and the implicit trust between business partners. This maps to MITRE ATT&CK T1199 (Trusted Relationship) and reinforces that cloud identity compromise creates blast radius far beyond the initial victim.
What defenders should do: Enforce phishing-resistant MFA (FIDO2) across all cloud tenants. Monitor for anomalous OAuth token grants, especially cross-tenant. Establish cross-tenant access policies that limit what external identities can reach. Review trusted partner access periodically.
Today’s Deep Dive - Third-Party Supply-Chain Compromise
The Optimizely incident is the latest in an accelerating trend of supply-chain attacks targeting trusted third-party services rather than individual organizations. The economics are compelling for attackers: compromise one platform, reach hundreds of downstream targets.
The defensive challenge is that organizations willingly load third-party JavaScript into their production pages. Content Security Policy is the primary browser-native control, but CSP adoption remains inconsistent even among large enterprises. When CSP is deployed, it is frequently configured in report-only mode or with overly permissive directives that negate its protective value.
The Optimizely attackers rebuilt their payload 26 times in 24 hours. Static signature-based detection cannot keep pace with that iteration speed. Organizations need runtime visibility into what third-party scripts actually execute in users’ browsers - not just what scripts are loaded, but what DOM elements they access, what data they exfiltrate, and what external domains they contact. This is an emerging category (client-side protection / page integrity monitoring) that most organizations have not yet deployed.
The parallel to the Microsoft Agent Framework PyPI poisoning is worth noting. In that incident, attackers compromised an official package for just 33 minutes - long enough to push credential-stealing code to developers pulling the latest version. Whether the supply chain is a JavaScript CDN or a package repository, the attack pattern is the same: trusted distribution channel becomes a malware delivery mechanism.
Detection focus: monitor for unexpected script sources in CSP violation reports, anomalous outbound data transfers from client-side code, and sudden changes in third-party script hashes (MITRE ATT&CK T1195.002).
Defender Action Items
- NGINX: Patch all instances to 1.31.9 or 1.30.7. Disable HTTP/2 on any instance that cannot be patched within 24 hours. Deploy IPS signatures for CVE-2026-123007 exploitation attempts
- Third-party scripts: Audit all externally loaded JavaScript on production sites. Implement SRI hashing and enforce strict CSP script-src directives. Evaluate client-side protection tooling for runtime script behavior monitoring
- Cloud identity: Enforce FIDO2 phishing-resistant MFA on all cloud tenants. Monitor cross-tenant OAuth grants. Review and restrict trusted partner access scopes
- Puppet Enterprise: Patch immediately per CISA KEV. Audit managed nodes for unauthorized configuration changes or unexpected binaries
- PHP: Apply CVE-2026-115560 patches as soon as they release on November 19. Deploy WAF rules targeting session upload progress abuse
Detection Queries
NGINX HTTP/2 exploitation attempts frequently involve malformed HEADERS and CONTINUATION frames. The following Suricata rule detects anomalous HTTP/2 frame sequences targeting the CVE-2026-123007 buffer overflow condition:
alert tcp any any -> $HOME_NET 443 (msg:"NGINX HTTP/2 CVE-2026-123007 Exploitation Attempt - Malformed CONTINUATION Frame"; flow:established,to_server; content:"|50 52 49 20 2a 20 48 54 54 50 2f 32|"; depth:14; content:"|00 09|"; distance:0; within:2; byte_test:3,>,16384,0,relative; threshold:type both, track by_src, count 5, seconds 10; classtype:attempted-admin; sid:2026119001; rev:1;)
This rule watches for HTTP/2 connection preface followed by oversized CONTINUATION frames - the specific pattern described in the public PoC. Tune the byte_test threshold based on your environment’s legitimate HTTP/2 traffic patterns. False positive rate is low for Internet-facing deployments but may trigger on legitimate HTTP/2 implementations that send large header blocks.
For CSP violation monitoring related to supply-chain script injection, this Splunk SPL query surfaces unexpected script sources:
index=webserver sourcetype=csp_reports
| spath input=_raw path=csp-report.violated-directive output=directive
| where directive="script-src"
| spath input=_raw path=csp-report.blocked-uri output=blocked_uri
| stats count by blocked_uri
| sort -count
| where count > 10
References
- 10-Year-Old NGINX HTTP/2 Flaw Lets Attackers Execute Code - The Hacker News / F5
- Attackers Used Optimizely to A/B Test Malware on Top Websites - Krebs on Security
- Russian Cold Relic Hackers Use Stolen Workspace Data - The Hacker News / Google Mandiant
- Hackers Exploiting Critical Puppet RCE Flaw - The Hacker News / CISA KEV
- PHP Readies Critical Security Updates - SecurityWeek
- UAT-12643 Blends Blockchain Resilience with Targeted Infostealing - Cisco Talos
- Microsoft Agent Framework PyPI Package Compromised - BleepingComputer
- CISA Warns of 4 Exploited Flaws - The Hacker News
Related Briefs
- AI Agents Steal Keys to Find More Keys - NHI Sprawl
- Java4Shell CVE-2026-114938 - Pre-Auth RCE Hits Jira
- Optimizely Supply-Chain Attack Hits 178 Orgs
- AI Agents Run Recursive Key-Theft Loops
- FBI Warns ARTEX AI Powers MSP Supply-Chain Hits
Subscribe to it-learn Brief
Get it-learn Brief in your inbox (Mon–Fri) - Daily cybersecurity news, SE angles, and detection queries.