> ## Content Index
> Fetch the complete content index at: https://blog.cyberdesserts.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Unauthenticated RCE: Where Pre-Auth Bugs Really Live
- URL: https://blog.cyberdesserts.com/where-unauthenticated-rce-lives/
- Published: 2026-11-18T19:58:07.000Z
- Updated: 2026-11-19T01:55:59.000Z
- Description: PHP2Shell, MongoBleed and React2Shell look like unrelated accidents, but they have common traits. Recognise those traits, and you can find the same weakness in your own stack before an attacker does.
- Author: Shakel Ahmed

*November 2026*

Remote code execution (RCE) is the worst line on a vulnerability report: an attacker running their own code on your server, on your account, with your reach. It has several causes: memory corruption, unsafe deserialisation, command injection, path traversal. The dangerous ones add a single qualifier, unauthenticated: no login, no account, no starting foothold.

The critical bugs named in the past twelve months look unrelated: PHP2Shell in the PHP engine, MongoBleed in a database, KindaRails2Shell in a web framework, React2Shell in a front-end library. That's four different products, four different kinds of flaw. Underneath, they are the same bug: each reads attacker-supplied input before anyone has logged in, often before your own code runs at all, in a feature that was switched on by default. What changes from one to the next is not the bug but where it sits, and these four sit at very different depths, from the language runtime up to the application.

That is what made PHP2Shell spread so fast. Cloudflare saw exploitation attempts go from tens of thousands within 45 minutes of disclosure to millions by early the next day (Cloudflare).

Learn to spot that trait in your own stack, and you find the next bug before it has a name.

> The pre-auth bugs of the past year, from MongoBleed's zlib decompression to KindaRails2Shell's default image loaders, share one trait: they parse attacker-supplied input before any login, in code that is on by default. The question to ask is where that kind of code sits in your stack.

![Block diagram mapping twelve months of unauthenticated remote code execution vulnerabilities to the software-stack layer each affected: application code at the top, then framework, shared libraries and decoders, language runtime, and reverse proxy at the base, with a dashed row showing where similar pre-auth bugs are likely to appear next.](https://storage.ghost.io/c/35/11/3511c934-5ff5-4c52-bd35-1fa0ecc19415/content/images/2026/11/unauthenticated-rce-stack-layers-1.svg)

The unauthenticated RCEs of the past twelve months, mapped to the stack layer each one hit. Reach widens as you move down, from the code you own to the proxy fronting roughly a third of the web. Dashed boxes mark where the same conditions already sit.

## The trait they share

Start with PHP2Shell, the pair the NSA told organisations to patch or take offline. The two critical flaws (CVE-2026-109618 and CVE-2026-109619) live in PHP itself, in how the engine cleans up after a request that hit a fatal error. No account was needed; a crafted request to a default install was enough, and the earliest affected path goes back to PHP 5.4.0 (Calif).

[MongoBleed](https://blog.cyberdesserts.com/mongobleed-cve-2025-14847/) is the same bug in a database. The flaw sits in MongoDB's zlib network decompression, which runs before authentication, so an attacker with network access to the default port could read uninitialised server memory, credentials and tokens included (Wiz).

KindaRails2Shell is the same bug in a web framework. Rails' Active Storage left an unsafe set of libvips image loaders switched on by default, so an unauthenticated image upload could be turned into reading arbitrary files off the server, secrets included (Rails security team).

[React2Shell](https://blog.cyberdesserts.com/cve-2025-55182-react-fix/) shows it in a front-end library, in the way React Server Components decode the data a browser sends back (CVE-2025-55182).

Four different layers of the stack. One mechanism: untrusted input, parsed early, in a default-on feature nobody deliberately enabled.

So the real question is depth. How far down the stack does this kind of code sit, and who inherits it when it breaks?

## Same bug, different depth

The mechanism is the same at every layer. What differs is the damage, and that comes down to how deep the code sits. Four layers, from the shared foundation up to your own code:

- **The language** is the specification, the rules of PHP or Python or JavaScript. It does not run on its own, so on its own it cannot be attacked.
- **The runtime** is the engine that runs your code: the PHP interpreter, CPython, the V8 engine inside Node. A flaw here touches every application on that runtime, whatever your own code does. PHP2Shell is a runtime flaw, which is why a stock WordPress install and a hand-written PHP app were exposed on the same terms.
- **A library or framework** is code your application pulls in. A flaw there reaches only the applications that installed it. React2Shell sat in React Server Components; apps that did not use them were out of its reach.
- **The application** is the server software you run and the code you write. A flaw here is yours, and it stops with you.

← Scroll to see full table

| Incident             | Layer                               | Pre-auth input                                        | Who's exposed                                     | The fix                                                            |
| -------------------- | ----------------------------------- | ----------------------------------------------------- | ------------------------------------------------- | ------------------------------------------------------------------ |
| **nginx2root**       | Reverse proxy (in front of the app) | HTTP/2 flow-control frames on a default listener      | every nginx with HTTP/2 enabled (1.9.5 to 1.31.8) | correct the send-window accounting so the counter cannot underflow |
| **PHP2Shell**        | Runtime (PHP engine)                | request data on memory-limit and cleanup paths        | every app on an unpatched PHP version             | reset request state at request end; cap upload memory              |
| **Java4Shell**       | Runtime (JVM / OpenJDK)             | a Base64-encoded token, decoded before the auth check | JVM apps on x86-64 with AVX-512 (OpenJDK 17.0.6+) | bound the output length in the Base64 decoder intrinsic            |
| **MongoBleed**       | Application server (MongoDB)        | zlib-compressed wire-protocol headers                 | every reachable MongoDB with zlib enabled         | validate the length fields in zlib decompression                   |
| **KindaRails2Shell** | Framework (Rails Active Storage)    | an uploaded image, default processor                  | every Rails app using the default image variant   | disable the unsafe libvips loaders by default                      |
| **React2Shell**      | Library (React Server Components)   | the serialised payload a browser posts back           | every app using React Server Components           | fix the deserialisation in Server Components                       |

*Source: CyberDesserts analysis; CVE details from the linked advisories.*

The closer a flaw sits to that foundation, the less it looks like your problem, and the more it takes with it when it goes. You inherit a runtime flaw simply by running the runtime; you never chose the feature, because it was on when you installed it. And the vulnerable code is often one you never added by hand at all: a transitive dependency, pulled in by something you did choose, buried far enough down the tree that you may not know it is there until it breaks.

Depth decides who is exposed. Why it turns critical in the first place comes down to three conditions.

## Why these bugs keep turning critical

Parsing untrusted input early is not automatically a disaster. Three conditions turn it into one, and the named bugs have all three.

**First**, the code is reachable before authentication, so an attacker needs nothing but network access. **Second**, it is on by default, so the people running it never decided to accept the risk. Third, the process lives on to serve the next request, so what one request leaves behind can surface in the next.

**The** **third** condition is the one that gets missed. Modern servers do not start fresh for every request; they keep long-lived worker processes and reuse them. PHP2Shell's second flaw was exactly this: a request that died partway through left state behind, and the next request on the same worker picked it up (Calif). The 2023 redis-py leak was the same condition in a connection pool. Cancelling an async command at the wrong moment left a connection holding one request's data, which was then handed to the next (CVE-2023-28859). At OpenAI that showed some users other people's ChatGPT chat titles, and payment details for 1.2% of active Plus subscribers in a nine-hour window (OpenAI).

AI-serving infrastructure tends to ship with the first two conditions built in. Ollama's API ran exposed and often without authentication; a path-traversal flaw (CVE-2024-37032, "Probllama") let an unauthenticated attacker write files on the server and from there run code, and Wiz found over a thousand instances exposed to the internet (Wiz). vLLM went further: its Mooncake integration accepted Python pickle data over a ZeroMQ socket bound to every network interface, so anyone who could reach the port could run code, rated CVSS 10 (CVE-2025-32444). Pickle over an open socket is this pattern in its purest form.

A defender can look at a service and see which of the three it has.

## What this means for defenders

The one-line patch for each CVE is not the useful part. The useful part is structural: the change each project’s maintainers made to how their software handles untrusted input, which closes the whole class of bug rather than the one flaw. Those design changes carry over to your own stack.

- Restart the worker on a timeout or a fatal error instead of letting it serve the next request. Ruby's rack-timeout ships this as `term_on_timeout`, for exactly the stale-state problem PHP2Shell exploited.
- Reset per-request state at the end of every request, so nothing a request leaves behind survives into the next. That is what PHP's patch now does.
- Add an authentication layer in front of any service that ships without one, model-serving endpoints first. Ollama's own guidance is to run it behind an authenticating reverse proxy.
- Turn off default-on features you do not use. PHP's interim mitigation for the exploited path was this: set `session.upload_progress.enabled=0` if you do not need it. The same line also closes CVE-2026-115560, a third PHP RCE disclosed two days after the pair; because it needs a non-default session configuration, PHP handled it in the normal release cycle.
- Patch fast, and move these bugs to the front of the queue. By the time one has a name, the mass scanning has usually already started.

## The next one is already in your stack

PHP2Shell, MongoBleed, the next one: the names change; the bug underneath does not. What changed over the past year is speed. Amazon's honeypots logged an exploit attempt four days before PHP2Shell was even public (Amazon). The gap between a fix landing and an exploit appearing is now measured in hours.

Where does this already live? Not a prediction, just the places carrying all three conditions today:

- **Compression and decoders on the network path:** zlib, Brotli, zstd, image parsers. They read attacker-controlled bytes before auth, and they are mostly written in C, where malformed input can be pushed past the end of a buffer and corrupt memory. That is how a decoder flaw can become code execution, and these decoders are bundled into almost everything. MongoBleed was zlib. In October 2026 an out-of-bounds write in Google's Brotli decoder (CVE-2026-111497 , named Node2Shell) forced same-week emergency patches across Node.js, .NET and Python, because each ships its own copy of the same decompression code, and CISA added it to the Known Exploited Vulnerabilities list within a week. Days earlier, Next.js shipped an unauthenticated RCE in its image-optimisation path (CVE-2026-96889): with SVG optimisation switched on, a crafted SVG reaches a memory bug in the librsvg library that sits behind sharp. And the decoder does not have to be on the wire: the Base64 decoder built into the Java runtime (Java4Shell, CVE-2026-114938, November 2026) turned a malformed string into an out-of-bounds heap write on x86-64 CPUs with AVX-512, unauthenticated RCE in the default configs of Keycloak, Jira and Jenkins, because almost everything Base64-decodes a token or header before it checks who you are.
- **Web servers and reverse proxies:** the software in front of nearly every app, parsing attacker HTTP before a line of your code runs. nginx serves roughly a third of the web. On 18 November 2026, F5 patched nginx2root, five nginx CVEs found by several teams at once; the worst, CVE-2026-123007, is an unauthenticated RCE in HTTP/2 flow control that works on a default nginx with HTTP/2 enabled, no backend application or module needed (nginx 1.9.5 to 1.31.8, fixed in 1.31.9). Found the same AI-assisted way as PHP2Shell.
- **AI-serving infrastructure:** inference servers and the glue around them. They shipped fast, often without authentication, and lean on deserialisation. Ollama and vLLM already showed it, and the deployment curve is still climbing.
- **Long-lived worker runtimes beyond PHP:** Python's async servers, Ruby, Node. The third condition, worker reuse, is theirs too. Node.js and Python both shipped critical fixes the same day PHP2Shell landed.
- **Deserialisation at any trust boundary:** pickle, Java serialisation, framework data formats. Deserialisation is the step that turns received bytes back into live objects a program can use, and with some formats a crafted payload makes that step run code instead. It is the shortest path from "parse input" to "run code," and React2Shell serves as a recent example.

Each one is worth the time to understand now, so that when the next one is found, you already know where to look.

Find the service in your stack that parses untrusted bytes before a login and is on by default. The next big bug is already sitting in code like that; the only question is whether you find it first, or someone else does.

---

****Get articles like this delivered to your inbox.** Subscribe to CyberDesserts for practical security insights, no fluff.

[Subscribe ](https://blog.cyberdesserts.com/#/portal/signup) 

  
**References and sources**

1. **Calif Research**. php2shell. Bug pattern, PHP 5.4.0 origin, the two CVEs. [https://calif.io/php2shell/](https://calif.io/php2shell/?ref=blog.cyberdesserts.com)
2. **Cloudflare**, reported via Cybernews. PHP2Shell exploitation attempts, tens of thousands to millions within a day. [https://cybernews.com/security/php2shell-attacks-php-new-vulnerabilities-found/](https://cybernews.com/security/php2shell-attacks-php-new-vulnerabilities-found/?ref=blog.cyberdesserts.com)
3. **Amazon**, reported via Cybernews. Honeypot exploitation attempt on 17 Oct 2026, four days before disclosure. [https://cybernews.com/security/php2shell-attacks-php-new-vulnerabilities-found/](https://cybernews.com/security/php2shell-attacks-php-new-vulnerabilities-found/?ref=blog.cyberdesserts.com)
4. **Wiz Research**. MongoBleed (CVE-2025-14847), zlib decompression before authentication. Disclosed 19 December 2025\. [https://www.wiz.io/blog/mongobleed-cve-2025-14847-exploited-in-the-wild-mongodb](https://www.wiz.io/blog/mongobleed-cve-2025-14847-exploited-in-the-wild-mongodb?ref=blog.cyberdesserts.com)
5. **Rails security team / Ethiack**. KindaRails2Shell (CVE-2026-66066), Active Storage libvips default. [https://www.helpnetsecurity.com/2026/08/03/kindarails2shell-cve-2026-66066-vulnerability/](https://www.helpnetsecurity.com/2026/08/03/kindarails2shell-cve-2026-66066-vulnerability/?ref=blog.cyberdesserts.com)
6. **React / Meta**. React2Shell (CVE-2025-55182), React Server Components. Disclosed 3 December 2025\. CyberDesserts coverage: <https://blog.cyberdesserts.com/cve-2025-55182-react-fix/>
7. **redis-py (CVE-2023-28859)** and **OpenAI postmortem**. Cross-user leak via cancelled async command; ChatGPT chat-title and billing exposure. [https://openai.com/index/march-20-chatgpt-outage/](https://openai.com/index/march-20-chatgpt-outage/?ref=blog.cyberdesserts.com)
8. **Wiz Research**. Probllama (CVE-2024-37032), Ollama path traversal to RCE, 1,000+ exposed instances. [https://www.wiz.io/blog/probllama-ollama-vulnerability-cve-2024-37032](https://www.wiz.io/blog/probllama-ollama-vulnerability-cve-2024-37032?ref=blog.cyberdesserts.com)
9. **Red Hat**. vLLM (CVE-2025-32444), pickle over unauthenticated ZeroMQ, CVSS 10\. [https://access.redhat.com/security/cve/CVE-2025-32444](https://access.redhat.com/security/cve/CVE-2025-32444?ref=blog.cyberdesserts.com)
10. **Node.js Project / Google Brotli**. Brotli decoder out-of-bounds write RCE (CVE-2026-111497), widely named Node2Shell. Node.js 21 October 2026 security release; same bug patched out-of-band across .NET and Python, added to CISA KEV 27 October 2026\. [https://nodejs.org/en/blog/vulnerability/october-2026-security-releases](https://nodejs.org/en/blog/vulnerability/october-2026-security-releases?ref=blog.cyberdesserts.com)
11. **Next.js / CSA**. Unauthenticated RCE in Image Optimization via SVG, librsvg behind sharp (CVE-2026-96889, CWE-416), Next.js 14 October 2026 out-of-band release (15.5.28 / 16.4.1). Conditional: glibc-based Linux with SVG optimisation enabled. [https://labs.cloudsecurityalliance.org/research/csa-research-note-nextjs-use-cache-librsvg-rce-20261016-csa/](https://labs.cloudsecurityalliance.org/research/csa-research-note-nextjs-use-cache-librsvg-rce-20261016-csa/?ref=blog.cyberdesserts.com)
12. **rack-timeout** (Ruby). `term_on_timeout` restart-on-timeout. [https://github.com/zombocom/rack-timeout](https://github.com/zombocom/rack-timeout?ref=blog.cyberdesserts.com)
13. **Wiz Research / Xint (Theori)**. nginx2root, unauthenticated HTTP/2 RCE (CVE-2026-123007, flow-control integer underflow), exploitable on a default nginx with HTTP/2 enabled; nginx 1.9.5 to 1.31.8, F5 fix 1.31.9 / 1.30.7, disclosed 18 November 2026\. [https://www.wiz.io/blog/nginx-http2-rce-vulnerabilities](https://www.wiz.io/blog/nginx-http2-rce-vulnerabilities?ref=blog.cyberdesserts.com)
14. **Calif**. Java4Shell (CVE-2026-114938), memory corruption in OpenJDK's Base64 intrinsic (HotSpot C2 JIT, AVX-512 VBMI): malformed input to an out-of-bounds heap write, unauthenticated pre-auth RCE in default configs of Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate; x86-64 with AVX-512 only, ARM64 unaffected; OpenJDK 17.0.6+; disclosed 17 November 2026\. [https://calif.io/java4shell](https://calif.io/java4shell?ref=blog.cyberdesserts.com)
15. **PHP project / CERT-EU**. CVE-2026-115560, a session-upload-progress RCE path in PHP, disclosed 23 October 2026, two days after the PHP2Shell pair. Needs a non-default session serialization configuration; no emergency release, mitigated by `session.upload_progress.enabled=0`, permanent fix scheduled for PHP's 19 November 2026 release. [https://www.php.net/](https://www.php.net/?ref=blog.cyberdesserts.com)