Summary
A missing authorization control in the Parse Dashboard AI Agent API (POST /apps/:appId/agent) allows authenticated users scoped to one app to invoke the agent endpoint for any other app by changing the appId in the URL.
Additionally, read-only users incorrectly receive the full master key and can request write permissions, enabling unintended write and delete operations on data when the agent configuration is enabled.
Affected context
This vulnerability occurs in Parse Dashboard deployments that:
- Run versions 7.3.0-alpha.42 through 9.0.0-alpha.7, and
- Have the
agentconfiguration block enabled for at least one app, and - Allow authenticated dashboard users with app-scoped accounts (including read-only roles).
In these conditions, the AI Agent API endpoint (POST /apps/:appId/agent) fails to enforce per-application authorization boundaries and mishandles privilege separation for read-only users.
Exploit preconditions
- Attack surface: HTTP(S) access to the Parse Dashboard AI Agent API endpoint (
POST /apps/:appId/agent). - Required access: Any authenticated dashboard account with access to at least one app (including read-only access) in a vulnerable version where the
agentconfig is enabled. - Trigger point: Sending requests to
/apps/:appId/agentwith: - A different
appIdin the URL than the one the user is scoped to, and/or - A request body that includes write or delete permissions despite being a read-only user.
- Why exploitation is possible: The endpoint does not verify that the caller is authorized for the target
appId, and read-only users are incorrectly provided with the full master key; the server trusts client-specified permissions in the request body instead of enforcing read-only semantics server-side.
Why this happens
The bug stems from missing and incomplete authorization logic on the AI Agent API endpoint.
The handler:
- Relies on the
appIdsupplied in the URL without validating that the authenticated user is entitled to operate on that specific app. - Grants read-only users the primary master key instead of a restricted read-only key, effectively elevating their privileges.
- Accepts client-supplied permission flags in the request body, rather than enforcing allowed operations based on the authenticated user's role and scope.
This aligns with CWE-862: Missing Authorization, where functionality that requires access control does not enforce any or sufficient authorization checks, breaking app-level and role-based isolation.
Potential impact
- Unauthorized access to AI Agent operations for apps the user should not see or control.
- Read-only users may perform write and delete operations through the agent, leading to:
- Data tampering, corruption, or deletion.
- Unauthorized configuration changes mediated by the agent.
- Cross-app data exposure where an app-scoped user can act against other apps managed by the same dashboard.
- Privilege escalation from read-only to effective admin-level operations within affected apps.
General mitigation guidance
Effective mitigation patterns for this class of vulnerability typically include:
- Enforce per-resource authorization: For every endpoint that takes an
appIdor similar identifier, verify that the authenticated user is explicitly authorized for that app before performing any action. - Honor least privilege in key handling: Distinguish clearly between full master keys and read-only/master-like keys; ensure read-only roles are mapped only to read-constrained credentials and that these credentials cannot be used to write or delete data.
- Server-side permission enforcement: Treat client-supplied permission flags and scopes as untrusted; derive the effective permissions strictly on the server from the user's role, group memberships, and app associations.
- Role and scope modeling: Design user roles so they map directly to permissible operations, and centralize access-control checks so the same logic is reused across endpoints handling app-level operations.
- Secure-by-default configuration: Consider disabling optional high-privilege features like AI Agent integrations by default or requiring explicit opt-in with clear documentation of permissions and required protections.
How teams detect issues like this
Detection can focus on both code-level and operational indicators:
- Static analysis and code review:
- Flag endpoints that accept resource identifiers (e.g.,
appId) from the URL or body but do not call a standardized authorization helper or middleware. - Review controller and service methods for direct use of master keys or elevated credentials without role checks.
- Identify code paths where client-supplied permission scopes are directly honored without server-side filtering.
- Policy and testing approaches:
- Incorporate authorization unit and integration tests that attempt cross-app access using different roles, especially read-only users.
- Add CI checks that require every new API route to register its authorization policy (e.g., via decorators or a route-to-policy map).
- Runtime monitoring:
- Log and review calls where a read-only user triggers write or delete-like agent operations.
- Monitor for patterns of users accessing multiple distinct
appIdvalues beyond their assigned scope.

