/

CVE-2026-27608

Severity:

HIGH RISK

(8.1)

Broken Access Control / Missing Authorization

CVE-2026-27608

Analyzed

Vulnerability type

Category:

Broken Access Control / Missing Authorization

CWE:

CWE-862

Impact:

Privilege Escalation and Unauthorized Data Modification

Severity:

HIGH RISK

(8.1)

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

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 agent configuration 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 agent config is enabled.
  • Trigger point: Sending requests to /apps/:appId/agent with:
  • A different appId in 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 appId supplied 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 appId or 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 appId values beyond their assigned scope.

Sources

SourceLink
github.comgithub.com/parse-community/parse-dashboard/releases/tag/9.0.0-alpha.8
github.comgithub.com/parse-community/parse-dashboard/security/advisories/GHSA-cvwj-6c9h-jg6v

Frequently asked

questions

Yes, if the Parse Dashboard is exposed over the network (including the internet) and an attacker can obtain a valid authenticated dashboard account, they can exploit the issue remotely against any app managed by that dashboard where the agent feature is enabled.

The attacker needs any authenticated Parse Dashboard account with access to at least one app, including a nominally read-only account. No direct administrative privileges are required, because the missing authorization and key misassignment allow privilege escalation to other apps and to write/delete capabilities.

Apply strict per-app authorization checks on every endpoint that accepts an appId or similar identifier and centralize the logic so that roles and scopes are consistently enforced. Additionally, ensure that read-only users are bound to read-only credentials and that their effective permissions are computed server-side without trusting client-specified capabilities.

Adopt a consistent authorization framework that:

  • Requires explicit declaration of access-control policies for every route.
  • Enforces the principle of least privilege in key and token management.
  • Treats all client-supplied identifiers and permission hints as untrusted.
  • Includes automated tests and reviews focused on cross-tenant and cross-app isolation, especially for new high-privilege features like agent endpoints.
Find out what's already
exploitable in your codebase.