A Single POST Request Writes a File Into Neos Flow's Public Resources Folder

"Flow, the PHP framework under Neos CMS, writes an unauthenticated upload into Web/_Resources/Persistent before the action's security policy runs, and its extension blocklist misses .phar, .

"Netics editorial card on the Neos Flow upload flaw, showing the policy check arriving after the file write."
"Netics editorial visual for the Flow upload advisory analysis."

TL;DR

  • Flow is the PHP application framework that Neos CMS is built on, and every Neos installation therefore runs it, which is why the project treats a Flow flaw as a Neos flaw.
  • The advisory published on 13 November 2026 rates the issue 9.8 critical: an unauthenticated visitor writes arbitrary files into the public resources folder, Web/_Resources/Persistent, with a single POST request.
  • The mechanism is an ordering problem. Flow processes the upload before the security policy of the called action is enforced, so the file lands on disk while the policy check is still ahead in the request pipeline.
  • A second gap widens it: the extension blocklist misses .phar, .php7, .pht and .shtml, and on Apache an uploaded .htaccess file can switch on script execution that had been disabled.
  • The documented middleware order explains the shape of it: the request body is parsed at position 8 of the default chain, the security entry point sits at 9, and dispatch runs at 10.
  • Patched releases exist for every maintained branch, 8.3.22, 8.4.7, 9.0.10, 9.1.5 and 9.2.3, and the advisory asks an operator to check uploaded files as well as update.
  • The execution path closes from the web server side, where a rule that no script runs below Web/_Resources holds even when a patch is late.
Netics warning panel stating that one POST request writes a file into the public resources folder because Flow evaluates the upload before the action policy
Netics visual, 13 November 2026: the two facts in the advisory that compound, the write that happens first and the policy that evaluates later.

What the Flow upload handler writes into Web/_Resources/Persistent

Flow ships a persistent resource management layer that stores uploaded files under Web/_Resources/Persistent and records each one in the database. The advisory describes what an unauthenticated visitor can do with it: place arbitrary files in that folder with a single request, without logging in. The Neos project's own summary names the two conditions that combine, the upload processed before the security policy of the called action is enforced, and a forbidden-extension list with gaps in it.

Neos advisory of 13 November 2026 on the Flow file upload vulnerability, with the affected versions, the fixed releases and the CVSS 9.8 severity, neos.io/blog/2026/security-advisory-critical-remote-code-execution-vulnerabilities-in-flow-and-neos.html
The project's advisory as published on 13 November 2026: component, vulnerability type, severity, affected and fixed versions in one table. Page from https://www.neos.io/blog/2026/security-advisory-critical-remote-code-execution-vulnerabilities-in-flow-and-neos.html.

The affected range covers most of the maintained tree: Flow up to and including 8.3.21, 8.4.0 to 8.4.6, 9.0.0 to 9.0.9, 9.1.0 to 9.1.4 and 9.2.0 to 9.2.2. Anything up to Flow 8.2 stays unmaintained and receives no fix, which the advisory states plainly and answers with the web server rule below.

The middleware order that runs body parsing at position eight

Flow's HTTP chapter documents the default middleware chain in order: standards compliance, trusted proxies, session, AJAX widget, routing, powered-by header, flash messages, body parsing, the security entry point, and dispatch. The request body is parsed at position 8. The security entry point runs at 9 and the dispatcher at 10.

Sequence diagram from the Flow Framework documentation showing how an authorisation decision is formed and enforced around an intercepted method, flowframework.readthedocs.io/en/stable/TheDefinitiveGuide/PartIII/Security.html
The framework's own sequence diagram for policy enforcement, from the Security chapter of the Flow documentation. Image from https://flowframework.readthedocs.io/en/stable/TheDefinitiveGuide/PartIII/Security.html.

That order is the architecture behind the advisory's sentence. The security chapter describes the framework as initialising in the MVC dispatcher and intercepting request dispatching before any controller is called, with the authorisation decision formed around the intercepted method: an aspect intercepts the call, a security interceptor refreshes the authentication status, and the privilege manager decides whether the method may run. A body that has already been parsed and handled sits earlier in that sequence than the decision about whether the action was permitted.

Sequence diagram from the Flow Framework documentation showing the authentication process and the security context during an HTTP request, flowframework.readthedocs.io/en/stable/TheDefinitiveGuide/PartIII/Security.html
The companion diagram from the same chapter: where authentication and the security context enter the request. Image from https://flowframework.readthedocs.io/en/stable/TheDefinitiveGuide/PartIII/Security.html.

Read as a design lesson, this is the useful part of the advisory. A policy attached to the method it protects is a strong guarantee, and it says nothing about work performed before that method is reached. Framework patches for this class of bug therefore land in two places at once, in the deny list and in the cleanup around requests that should have been refused a write.

The extension blocklist that missed .phar, .php7, .pht and .shtml

The GitHub advisory names the four extensions the blocklist did not cover: .phar, .php7, .pht and .shtml. Each one matters only if the web server will execute it, and the advisory is careful about that condition. On hosts that execute scripts below Web/_Resources, the impact is critical. Elsewhere, the attack leaves files behind.

GitHub security advisory GHSA-7wrr-qcrp-4hhf for neos/flow, showing the impact statement, affected and patched versions and CVSS 9.8 metrics, github.com/neos/flow-development-collection/security/advisories/GHSA-7wrr-qcrp-4hhf
The advisory record itself, published 13 November 2026 by the Flow maintainers: impact, affected ranges, patched versions and the CVSS vector. Page from https://github.com/neos/flow-development-collection/security/advisories/GHSA-7wrr-qcrp-4hhf.

The Apache case deserves its own line. An uploaded .htaccess file can enable script execution that had previously been disabled, which turns a directory-level configuration file into a way around the rule the administrator had set.

What a nine-point-eight advisory asks an operator to do

Two actions follow. The first is the update: composer update neos/flow, then confirm with composer show neos/flow that the installed version is one of the patched ones. The patch-level releases are 8.3.22, 8.4.7, 9.0.10, 9.1.5 and 9.2.3.

Netics ranking of the four layers where the Flow upload execution path closes, from the web server rule to the database cleanup
Netics visual, 13 November 2026: the four layers that close the path, ordered by how quickly each one can be applied.

The second is a check, because updating closes the hole and leaves any file that was already written. The advisory supplies the two queries that find them. On disk, a find over Web/_Resources/Persistent filtering symlinks and script-like extensions (.ph, .shtml, .cgi, .pl, .py) lists candidates. In the database, a select against neos_flow_resourcemanagement_persistentresource filtering filename LIKE '.%' or lowercased %.ph%, %.shtml, %.cgi, %.pl, %.py returns the records that hint at an unauthenticated upload. Findings get reviewed, then removed with their records.

Where the execution path closes

The web server rule is the durable half of the fix. Configure the server so that it never executes PHP or any other script type below Web/_Resources. That closes the code execution path on an unpatched Flow 8.2 install, on a host where the update is waiting for a change window, and on any future upload bug of the same family.

Netics definition card for CWE-434, unrestricted upload of a file with a dangerous type, as the advisory classifies the Flow issue
Netics visual, 13 November 2026: the weakness class the advisory assigns, and the score it carries.

For an operator running a self-hosted CMS, that rule belongs beside the rest of the sovereign infrastructure and cloud exit work, in the same configuration review that decides which directories serve static bytes and which ones can run code. Two habits carry it: a rewrite or handler rule per vhost that denies script handlers under the resources directory, and a weekly check of that directory for files with script extensions or a leading dot.

The advisory closes with a line worth repeating on its own terms. The patched releases check file extensions for every kind of upload, discard newly created resources if a request fails, and enforce the action policy before an error action is called. Three changes, one theme: the order in which a framework evaluates a request decides what an unauthenticated visitor can leave behind.

Sources

Source: the Neos advisory post of 13 November 2026, the GitHub advisory GHSA-7wrr-qcrp-4hhf and the Flow Framework Security and HTTP documentation chapters, all fetched on 13 November 2026. Those documents carry the affected and patched versions, the CVSS score, the extension list, the middleware order and the checking queries quoted above.