Summary
ArcadeDB contains a missing authorization check in the DELETE FUNCTION SQL statement, allowing a database user to remove registered server-side functions without the required schema-update permission.
When a user has database access and can submit commands through the command API, this may permanently affect security-relevant logic and reduce application availability.
Affected context
The issue affects ArcadeDB deployments where users can access a database and submit SQL commands through the command API. The DELETE FUNCTION operation unregisters and persists the deletion of a server-side function without verifying the UPDATE_SCHEMA permission, so the risk depends on how database access and command privileges are assigned.
Exploit preconditions
- Attack surface: Database command execution through the ArcadeDB command API
- Required access: Valid access to the affected database and sufficient ability to submit SQL commands
- Trigger point: Execution of the DELETE FUNCTION statement
- Why exploitation is possible: The deletion path does not perform the expected database authorization check before unregistering and persisting the function removal
Why this happens
The underlying bug is an authorization-control omission in a state-changing database operation. The DELETE FUNCTION execution path performs a privileged schema-related action without invoking the permission check associated with UPDATE_SCHEMA.
This maps to CWE-862: Missing Authorization, where an application fails to enforce an authorization requirement before allowing an authenticated or otherwise reachable user to perform a protected operation.
Potential impact
- An unauthorized database user may remove registered server-side functions
- Security-relevant function logic could be disabled or deleted
- Application workflows depending on those functions may become unavailable
- Database integrity could be altered through unauthorized schema-related changes
- Repeated or targeted deletions could contribute to denial of service
General mitigation guidance
Mitigation generally focuses on enforcing authorization consistently for every state-changing database operation.
Common defensive patterns include:
- Requiring an explicit schema-management permission for function deletion
- Centralizing authorization checks so command handlers cannot bypass them
- Applying deny-by-default access policies to database command interfaces
- Restricting database accounts to the minimum operations required for their roles
- Separating application query access from administrative and schema-management access
- Auditing authorization decisions and persisted function-removal events
- Treating server-side functions as protected configuration and limiting their mutability
How teams detect issues like this
Organizations can look for this class of issue through:
- Static analysis that identifies state-changing handlers lacking authorization calls
- Code review checks requiring permission enforcement before schema or metadata mutations
- Tests that invoke administrative SQL operations using accounts with ordinary database access
- Policy enforcement that separates query permissions from schema-management privileges
- Audit monitoring for unexpected DELETE FUNCTION activity or sudden disappearance of registered functions
Automated security review tools may help identify command paths where authorization checks are missing or inconsistently applied.

