Summary
ArcadeDB allows authenticated identities to invoke several schema-changing operations without the required UPDATE_SCHEMA permission. Through database command or query HTTP endpoints, a read-only API token may be able to alter or remove schema definitions, potentially changing how stored records are interpreted.
Affected context
The issue occurs in ArcadeDB deployments that expose database command or query HTTP endpoints and rely on schema authorization checks. While one schema mutation path includes an authorization check, other public mutators for types, properties, aliases, inheritance, buckets, and constraints may remain accessible to authenticated identities lacking UPDATE_SCHEMA permission.
Exploit preconditions
- Attack surface: Database command or query HTTP endpoints that accept schema mutation operations
- Required access: An authenticated identity, including a read-only API token, with access to the affected database endpoint
- Trigger point: Execution of operations such as DROP PROPERTY, ALTER TYPE, or ALTER PROPERTY
- Why exploitation is possible: Authorization enforcement is incomplete across public schema mutators, allowing operations to proceed without verifying the required schema-management privilege
Why this happens
The underlying flaw is inconsistent authorization enforcement across related schema-management APIs. A permission check was added to one mutator, but other publicly reachable methods continued to perform sensitive schema changes without validating the caller's privileges. This maps primarily to CWE-862: Missing Authorization, with CWE-863: Incorrect Authorization also relevant because the documented permission model does not consistently restrict protected operations.
Potential impact
- Unauthorized identities may change type names, inheritance relationships, aliases, or buckets
- Attackers could drop properties or alter property constraints
- Applications may misinterpret the meaning or structure of stored records
- Data access, validation, and application behavior could be disrupted
- Schema tampering could cause integrity issues without directly reading or writing record data
General mitigation guidance
Mitigation generally focuses on enforcing authorization consistently at every schema mutation boundary.
Common defensive patterns include:
- Applying the required schema-management permission to all public schema mutators
- Centralizing authorization decisions so individual operations cannot bypass them
- Treating read-only tokens and identities as unable to invoke schema-changing commands
- Using deny-by-default policies for administrative database operations
- Separating application credentials from schema-administration credentials
- Auditing schema changes and limiting database endpoint exposure to trusted networks
These controls reduce the risk of privilege bypass and help preserve the intended separation between data access and schema administration.
How teams detect issues like this
Organizations can look for this class of issue through:
- Static analysis checks confirming authorization guards on every public schema mutation method
- Code review searches for database commands that alter types, properties, aliases, buckets, inheritance, or constraints
- Endpoint and API policy tests using read-only identities against administrative operations
- Runtime monitoring for schema changes performed by identities without schema-management privileges
- Audit-log reviews that correlate schema mutations with caller roles and permissions
- Automated security testing or code review tools that compare permission requirements across related mutator methods

