May 15, 2026·6 min read·48 visits
An authorization bypass in Joomla! webservice endpoints allows authenticated low-privileged users to read and modify sensitive configuration settings, resulting in total system compromise.
CVE-2026-23899 is a critical authorization bypass vulnerability within the Joomla! CMS webservice API. Due to an improper access check in the com_config component, authenticated low-privileged users can read and modify the global configuration, leading to the exposure of database credentials and the application secret key.
Joomla! CMS exposes a webservice API intended to facilitate programmatic interaction with the platform's core components. The Global Configuration component, designated internally as com_config, manages the most critical administrative settings for the application. This includes database credentials, SMTP relay configurations, and the cryptographic secret key used for session management.
CVE-2026-23899 identifies a critical authorization bypass vulnerability within the REST API controllers handling this component. The flaw allows an authenticated actor with basic API access to bypass intended privilege restrictions. The vulnerability is classified as an Improper Access Check under CWE-284.
Exploitation requires the attacker to possess a valid API token, regardless of the privileges associated with that token. The vulnerability manifests because the endpoint validates the authentication token but fails to perform subsequent authorization checks against the requested component. This permits low-privileged users to interact with administrative endpoints.
The vulnerability originates in the routing and controller logic of the Joomla! webservice architecture. When a request is dispatched to the /api/index.php/v1/config/application endpoint, the system extracts the X-Joomla-Token header to identify the calling user. The framework authenticates the session but delegates authorization responsibilities to the component controller.
The com_config REST controllers omit the required validation against the core.admin permission. In a secure implementation, the controller must invoke the Access::check() method or an equivalent authorization boundary before processing the request payload. The absence of this check creates a direct execution path from the authenticated router to the configuration handler.
Because the handler processes GET, POST, and PATCH methods without verifying the user's role, any authenticated request is treated as implicitly authorized. The system subsequently reads or modifies the configuration.php file based on the provided input. This architectural oversight breaks the principle of least privilege.
The Joomla! API relies on a modular architecture where each component defines its own webservice controllers. The vulnerable implementation of the com_config controller extends the base API controller but overrides or fails to implement the checkAccess() method required for administrative interfaces.
During the dispatch process, the application checks if the user is logged in. However, the specific method responsible for serving the configuration proceeds directly to interacting with the configuration model. The underlying model accesses configuration.php and serializes the variables into a JSON response.
The fix for CVE-2026-23899 introduces a mandatory permission check at the beginning of the controller's lifecycle. The patched code explicitly verifies that the user object possesses the core.admin permission for the com_config component. If the check fails, the controller returns a 403 Forbidden response, halting execution before the model is invoked.
This remediation correctly establishes the authorization boundary. By enforcing the core.admin requirement at the controller level, the patch ensures that no underlying methods can be reached by unauthorized actors. Developers must consistently apply this pattern across all administrative webservice endpoints to prevent variant attacks.
Exploitation of CVE-2026-23899 begins with the acquisition of a valid Joomla! API token. An attacker can obtain this token through a compromised low-privileged user account, a leaked configuration file, or an adjacent vulnerability. The specific privilege level of the token is irrelevant to the attack path.
Once a token is obtained, the attacker issues an HTTP GET request to the /api/index.php/v1/config/application endpoint. The request must include the X-Joomla-Token header containing the valid credential. The server processes the request and returns an HTTP 200 OK response containing the entire global configuration serialized as a JSON object.
The attacker parses the JSON payload to extract high-value credentials. The target fields typically include $db, $user, $password, $secret, and $smtppass. These values provide direct access to the underlying database infrastructure and email relay services, bypassing the web application entirely.
Alternatively, the attacker can submit an HTTP PATCH request to the same endpoint to modify the configuration. By altering security-centric settings, such as allowed upload extensions or session lifespans, the attacker facilitates secondary attack vectors. Modifying the configuration provides a reliable path to arbitrary code execution or persistent administrative access.
The confidentiality impact of this vulnerability is total. The configuration.php file acts as the central repository for all critical infrastructure credentials within a Joomla! deployment. Exposure of the database credentials allows an attacker to connect directly to the database server, assuming it is network-accessible, or use adjacent web-based database management tools.
Exposure of the Joomla! $secret key has profound cryptographic implications. The application relies on this key for session generation, CSRF token validation, and password reset procedures. An attacker in possession of the secret key can forge administrative sessions, bypass cross-site request forgery protections, and execute actions on behalf of other users.
The integrity and availability impacts are equally severe due to the application's processing of PATCH requests. An attacker can alter the database connection string to point to an external server, causing an immediate denial of service. They can also place the site into maintenance mode or inject malicious configurations that permanently disrupt the platform's operation.
The primary remediation for CVE-2026-23899 is upgrading the Joomla! CMS to a patched version. Administrators must deploy Joomla! version 5.4.4 or 6.0.4 immediately. These releases contain the necessary authorization checks within the com_config webservice controllers.
Applying the patch resolves the vulnerability but does not remediate prior exposure. Organizations must assume that any configuration data present on vulnerable instances has been compromised. A comprehensive credential rotation process must follow the software upgrade.
Administrators must generate a new database password, update the SMTP relay credentials, and cryptographically generate a new Joomla! secret key. Modifying the secret key will invalidate all active user sessions and remember-me tokens. This forced re-authentication is a necessary step to neutralize any sessions forged prior to the remediation.
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
Joomla! CMS Joomla! | 4.0.0 - 5.4.3 | 5.4.4 |
Joomla! CMS Joomla! | 6.0.0 - 6.0.3 | 6.0.4 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-284 |
| Attack Vector | Network |
| Privileges Required | Low (API Token) |
| CVSS v3.1 Score | 8.8 |
| EPSS Score | 0.00001 |
| Exploit Status | Proof of Concept |
The software does not restrict or incorrectly restricts access to a resource from an unauthorized actor.
A race condition and improper synchronization vulnerability (CWE-362) exists in Next.js versions 16.2.0 prior to 16.4.5 when Cache Components ('use cache' directive) are enabled. When an outer cached function calls a nested cached function that reads dynamic root parameters via 'next/root-params' and returns an object containing pending promises, React Flight can resolve and deliver the ready portion of the payload before the inner cache finishes publishing its root parameter dependencies. Consequently, the outer cache entry finalizes and persists under a cache key that omits the root parameter dependencies, causing the first written cache entry to be served across requests with different root parameter values and bypassing nested cache invalidation rules.
A remote OS command injection vulnerability (CWE-78) exists in code-review-mcp-server prior to version 1.5.3. The application passes caller-controlled tool parameters directly into Node.js child_process.execSync() calls without proper neutralization. An attacker or compromised LLM agent invoking tools such as getLocalGitDiff, codeReview, createPR, or getPRTemplate can inject arbitrary shell commands that execute with the privileges of the MCP server host process.
A path traversal vulnerability (CWE-22) in termux-sync prior to version 1.2.4 allows an attacker to overwrite arbitrary files within the Termux environment during the backup restoration process. The flaw stems from the application trusting attacker-controlled extraction paths defined in the backup's manifest.json file, failing to validate archive members against directory traversal sequences during tar extraction, and using unsanitized backup names when constructing temporary directories. If a user restores a malicious backup archive from local storage, shared folders, GitHub, or Google Drive, an attacker can overwrite sensitive configuration files such as shell startup scripts or local binaries, resulting in arbitrary code execution under the privileges of the Termux user.
SpamScope mail-parser versions 3.8.0 prior to 4.6.0 contain a path traversal vulnerability (CWE-22) within the write_attachments() and write_sample() functions. The library passes untrusted attachment filenames directly into os.path.join() without stripping directory components, validating path containment, or verifying symbolic links. An attacker can send a crafted email containing relative path traversal sequences or absolute filesystem paths in the Content-Disposition header to write or overwrite arbitrary files accessible to the parsing process.
A Regular Expression Denial of Service (ReDoS) vulnerability exists in SpamScope mail-parser versions 4.2.0 prior to 4.6.1. Two separate regular expressions evaluated during standard email header parsing exhibit quadratic to cubic backtracking complexity when processing headers padded with whitespace or angle brackets. An unauthenticated remote attacker can exploit this flaw by sending a small, RFC-compliant email message, causing parsing worker threads or processes to stall at 100% CPU utilization for extended periods.
CVE-2026-129297 is an origin validation vulnerability (CWE-345) in the Python library mail-parser prior to version 4.6.2. The MailParser.get_server_ipaddress() method fails to properly isolate MTA-recorded client IP addresses from sender-controlled text within email Received headers. Due to naive substring delimiter matching, appearance-based regular expression scanning, and fail-open header traversal, remote attackers can spoof their originating IP address to bypass email security controls, blocklists, and anti-spam attribution.