Automation Insights 7 min read

PHP and Node.js RCE Fixes: What to Patch This Week

October 28, 2026 Keitri Team
Share

Two major web runtimes published unusually serious security news in the same week. Node.js released fixes on October 21, 2026 for a High-severity flaw that can turn malformed Brotli data into memory corruption and remote code execution. The PHP project published two Critical advisories that day, then listed patched PHP releases in its October 22 changelog.

The dates matter less than the shared lesson: your runtime is part of your attack surface. A framework can be current, application authentication can be sound, and your own code can pass review while the process underneath it is still exposed during ordinary request handling. If that process is on an end-of-life release, there may be no patch to install.

We spent the week inventorying runtimes, tracing where untrusted bodies are decoded, and rebuilding artifacts that carry their own runtime. This is the practical guidance we would use for any business operating PHP or Node.js systems.

What Node.js Fixed

CVE-2026-111497 is an out-of-bounds write in the Brotli decoder bundled with Node.js. The Node.js advisory explains that an invalid block switch could be treated as a temporary need for more input rather than a permanent format error. The streaming decoder could then continue appending bytes past an internal buffer. An attacker who supplies Brotli data that an application decompresses through node:zlib may be able to crash the process, disclose process memory, or achieve remote code execution.

The Node.js project rates the issue High and identifies the affected release lines as 22.x, 24.x, and 26.x. The fixed releases are:

  • Node.js 22.23.4
  • Node.js 24.22.1
  • Node.js 26.12.1

The official release schedule marks Node.js 20, 21, 23, and 25 as end of life, along with older lines. The security advisory says end-of-life versions should be treated as affected when a security release occurs. In practical terms, running Node.js 20 because it still starts successfully is now a security decision: there is no 20.x release in this patch set. Move the application to a supported line rather than waiting for a backport.

Where Node.js Exposure Hides

The advisory's technical boundary is clear: attacker-controlled Brotli data must reach node:zlib. The inventory around that boundary is ours, because real applications rarely call a decoder in only one obvious place.

  • Inbound request bodies. Check middleware that inflates compressed bodies, especially routes that accept Content-Encoding: br. Decompression can happen before the handler that performs authentication or authorization.
  • Outbound HTTP responses. Review clients and integrations that accept compressed responses from third parties. Follow the path through the HTTP client rather than assuming only public server endpoints matter.
  • Direct decoder use. Search for Brotli functions from node:zlib in upload, archive, import, proxy, and data-processing code.
  • Build and packaging paths. Include CI images, build runners, package-install stages, and any tooling that processes untrusted compressed data.
  • Bundled runtimes. A container image or single-executable application does not inherit the Node.js version installed on its host. Rebuild and redeploy the artifact after updating its base runtime.

The Node.js advisory does not name a configuration workaround. If an application has no reason to accept Brotli-compressed request bodies, rejecting Content-Encoding: br at the reverse proxy is a useful temporary reduction in exposure. It is not a substitute for patching: it does not cover outbound responses, direct decoder calls, or another bundled copy of Node.js.

What PHP Fixed

PHP's two advisories describe different routes to the same class of outcome: request-owned memory survives or is handled in an invalid state, and an unauthenticated attacker may turn that state into code execution with the web worker's privileges. The PHP CNA rates both issues Critical, CVSS 9.2.

CVE-2026-109618 concerns PHP's out-of-memory handling. PHP used longjmp() to abort a request when memory was exhausted. In some contexts, that early exit could leave request memory incompletely initialized before shutdown code read or acted on it. The vendor advisory documents several multipart strategies that can drive the process into this condition, including body data that passes an initial post_max_size check and multipart headers whose in-memory representation is much larger than their wire size.

CVE-2026-109619 concerns stale global state. A failed or interrupted request can leave a persistent worker referring to memory that belonged to that request. A later request handled by the same worker may consume that freed state before normal initialization resets it. One confirmed path uses session upload progress, which PHP enables by default and which can run before ordinary session initialization. The advisory confirms unauthenticated memory disclosure and remote code execution, while noting that exact exploitability varies by server interface, application path, extensions, and configuration.

The PHP project lists the fixes in these releases:

  • PHP 8.2.35
  • PHP 8.3.36
  • PHP 8.4.27
  • PHP 8.5.12

The associated CVE records identify earlier versions on those four branches as affected. PHP 7.x and other end-of-life branches are not supported patch targets, so they require an upgrade to a supported branch. PHP 8.2 also deserves a near-term plan even after this patch: its security support ends on December 31, 2026.

PHP Stop-Gaps Are Not Complete Fixes

Both vendor advisories are explicit that updating is the complete mitigation. If patching cannot happen immediately, reduce reachable paths while the upgrade is prepared:

  • Set session.upload_progress.enabled=0 administratively when upload progress is not required, then restart every PHP worker. Use centrally controlled PHP or FPM configuration rather than relying on a per-directory .user.ini.
  • Keep post_max_size conservative and enforce an independent decoded request-body limit at the web server, load balancer, or reverse proxy.
  • Block multipart requests at the edge for applications that do not use multipart form data.
  • Use container or cgroup memory controls as defence in depth, while recognizing that the advisory does not consider them complete protection.

Do not respond by simply lowering PHP's memory_limit. The first advisory is specifically about corruption reached through out-of-memory handling. Its primary configuration mitigation for systems that cannot update is administratively enforcing memory_limit=-1, and even that is incomplete because an underlying allocation can still fail. That trade-off needs operational review; it is not a reason to delay the patched runtime.

Why Authentication Is Not the Boundary

These issues are a reminder that “unauthenticated” does not necessarily mean a missing login check. PHP can parse multipart input before application-specific code begins. Node.js middleware may decompress a body before the route handler evaluates a session or token. The vulnerable operation can therefore sit below the security controls the product team normally thinks about.

The right question is not only “which routes are public?” It is “where can untrusted bytes reach runtime facilities, and which exact runtime binary handles them?” That includes workers, scheduled jobs, command-line tools, CI runners, containers, and packaged executables.

What To Do This Week

  • Inventory every runtime copy. Record the version in hosts, containers, base images, build pipelines, serverless functions, and self-contained artifacts. Do not infer the version from a developer laptop or host installation.
  • Patch supported lines now. Move Node.js to 22.23.4, 24.22.1, or 26.12.1 as appropriate. Move PHP to 8.2.35, 8.3.36, 8.4.27, or 8.5.12, then restart workers and rebuild deployable artifacts.
  • Treat end of life as an upgrade project. Apply narrowly scoped edge controls to reduce exposure, assign an owner and date, and move to a supported major line. “It still works” is not a security-support policy.
  • Reject or cap untrusted bodies at the edge. Deny encodings and content types the application does not use, cap decoded body size, and keep those controls independent of application code.
  • Make runtime support a standing risk item. Track support deadlines alongside certificates, backups, and dependency updates so the next security release starts with an inventory instead of a search.

The lasting lesson from these releases is not that PHP or Node.js is uniquely unsafe. It is that runtimes do security-sensitive work before your business logic gets a vote. Keep them visible, keep them supported, and design the edge so ordinary request features are never unlimited by default.