Jun 15, 2026·7 min read·34 visits
Authenticated backend users can bypass file extension restrictions to load malicious YAML configurations, executing arbitrary database commands and gaining full administrator privileges.
CVE-2026-11607 is a critical broken access control vulnerability in TYPO3 CMS's Form Framework (ext:form). Authenticated backend users with access to the Form Framework can load unauthorized YAML configurations, bypassing file extension restrictions. This allows the execution of arbitrary SQL commands via the SaveToDatabase finisher, leading to privilege escalation to administrator level.
CVE-2026-11607 is a broken access control vulnerability (CWE-862) within the Form Framework (ext:form) component of TYPO3 CMS. The Form Framework provides editors with a visual interface and backend modules to create, configure, and maintain interactive web forms. These configurations are serialized and stored as YAML files within designated persistence layers. The vulnerability allows authenticated backend users to bypass established file extension rules and load arbitrary configuration payloads.
Under normal operating conditions, the Form Framework restricts configuration files to the .form.yaml file extension. This restriction acts as a critical security boundary to prevent unauthorized file injection and parsing attacks. An administrative or low-privileged backend user with access to the Form module can, however, bypass this extension check. This vulnerability permits the processing of YAML files lacking the appropriate extension, exposing the underlying parsing engine to maliciously crafted input.
The consequences of this validation failure are severe, as it facilitates a multi-stage attack. By uploading a specially formatted configuration file, attackers can force the system to parse and execute arbitrary instructions. Specifically, the framework executes backend actions configured via form finishers when processing these files. This flaw ultimately enables arbitrary SQL statement execution on the underlying database, leading to full system compromise.
The root cause of the vulnerability lies in a logical short-circuiting flaw located in FormPersistenceManager.php and AbstractFileStorageAdapter.php. When importing or loading a form definition, the framework validates whether the file extension is secure. This validation check relies on a helper method designed to verify both the internal file structure and the external file extension. The validation logic was structured using a logical AND (&&) operator to perform these verification checks in sequence.
The function generateErrorsIfFormDefinitionIsValidButHasInvalidFileExtension executed two primary functions. First, it checked if the configuration payload structurally resembled a form via looksLikeAFormDefinition. Second, it checked if the file had a valid extension via hasValidFileExtension. Because these checks were joined by an AND operator, the failure of the first check caused the interpreter to skip the second check entirely.
An attacker can exploit this conditional evaluation by crafting a file that does not structurally match a standard form definition initially. Specifically, omitting the expected type: Form pair causes looksLikeAFormDefinition to return a boolean false. The overall conditional statement immediately evaluates to false, which bypasses the exception-throwing block. The system then processes the arbitrary file structure as a valid configuration despite its non-compliant file extension.
To understand the vulnerable code path, look at the logical operation executed during the file loading sequence. In the vulnerable version, the conditional check was implemented with a logical AND connector. If the parsed structure did not trigger the structural validator, the engine assumed no violation had occurred. The code snippet below illustrates the vulnerable conditional check before the patch was applied.
// Vulnerable logic utilizing short-circuit AND operator
protected function generateErrorsIfFormDefinitionIsValidButHasInvalidFileExtension(array $formDefinition, string $persistenceIdentifier): void
{
if ($this->looksLikeAFormDefinition($formDefinition) && !$this->hasValidFileExtension($persistenceIdentifier)) {
throw new PersistenceManagerException(sprintf('Form definition "%s" does not end with ".form.yaml".', $persistenceIdentifier), 1531160649);
}
}The patch changes the logic from a logical AND operator (&&) to a logical OR operator (||). By checking if the form definition is invalid OR if the file extension is invalid, the system enforces both criteria. If the structure is missing the appropriate keys, or if the extension is not .form.yaml, the validation block throws an exception. This ensures that the configuration must strictly conform to both structural and metadata constraints before loading.
Reviewing the patch for the file storage adapter shows an identical change to ensure consistent security across adapters. The modification in AbstractFileStorageAdapter.php alters the logic to use the negative OR evaluation mechanism. This parallel adjustment guarantees that alternative storage adapters do not remain vulnerable to the same file validation bypass. The complete implementation now leaves no paths where malformed file extensions can bypass structural validations.
Exploitation requires an attacker to possess authenticated backend privileges with access to the TYPO3 Form Framework. The attacker first constructs a malicious configuration payload inside a standard text file. This file uses a standard extension such as .yaml or .txt instead of the restricted .form.yaml suffix. The structure is designed to avoid containing the key-value pair type: Form during the initial persistence check.
The malicious YAML file defines a form structure containing a highly privileged database finisher. The Form Framework natively supports the SaveToDatabase finisher, which allows inserting user input directly into database tables. The attacker specifies database columns and insert parameters within the finisher configuration blocks. This configuration dictates the insertion of a new administrative user record into the be_users database table.
After uploading the file to a standard user-accessible directory like fileadmin/, the attacker references the file within the Form module. When the framework parses the file, the logical bypass occurs, and the persistence manager loads the configuration. The attacker then triggers the form processing sequence, executing the SQL instructions embedded in the finisher. This action inserts a new administrator account, allowing the attacker to escalate privileges and take complete control of the CMS.
The security impact of CVE-2026-11607 is classified as high, carrying a CVSS score of 7.6. The exploitation pathway allows low-privileged backend users to escalate their privileges to full administrators. This completely compromises the confidentiality, integrity, and availability of the affected TYPO3 installation. Since TYPO3 systems often handle highly sensitive web assets, a compromise at this level exposes the entire host environment.
Once an attacker gains administrative privileges via the database insert mechanism, they can execute arbitrary code. TYPO3 administrators have the capability to install extensions, configure template engines, and execute system commands in some configurations. This permits the deployment of web shells or malicious scripts directly to the underlying web server. Consequently, the exploit serves as a direct vector for remote code execution on the hosting infrastructure.
The vulnerability also presents significant risk to connected databases and internal networks. Attackers can extract sensitive application data, including user credentials, configuration files, and private client databases. The absence of active exploitation in the wild does not diminish the severity of the flaw. Immediate patching is necessary to mitigate the risk of target-specific unauthorized access attempts.
The primary remediation strategy is upgrading the TYPO3 installation to the designated secure versions. Security updates are available for all supported release branches, including LTS and ELTS versions. Administrators should consult the official TYPO3 release notes to determine the exact version matching their branch. Applying these updates replaces the vulnerable validation scripts with the corrected logical operators.
For organizations unable to apply immediate updates, temporary workarounds can mitigate the threat vector. Security administrators must audit and restrict user access to the TYPO3 Form Framework module. Disabling form creation permissions for non-admin users blocks the primary pathway required to reference external files. Additionally, implementing strict file upload restrictions on the /fileadmin/ directory prevents the placement of unauthorized YAML assets.
Finally, security teams should implement defensive monitoring and scanning routines across the environment. Analyzing the backend database for newly created administrative accounts helps detect unauthorized privilege escalation. Web Application Firewalls (WAF) can also be configured to block request payloads targeting the form editor endpoints. Continuous monitoring of file modification logs ensures rapid detection of suspicious YAML files within public directories.
CVSS:4.0/AV:N/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N| Attribute | Detail |
|---|---|
| CWE ID | CWE-862 |
| Attack Vector | Network |
| CVSS v4.0 | 7.6 |
| EPSS Score | 0.00414 (0.41%) |
| Impact | Privilege Escalation / Database Compromise |
| Exploit Status | None |
| KEV Status | Not Listed |
CVE-2026-128087 (GHSA-9264-jvgf-6w2f) is an incorrect behavior order (CWE-696) and improper authorization (CWE-863) vulnerability in the russh Rust SSH library, affecting versions 0.55.0 through 0.65.0. During the initial SSH key exchange (KEX) handshake, the client state machine invokes the client::Handler::kex_done() callback—providing the negotiated raw shared secret bytes—prior to validating the remote server's host key or certificate via check_server_key(). Consequently, an untrusted or rogue SSH server can complete cryptographic key agreement and force a connecting client to execute side-effecting application logic inside kex_done() before the server's identity is checked and rejected.
CVE-2026-128082 (GHSA-6vhm-j9h7-f9gh) is an uncontrolled recursion vulnerability (CWE-674) in AutoMapper, a convention-based object-object mapper for .NET. When mapping nested or self-referential types into destination models that rely on parameterized constructors, C# positional records, or recursive ConstructUsing expressions, AutoMapper evaluates child constructor arguments prior to incrementing the parent's recursion depth counter. This ordering flaw bypasses both explicit MaxDepth limits and the default depth limit of 64. An unauthenticated remote attacker can supply deeply nested input payloads to affected endpoints, exhausting the thread call stack and triggering an uncatchable System.StackOverflowException that terminates the hosting .NET process.
An information exposure vulnerability in the @opentelemetry/instrumentation-http package for OpenTelemetry JavaScript versions 0.204.0 prior to 0.222.0 causes incoming HTTP server spans to record raw, unredacted query string parameters under the url.query attribute. While outgoing client spans applied built-in and user-configured query parameter redaction, incoming server spans bypassed this sanitization completely, resulting in the transmission of sensitive credentials such as pre-signed cloud URLs and API tokens to external observability backends.
CVE-2026-128089 is an uncontrolled resource consumption vulnerability in the dnspython toolkit for Python, affecting all versions prior to 2.9.2. When parsing Well-Known Service (WKS) records from text via dns.rdtypes.IN.WKS.WKS.from_text(), the parser fails to validate that numeric service port identifiers fall within the RFC 1035 valid range of 0 through 65535. An attacker capable of supplying untrusted zone files or RDATA text strings containing an arbitrarily large service port integer can force the parser to allocate an unbounded bitmap array using an inefficient linear append loop, resulting in severe CPU exhaustion, application hangs, or Out-Of-Memory (OOM) process termination.
CVE-2026-126347 (GHSA-5cjw-f85j-cv6r) is an open redirect vulnerability (CWE-601) in Tornado, an asynchronous Python networking library and web framework. The flaw resides in tornado.web.RedirectHandler when dynamic URL redirection templates incorporate unvalidated user input. Due to a parser differential between RFC 3986 (used by Python's urllib.parse.urlsplit) and the WHATWG URL Standard (used by modern web browsers), inputs containing three or more leading slashes bypass Tornado 6.6.0's validation logic, allowing unauthenticated attackers to redirect users to arbitrary external domains.
A Denial of Service (DoS) vulnerability exists in @sveltejs/adapter-node versions 5.5.7 and 6.0.0-next.0 through 6.0.0. When a SvelteKit server route returns a direct response from a fetch() call with a Content-Type of text/event-stream, the Node.js adapter attempts to mutate the response headers to disable proxy buffering. Because headers returned directly by the WHATWG Fetch API carry an immutable guard, this mutation throws an unhandled TypeError, terminating the underlying Node.js process and denying service to all active and subsequent clients.