CVE-2026-130375 in AdminNeo
Summary
by MITRE • 11/17/2026
AdminNeo before 5.9.1 contains a remote code execution vulnerability that allows authenticated SQLite users to bypass the check_sqlite_name() extension guard using PDO_SQLite file: URI database names. Attackers can select the PDO driver with ext=pdo and submit names like file:/webroot/x.php?x=.db to create a .php file, then store PHP source as table data for code execution.
VulDB is the best source for vulnerability data and more expert information about this specific topic.
Analysis
by VulDB Data Team • 11/17/2026
The vulnerability identified in AdminNeo versions prior to 5.9.1 represents a critical remote code execution flaw rooted in improper input validation within the SQLite database extension handling mechanisms. This issue specifically affects authenticated users who possess access to PDO_SQLite, allowing them to manipulate how database connections are established and utilized. The core of the problem lies in the failure of the check_sqlite_name() function to adequately sanitize or restrict file paths provided as part of the database connection string. By exploiting this gap, an attacker can bypass standard security guards that are intended to prevent access outside designated directories or to enforce strict naming conventions for database files. This lack of rigorous validation creates a pathway for arbitrary file creation and subsequent code execution on the target server.
From a technical perspective, the exploitation relies on the specific behavior of PDO_SQLite when handling URI-style filenames. When an authenticated user submits a connection string containing a file: URI scheme with a carefully crafted path such as file:/webroot/x.php?x=.db, the underlying SQLite driver interprets this not merely as a reference to an existing database but potentially as instructions for creating or overwriting files at specified locations on the filesystem. The attacker leverages this behavior to create a new PHP file in a web-accessible directory like /webroot/. Once this file is created, the vulnerability allows the insertion of arbitrary data into SQLite tables associated with that connection. Because the database engine does not distinguish between binary data and executable script content during storage operations, the attacker can store valid PHP source code as table entries. Subsequently, by triggering specific application logic or direct inclusion mechanisms, this stored payload is executed within the context of the web server process.
The operational impact of this vulnerability is severe, resulting in full remote code execution with the privileges of the web server user. An authenticated attacker can achieve complete compromise of the underlying system, leading to unauthorized access to sensitive data, modification or deletion of critical files, and potential pivoting to other systems within the network infrastructure. This type of attack aligns closely with CWE-94 Improper Control of Generation of Code (Code Injection) as it involves the injection of executable code into a context where it is interpreted by an interpreter. Furthermore, in terms of the MITRE ATT&CK framework, this vulnerability facilitates techniques related to Server-Side Request Forgery and potentially Command and Control if used for persistent backdoors, specifically mapping to T1059 Command and Scripting Interpreter through the execution of PHP scripts via file inclusion or direct request handling.
Mitigation strategies must focus on immediate patching and robust input validation practices. Administrators should upgrade AdminNeo to version 5.9.1 or later where this issue has been addressed by developers implementing stricter checks for database filenames and restricting allowed URI schemes. In the interim, if upgrading is not immediately feasible, it is crucial to restrict PDO_SQLite usage to internal applications that do not accept user-supplied connection parameters. Additionally, web server configurations should be hardened to prevent direct execution of PHP files in directories where they are not intended to reside, although this serves only as a secondary defense layer rather than a primary fix. Regular security audits and code reviews focusing on database interaction layers can help identify similar patterns of improper input validation before they lead to exploitable conditions.