/

CVE-2026-44221

Severity:

CRITICAL RISK

(9.0)

Authorization Bypass in ArcadeDB Cross-Database Access

CVE-2026-44221

Deferred

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-863

Impact:

Cross-Database Unauthorized Access and Schema Manipulation

Severity:

CRITICAL RISK

(9.0)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

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/server HTTP 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/server and 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 uninitialized fileAccessMap.
  • Creating databases via the server API (e.g., POST /api/v1/server with {"command":"create database X"}), which results in databases with record-level security effectively disabled.
  • Why exploitation is possible:
  • An uninitialized or empty fileAccessMap is treated by requestAccessOnFile as 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:

  1. 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.
  2. Security configuration not applied on critical operations: The database creation path (ArcadeDBServer.createDatabase()) neglects to invoke factory.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 fileAccessMap or 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.

Sources

SourceLink
github.comgithub.com/ArcadeData/arcadedb/commit/04110c06315da55604ac107f71fe7182f3a3deb8
github.comgithub.com/ArcadeData/arcadedb/commit/9e708f116b
github.comgithub.com/ArcadeData/arcadedb/security/advisories/GHSA-fxc7-fm93-6q77

Frequently asked

questions

The vulnerability is broadly exploitable by any authenticated principal on the affected ArcadeDB server. Once logged in, a user or an API token that is intended to be scoped to a single database can interact with other databases and, in some cases, bypass record-level authorization. The exploitability is limited primarily by the ability to authenticate and reach the relevant APIs.

No. The issue specifically affects accounts and tokens that are meant to be scoped to a single database. Even low-privilege or narrowly scoped principals can potentially escalate their effective reach to other databases, because the authorization checks do not correctly enforce database boundaries or record-level rules.

The safest pattern is to enforce a strict, fail-closed authorization model. This includes requiring that all security structures are initialized before use, treating any missing or unknown permission data as "deny," and centralizing all access control decisions in a single, consistent enforcement layer. Additionally, all resource creation paths should be updated to guarantee that security configuration is applied and validated at creation time.

Preventing similar issues involves a combination of design and process: adopt a clear authorization model with explicit scoping, ensure that defaults are always conservative, integrate security checks into core abstractions rather than scattered across handlers, and build automated tests that exercise multi-tenant and cross-database scenarios. Augment this with static analysis rules for authorization patterns, peer reviews focused on security-critical code, and routine audits of management APIs and resource creation paths.

Find out what's already
exploitable in your codebase.