Summary
ArcadeDB allows a reader-role database user to submit JavaScript commands through the command API without the required database-administrator authorization. Combined with a host-class loading bypass in the JavaScript engine, this may let the user read arbitrary files accessible to the database process outside the database's intended scope.
Affected context
The issue occurs in ArcadeDB deployments where a user with reader-level database access can reach the command API and invoke the JavaScript PolyglotQueryEngine. The risk is present when command-related operations do not consistently enforce database-administrator authorization and the embedded scripting environment can reflect from a bound database object to load unrestricted host classes. Process creation is reportedly blocked, so operating-system command execution is not established by this issue.
Exploit preconditions
- Attack surface: The database command API endpoint, specifically JavaScript command handling
- Required access: An authenticated user with reader-role access to the target database
- Trigger point: Submission of a JavaScript command through the database command interface
- Why exploitation is possible: Command, analysis, and function-registration paths do not consistently require database-administrator authorization, while the scripting engine permits reflection-based access to host classes beyond the configured package allowlist
Why this happens
The vulnerability results from a combination of improper authorization and insufficient privilege separation. Sensitive PolyglotQueryEngine operations accept requests from a reader role even though they require administrative authority, mapping to CWE-863, Incorrect Authorization, and relating to CWE-269, Improper Privilege Management. In addition, the scripting environment's package restriction does not adequately constrain reflective access obtained through an exposed database object, allowing scripts to reach host classes and file-access functionality outside the intended database boundary.
Potential impact
- A reader-role user may read arbitrary files accessible to the database process
- Sensitive host, configuration, credential, or application data could be disclosed
- Database isolation boundaries may be weakened
- Exposed files could support follow-on compromise of connected systems
- The database process may be abused for unauthorized reconnaissance
General mitigation guidance
Mitigation generally focuses on enforcing authorization at every command engine entry point and reducing the capabilities exposed to database scripts. Sensitive command, analysis, and function-registration operations should use explicit allowlists tied to the caller's effective privilege, while secure-by-default deployments should disable scripting features that are not required. Host-object exposure and reflective class loading should be minimized or removed, and script execution should occur with a narrowly privileged service identity, restricted filesystem access, and isolated runtime permissions. Configuration and policy controls should also reduce reliance on package whitelists as the sole security boundary.
How teams detect issues like this
Detection approaches include static analysis and code review for API handlers that invoke command engines without centralized authorization checks, inconsistent role comparisons, and scripting APIs that expose database or runtime objects. Reviewers can search for reflection, class-loader access, unrestricted host interop, and package allowlists that are not enforced at the object or capability boundary. Runtime monitoring can alert on reader-role requests to JavaScript command endpoints, unusual file reads by the database process, and access to host classes outside the expected application set. Automated security review tools and policy checks can help identify these patterns in source and deployment configurations.

