/

CVE-2026-22663

Severity:

HIGH RISK

(7.5)

Missing Authorization in prompts.chat Private Prompt APIs

CVE-2026-22663

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Unauthorized Disclosure of Sensitive Information

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

prompts.chat contained multiple missing authorization checks that allowed unauthorized users to access data tied to private prompts.

When specific API endpoints and page metadata were requested, the application did not consistently verify whether the requester was allowed to view the underlying private prompt, exposing histories, change requests, examples, content, and descriptive metadata.

Affected context

This vulnerability affects prompts.chat functionality that handles "private" prompts, particularly:

  • API endpoints responsible for serving prompt version history, change requests, examples, and current content
  • Page rendering and metadata generation paths that populate HTML meta tags with prompt titles and descriptions

The issue is relevant when applications rely on private prompts for sensitive or proprietary information, yet do not enforce a consistent authorization check on every access path. It does not require any specific misconfiguration beyond using the affected versions of prompts.chat with private prompts enabled.

Exploit preconditions

  • Attack surface: Web application endpoints and associated HTML pages of prompts.chat
  • Required access: Ability to send HTTP requests to the affected endpoints or access rendered pages; no valid ownership or membership in the private prompt is required if the bypass exists
  • Trigger point: Requesting specific APIs or pages related to a private prompt where the isPrivate or equivalent authorization check is missing
  • Why exploitation is possible: The system treats some routes as public or partially protected and fails to re-verify that the current user is authorized to access data for a given private prompt before returning sensitive content and metadata

Why this happens

The core issue is an authorization logic gap, in which the application assumes that certain endpoints or rendering paths are safe without enforcing a consistent access-control check for private resources.

This aligns with CWE-862: Missing Authorization, where a system does not perform a permission check for a resource before allowing its use.

Instead of centralizing and mandating an isPrivate or ownership check for all prompt-related operations, prompts.chat had scattered logic, leaving some API calls and metadata generation flows without the necessary validation. As a result, any user capable of invoking those endpoints could retrieve or infer sensitive information about private prompts.

Potential impact

  • Unauthorized users may access private prompt version history, revealing evolution of sensitive or proprietary content.
  • Attackers could retrieve change requests and examples associated with private prompts, exposing internal workflows or experimentation.
  • Current private prompt content can be disclosed, including potentially confidential text or business logic.
  • Titles and descriptions of private prompts may leak via HTML meta tags, enabling information gathering and reconnaissance.
  • Exposure of intellectual property or sensitive operational text used in internal automation or customer interactions.

General mitigation guidance

Effective mitigation hinges on enforcing consistent, centralized authorization for all private resources and their derivatives.

Common defensive patterns include:

  • Implementing a single, reusable authorization layer (middleware, policy engine, or service) that checks prompt ownership or access level for every request involving private prompts.
  • Treating metadata (titles, descriptions, preview text) as sensitive when derived from private prompts, and avoiding exposure in public or cacheable contexts unless explicitly allowed.
  • Applying a "default deny" stance for prompt-related endpoints: any action on a private prompt must explicitly pass an authorization check before data is read or rendered.
  • Separating public and private routes at the routing and component level, ensuring that private prompt handlers never fall back to public code paths without re-validation.
  • Minimizing the amount of sensitive information included in client-visible metadata, and using generic placeholders where detailed descriptions are not strictly needed.

How teams detect issues like this

To detect similar issues, organizations can:

  • Use static analysis or linting rules that flag controller or API methods handling private resources when no explicit authorization guard is present.
  • Enforce code review checklists requiring reviewers to validate access control for any feature dealing with "private", "restricted", or "internal" data.
  • Implement application-level security tests (DAST) that attempt to access private resources from unauthenticated or unauthorized accounts and confirm they are blocked.
  • Adopt policy-as-code frameworks (such as centralized authorization policies) and verify via automated tests that each endpoint referencing private prompts includes the correct policy hooks.
  • Monitor logs for unusual access patterns, such as anonymous or unrelated users repeatedly requesting endpoints associated with private prompt identifiers.

Sources

SourceLink
github.comgithub.com/f/prompts.chat/commit/7b81836b214f2796aaf37ded2944eadc978afd35
github.comgithub.com/f/prompts.chat/pull/1104
vulncheck.comvulncheck.com/advisories/prompts-chat-authorization-bypass-information-disclosure

Frequently asked

questions

Yes. Any remote user who can reach the affected prompts.chat endpoints or pages may attempt to exploit the missing authorization checks, even without being associated with the private prompts in question, depending on the specific deployment and access controls around the service.

Typically, only network-level access to the web application is required. The attacker does not need to own or collaborate on the private prompt. In some deployments, a basic account might be required, while in others, even unauthenticated users might be able to reach the vulnerable endpoints if public access is permitted.

The most robust fix is to centralize authorization for private resources and ensure every endpoint, view, and metadata generator that touches those resources calls the same permission-checking logic. Adopting a "default deny" model and using common middleware or policy enforcement components reduces the chance of missing checks on new routes.

Prevention typically involves combining secure design and automated checks: define clear access-control rules for all data types, implement them in a single shared layer, require explicit authorization in code reviews, and back this up with automated unit, integration, and security tests that verify unauthorized users cannot access private content or its metadata.

Find out what's already
exploitable in your codebase.