Summary
ArcadeDB contained an authorization bypass where authenticated users and scoped API tokens could read, write, and mutate schema on databases they were not meant to access.
Because database- and record-level checks were effectively disabled under certain conditions, any authenticated principal could interact with arbitrary databases on the same server, breaking isolation between tenants and data domains.
Affected context
This vulnerability affects ArcadeDB server deployments where:
- Multiple databases are hosted on the same ArcadeDB server instance, often for multi-tenant or environment separation.
- Access control relies on database-scoped users or API tokens to enforce isolation between databases.
- Databases may be created dynamically, including via the
/api/v1/serverHTTP endpoint with a{"command":"create database X"}payload.
In such configurations, users and tokens intended to be limited to a single database could still perform operations on other databases and, in some cases, operate against databases with record-level authorization silently disabled.
Exploit preconditions
- Attack surface: ArcadeDB server, including HTTP API endpoints such as
/api/v1/serverand database-specific APIs. - Required access: Any valid authenticated user account or API token, even if nominally scoped to a specific database.
- Trigger points:
- Invoking operations that rely on
ServerSecurityUser.getDatabaseUser()for authorization checks, where the returned database user has an uninitializedfileAccessMap. - Creating databases via the server API (e.g., POST
/api/v1/serverwith{"command":"create database X"}), which results in databases with record-level security effectively disabled. - Why exploitation is possible:
- An uninitialized or empty
fileAccessMapis treated byrequestAccessOnFileas an "allow-all" configuration, so the absence of explicit permissions is misinterpreted as full permission. - The database creation path omits
factory.setSecurity(...), causing new databases created through that API to bypass the intended authorization framework for record-level access. - In combination, these flaws allow an authenticated principal to perform operations across databases without the intended isolation and without being blocked by record-level security.
Why this happens
The core issue maps to CWE-863: Incorrect Authorization and stems from inconsistent and incomplete enforcement of authorization logic in the ArcadeDB server.
At an abstract level, the authorization subsystem exhibits two insecure patterns:
- Unsafe default on missing policy: The
ServerSecurityUser.getDatabaseUser()method can return a database user whose internal access-control map (fileAccessMap) is uninitialized. Instead of treating this as "no permissions granted," downstream code (requestAccessOnFile) interprets the missing map as "all permissions allowed." This is a classic insecure fail-open behavior where absence of policy is treated as full access rather than denial. - Security configuration not applied on critical operations: The database creation path (
ArcadeDBServer.createDatabase()) neglects to invokefactory.setSecurity(...). As a result, newly created databases through the affected API path are not wired into the record-level authorization framework at all, effectively disabling fine-grained security controls for those databases.
Together, these patterns represent an authorization design flaw where security checks are fragmented, rely on implicit defaults, and are not consistently enforced across all entry points. The system assumes security has been configured when, in reality, some objects are created without full security metadata, and the authorization code path is not robust against missing or uninitialized state.
Potential impact
- Unauthorized reading of data from other databases hosted on the same ArcadeDB server.
- Unauthorized modification or deletion of records in databases the user or token should not access.
- Unauthorized schema changes (e.g., creating, altering, or dropping types, collections, or indexes) across databases, potentially breaking applications.
- Cross-tenant data exposure and modification in multi-tenant deployments, undermining isolation guarantees.
- Escalation from low-privilege, database-scoped accounts to effective administrative control over multiple databases.
- Long-term integrity issues where audit trails and record-level access assumptions become unreliable or meaningless.
General mitigation guidance
Mitigation focuses on enforcing consistent, fail-safe authorization and eliminating insecure defaults in access control logic.
Recommended design patterns include:
- Fail-closed authorization decisions: Ensure that any missing or uninitialized security structure (such as an empty
fileAccessMapor null security descriptor) is treated as "deny" by default. Authorization checks should require explicit permission entries, not infer permission from missing data. - Centralized access control evaluation: Consolidate authorization checks so that all database and record operations pass through a single, well-tested policy enforcement point, rather than having multiple code paths that can drift out of sync.
- Mandatory security configuration for new resources: Enforce that database creation, schema mutation, and other critical operations must attach a fully initialized security model. Object factories or builders should refuse to create databases or security-sensitive resources if security metadata is absent or incomplete.
- Explicit scoping of principals: Model users, roles, and API tokens with clear scoping rules (e.g., single-database, multi-database, server-wide) and validate those scopes at every entry point that allows cross-database operations.
- Defense-in-depth around management APIs: Treat server management endpoints (e.g., database creation, configuration changes) as highly privileged surfaces. Apply strong authentication, role checks, and where possible, segregate them from routine data plane APIs.
- Least-privilege for application accounts: Encourage deployments to use narrowly scoped database accounts or tokens per application or tenant, minimizing the blast radius if any single principal is affected.
How teams detect issues like this
Effective detection of this class of issue involves both code-level analysis and runtime observation:
Static analysis and code review:
- Search for authorization code paths that interpret uninitialized or empty permission maps as granting access instead of denying it.
- Flag patterns where security-related fields (e.g., permission maps, security descriptors, role sets) are not validated prior to use.
- Identify resource creation functions (e.g., database or schema factories) that fail to initialize or attach security configuration, especially when alternative creation paths do so correctly.
- Review HTTP or RPC handlers that perform database or schema operations to ensure they always enforce principal scope and database ownership checks.
Runtime and configuration-level checks:
- Monitor access logs for indications that a single principal is accessing multiple databases that, by policy, should be isolated.
- Evaluate database metadata and configuration to confirm that newly created databases have consistent security settings, especially record-level authorization rules.
- Use policy-as-code or configuration validation tools to verify that all databases in a fleet conform to expected security baselines.
Organizations can employ automated code scanning tools, custom static analysis rules, and CI/CD gating on security-sensitive modules to catch regressions in authorization handling before deployment. Periodic access reviews and anomaly detection on database activity can complement code-level controls.

