/

CVE-2026-27595

Severity:

HIGH RISK

(7.5)

Missing Authentication in Parse Dashboard AI Agent Endpoint

CVE-2026-27595

Analyzed

Vulnerability type

Category:

Missing Authentication

CWE:

CWE-306

Impact:

Unauthenticated Arbitrary Database Read/Write via Master Key

Severity:

HIGH RISK

(7.5)

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

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/agent on 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 appId instances 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.

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-qwc3-h9mg-4582

Frequently asked

questions

Yes, if the Parse Dashboard (or specifically the AI Agent endpoint) is accessible from the internet or an untrusted network while the agent feature is enabled. An attacker only needs network access to the endpoint; no login is required in the vulnerable versions.

No. The core problem is missing authentication and authorization on a powerful endpoint. A remote attacker can issue POST requests directly to /apps/:appId/agent without a valid session, provided they can reach the service over the network.

The safest pattern is to treat all feature endpoints, including optional or "internal" ones, as untrusted entry points: require explicit authentication, apply fine-grained per-resource authorization, enforce CSRF protection where applicable, and strictly separate high-privilege keys (like master keys) from lower-privilege tokens both in code and in caching layers.

Adopt a security-by-default routing model where new endpoints must explicitly declare authentication and authorization middleware. Define clear policies for use of master keys and read-only keys, including mandatory server-side enforcement of least privilege. Regularly review admin and agent-style APIs for exposed high-impact operations, and include authentication, CSRF, and privilege checks as required gates in development standards and CI-based security tests.

Find out what's already
exploitable in your codebase.