CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-11607

CVE-2026-11607: Broken Access Control in TYPO3 CMS Form Framework

Amit Schendel
Amit Schendel
Senior Security Researcher

Jun 15, 2026·7 min read·34 visits

Executive Summary (TL;DR)

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.

Vulnerability Overview

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.

Root Cause Analysis

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.

Code Analysis

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 Methodology

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.

Impact Assessment

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.

Remediation and Mitigation

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.

Technical Appendix

CVSS Score
7.6/ 10
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

Affected Systems

TYPO3 CMS
AttributeDetail
CWE IDCWE-862
Attack VectorNetwork
CVSS v4.07.6
EPSS Score0.00414 (0.41%)
ImpactPrivilege Escalation / Database Compromise
Exploit StatusNone
KEV StatusNot Listed
CWE-862
Missing Authorization

Vulnerability Timeline

Vulnerability disclosed in TYPO3-CORE-SA-2026-019
2026-06-09
Patches released for LTS and ELTS versions
2026-06-09

References & Sources

  • [1]TYPO3 Security Advisory TYPO3-CORE-SA-2026-019
  • [2]TYPO3 Git Commit 040d50
  • [3]TYPO3 Git Commit 50974c
  • [4]CVE Record CVE-2026-11607

More Reports

•1 day ago•CVE-2026-128087
3.7

CVE-2026-128087: Premature Key Exchange Callback Invocation Prior to Host Key Verification in russh

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.

Amit Schendel
Amit Schendel
8 views•10 min read
•2 days ago•CVE-2026-128082
7.5

CVE-2026-128082: Uncontrolled Recursion and Denial of Service in AutoMapper via Constructor Parameter Mapping

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.

Amit Schendel
Amit Schendel
8 views•11 min read
•2 days ago•CVE-2026-128080
5.8

CVE-2026-128080: Sensitive Query Parameter Disclosure on Incoming Server Spans in OpenTelemetry JavaScript (@opentelemetry/instrumentation-http)

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.

Alon Barad
Alon Barad
7 views•10 min read
•2 days ago•CVE-2026-128089
7.5

CVE-2026-128089: Uncontrolled Resource Consumption in dnspython WKS Record Parser

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.

Amit Schendel
Amit Schendel
8 views•10 min read
•2 days ago•CVE-2026-126347
3.1

CVE-2026-126347: Open Redirect via Triple-Slash Redirect Paths in Tornado RedirectHandler

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.

Alon Barad
Alon Barad
8 views•11 min read
•2 days ago•CVE-2026-128123
5.9

CVE-2026-128123: Uncaught Exception and Denial of Service in SvelteKit @sveltejs/adapter-node

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.

Alon Barad
Alon Barad
8 views•9 min read