/

CVE-2026-56323

Severity:

HIGH RISK

(7.5)

Information Disclosure (CWE-200) in Capgo API Endpoint

CVE-2026-56323

Deferred

Vulnerability type

Category:

Information Disclosure

CWE:

CWE-200

Impact:

Exposure of sensitive application and subscription metadata

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

An information disclosure vulnerability in Capgo's /functions/v1/channel_self endpoint allows unauthenticated users to enumerate non-public rollout channel names, confirm whether specific apps exist, and infer subscription status.

By issuing crafted GET requests with arbitrary app_id parameters, a remote attacker can gather internal deployment and billing metadata across tenants without authentication or device binding.

Affected context

This vulnerability appears in Capgo deployments where the /functions/v1/channel_self API endpoint is exposed and does not strictly enforce authentication or device binding for metadata queries.

It primarily affects environments where application identifiers are guessable or enumerable and where rollout channels and subscription states are treated as internal-only information.

The issue becomes more impactful in multi-tenant scenarios, because responses can reveal the existence of apps and their associated rollout and billing status across different customers.

Exploit preconditions

  • Attack surface: Publicly reachable HTTP(S) interface exposing /functions/v1/channel_self.
  • Required access: No authentication, valid session, or device binding required; attacker needs only network access to the endpoint.
  • Trigger point: Attacker sends GET requests with arbitrary or enumerated app_id values to the vulnerable endpoint.
  • Why exploitation is possible: The endpoint returns detailed channel and billing-related metadata based solely on the provided app_id, without enforcing proper authorization checks or restricting the information returned.

Why this happens

The core issue is an authorization flaw where sensitive metadata is exposed to unauthenticated callers.

The /functions/v1/channel_self endpoint appears to trust the provided app_id and responds with internal channel information and subscription state, rather than limiting responses to authenticated, authorized entities.

This maps to CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, where a system discloses data that should be restricted, often due to missing or insufficient access control and overly verbose responses.

Potential impact

  • Enumeration of non-public rollout channel names and internal deployment configurations.
  • Discovery of valid application identifiers across tenants, aiding targeted attacks and account enumeration.
  • Inference of subscription and billing status for specific apps or tenants, potentially leaking business-sensitive information.
  • Improved reconnaissance for follow-on attacks, such as phishing, social engineering, or targeted abuse of specific customer accounts.
  • Violation of privacy or contractual expectations regarding tenant isolation and confidentiality of operational metadata.

General mitigation guidance

Effective mitigation focuses on tightening access control and reducing the sensitivity of data returned by public endpoints.

Recommended defensive patterns include:

  • Enforcing strict authentication and authorization on metadata endpoints, ensuring that only owners or trusted devices can query channel and subscription information for a given app_id.
  • Applying least-privilege data exposure by limiting responses to only what is necessary for the caller's legitimate use case, and omitting internal rollout or billing details from general-purpose APIs.
  • Designing APIs so that application existence checks and rollout metadata are not available through unauthenticated or low-trust interfaces, or are returned in a deliberately non-enumerable way.
  • Normalizing error responses for invalid and unauthorized app_id values to avoid enabling application or tenant enumeration.
  • Treating billing and rollout configuration as sensitive metadata and segmenting it behind higher-trust control planes rather than public-facing endpoints.

How teams detect issues like this

Detection typically involves a combination of logging review, testing, and automated analysis.

Possible strategies include:

  • Reviewing API access logs for repeated queries to /functions/v1/channel_self with many different app_id values, which may indicate enumeration attempts.
  • Incorporating security testing into CI/CD (such as API fuzzing or integration tests) to validate that unauthenticated requests cannot retrieve sensitive metadata and that errors do not leak internal details.
  • Using static analysis or configuration scanning to flag endpoints lacking explicit authentication/authorization decorators or middleware, especially for routes returning operational or billing data.
  • Implementing API gateway or WAF rules to rate-limit or block suspicious enumeration-like patterns and to enforce authentication policies centrally.

Sources

SourceLink
github.comgithub.com/Cap-go/capgo/security/advisories/GHSA-469v-6vw5-hxpq
vulncheck.comvulncheck.com/advisories/capgo-unauthenticated-channel-enumeration-and-app-oracle-via-get-channel-self

Frequently asked

questions

Yes. An attacker with network access to the affected Capgo API can exploit the issue remotely by sending crafted GET requests; no prior authentication or device association is required.

Only basic network access to the /functions/v1/channel_self endpoint is needed. The vulnerability is triggered via unauthenticated requests that supply arbitrary app_id values.

The most robust fix is to enforce strict authentication and authorization on the endpoint, ensuring that only properly authenticated and authorized callers can retrieve channel and subscription metadata for a given app, and to minimize the amount of sensitive information returned.

Design APIs under a "privacy by default" mindset: treat operational, billing, and configuration data as sensitive, require explicit authorization checks for any metadata access, normalize error messages to avoid enumeration, and regularly test endpoints for excessive data exposure using automated security testing and code review.

Find out what's already
exploitable in your codebase.