Summary
Parse Dashboard's AI Agent API endpoint in affected versions lacks proper authentication and authorization controls, allowing unauthenticated attackers to interact with connected Parse Server instances using powerful keys.
When the agent feature is enabled, a remote attacker can abuse the endpoint to perform arbitrary read and write operations against any configured Parse Server database, effectively bypassing application-level access controls.
Affected context
This vulnerability occurs in Parse Dashboard deployments that:
- Run versions from 7.3.0-alpha.42 through 9.0.0-alpha.7, and
- Have the AI Agent feature explicitly enabled and configured, and
- Expose the dashboard (or at least the AI Agent endpoint) to networks reachable by potential attackers.
Dashboards without an AI Agent configuration block are not impacted, as the vulnerable endpoint is not active in those setups.
Exploit preconditions
- Attack surface: HTTP POST requests to
/apps/:appId/agenton the Parse Dashboard instance. - Required access: Network-level reachability to the dashboard; no valid user session, API key, or credentials are required when the flaw is present.
- Trigger point: Sending crafted POST requests to the AI Agent endpoint for any configured
:appId. - Why exploitation is possible: The AI Agent endpoint was exposed without robust authentication, CSRF protection, or per-application authorization checks. Additionally, a cache key collision between the master key and read-only master key, along with insufficient enforcement of read-only constraints, allowed unintended elevation to full master key capabilities.
Why this happens
The core issue aligns with CWE-306: Missing Authentication for Critical Function, where a sensitive backend capability is reachable without adequately verifying the caller's identity or privileges.
In this case, the AI Agent endpoint was treated as an internal helper for agent functionality and was not consistently guarded by:
- Authentication middleware ensuring only logged-in users can access it.
- Per-application authorization to confirm the requesting user is allowed to operate on a specific
appId. - CSRF validation to ensure that requests originate from trusted dashboard interactions.
Compounding this design flaw, a cache key collision between the master key and the read-only master key, and insufficient server-side enforcement of read-only semantics, meant that requests which should have been constrained to read-only operations could instead be executed with full master key privileges.
Potential impact
- Unauthenticated reading of sensitive application data from connected Parse Server databases.
- Unauthorized modification, creation, or deletion of database records using master key privileges.
- Bypassing of all application-level access controls that normally restrict client operations.
- Data integrity compromise, including data corruption or targeted tampering of critical objects.
- Potential establishment of persistent backdoors or malicious configurations in application data.
- Use of the compromised Parse Server as a pivot point for wider application or infrastructure attacks.
General mitigation guidance
Effective mitigation focuses on enforcing strong access control around sensitive dashboard endpoints and avoiding master key exposure by default:
- Introduce mandatory authentication middleware for all non-public endpoints, ensuring requests originate from authenticated dashboard users.
- Apply granular, per-application authorization checks so that users can act only on specific
appIdinstances they are explicitly allowed to manage. - Enforce CSRF protection on state-changing endpoints that can be triggered via browser contexts.
- Implement clear separation between full master keys and read-only master keys, including distinct cache keys and strict server-side enforcement of read-only semantics regardless of client claims.
- Restrict or disable optional features like AI Agent in environments where they are not strictly needed, especially if they involve powerful backend actions.
- Limit network exposure of Parse Dashboard by placing it behind VPNs, admin-only networks, or authenticated reverse proxies to reduce anonymous access to the attack surface.
How teams detect issues like this
Organizations can identify and monitor similar issues using a combination of code-level and operational controls:
- Static analysis and code review:
- Flag routes or controllers that access master key functionality but lack explicit authentication and authorization middleware.
- Review route definitions for optional features (like "agent" or "admin" endpoints) to verify that they are gated behind consistent security policies.
- Examine caching logic involving security-sensitive tokens (e.g., master keys, read-only keys) for key collisions or ambiguous key derivation.
- Configuration and deployment checks:
- Maintain an inventory of dashboards and optional features (such as AI Agent) and periodically verify that only required features are enabled.
- Enforce infrastructure-as-code policies that require admin interfaces to sit behind authenticated gateways.
- Runtime monitoring and logging:
- Log all access to critical endpoints, including
/apps/:appId/agent, with request origin, appId, and effective key/permission level. - Set alerts on anomalous patterns such as repeated unauthenticated POST requests, mass read/write operations, or activity from unexpected IP ranges.
- Automated review tools:
- Integrate security scanners and linters into CI/CD pipelines to detect routes lacking authentication, missing CSRF checks, and overly permissive admin APIs.

