/

CVE-2026-59954

Severity:

HIGH RISK

(7.5)

Auth Bypass via AppId Normalization (CWE-287) in Apollo

CVE-2026-59954

Deferred

Vulnerability type

Category:

Authentication Bypass

CWE:

CWE-20, CWE-287

Impact:

Unauthorized Access to Sensitive Configuration Data

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

Apollo ConfigService before 2.5.2 contains an authentication bypass where non-canonical appId variants can pass AccessKey or management key checks but are later resolved to a protected application.

Under accent-insensitive or PAD SPACE collations, attackers may access configuration data for another app by using visually similar or padded appId values on /configs and /configfiles endpoints.

Affected context

This vulnerability appears in Apollo deployments using ConfigService with AccessKey or management key authentication enabled.

It is most relevant when:

  • The database or underlying storage uses accent-insensitive collations, allowing accent variants of appId
  • Or PAD SPACE collations, allowing trailing-space variants of appId
  • /configs and /configfiles endpoints are exposed to services or external clients

In these environments, an appId that passes authentication checks in one normalized form may still be mapped to a different logical application downstream.

Exploit preconditions

  • Attack surface: HTTP(S) requests to Apollo ConfigService /configs and /configfiles endpoints
  • Required access: Ability to send authenticated-like requests using AccessKey or management key where appId is under attacker control
  • Trigger point: Providing a non-canonical appId variant (e.g., accent-changed or padded with spaces) that is treated differently between authentication and subsequent request handling
  • Why exploitation is possible: Input validation and canonicalization of appId are inconsistent; authentication accepts a variant while downstream resolution normalizes it to a protected app, effectively bypassing intended authorization boundaries

Why this happens

The core issue is inconsistent input validation and canonicalization of the appId across different processing stages.

During authentication, the ConfigService accepts certain appId representations as distinct (e.g., with accents or trailing spaces), but later components normalize these values under accent-insensitive or PAD SPACE collations and resolve them to an existing protected application.

This mismatch aligns with:

  • CWE-287: Improper Authentication, where identity checks can be fooled by alternate representations of credentials or identifiers
  • CWE-20: Improper Input Validation, where appId values are not normalized and validated consistently before being used for security decisions and routing.

Potential impact

  • Unauthorized read access to configuration files belonging to another application
  • Exposure of sensitive configuration values such as secrets, tokens, database credentials, or service endpoints
  • Potential pivoting to other services that trust Apollo-hosted configuration data
  • Confusion in audit logs due to ambiguous or misleading appId representations

General mitigation guidance

Mitigation typically involves enforcing consistent, strict handling of security-sensitive identifiers such as appId.

Common defensive patterns include:

  • Normalizing appId to a canonical form (e.g., trimming, accent/whitespace normalization) at the earliest possible point and using that canonical form for all authentication and authorization decisions
  • Validating appId against a well-defined pattern and rejecting ambiguous variants instead of attempting to tolerate them
  • Aligning database or storage collation choices with security requirements, avoiding collations that introduce ambiguity for identifiers used in authentication
  • Treating configuration data as sensitive and limiting which networks, services, or users can query ConfigService, applying least-privilege principles
  • Designing key-based authentication schemes so that the key is always bound to a canonical appId, and all components agree on the same normalization rules

How teams detect issues like this

Detection can focus on both code-level patterns and runtime signals:

  • Static analysis and review:
  • Look for authentication or authorization logic that compares appId or similar identifiers without prior canonicalization.
  • Flag code that relies on database collation behavior for equality or uniqueness of identifiers used in security decisions.
  • Review handling of whitespace, diacritics, and case transformations for identity-related fields.
  • Policy and automated checks:
  • Enforce coding standards that require canonicalization helpers for security-sensitive identifiers.
  • Integrate automated tests that attempt variants of appId (with accents, padding, or other Unicode variations) to ensure they cannot cross application boundaries.
  • Operational monitoring:
  • Monitor logs for repeated access attempts using unusual appId values or values that differ only by whitespace or diacritics.
  • Correlate configuration access patterns with registered applications to spot mismatches between callers and targeted apps.

Sources

SourceLink
github.comgithub.com/apolloconfig/apollo/commit/310809d557e01c6803051736cd525e333ffe00ec
github.comgithub.com/apolloconfig/apollo/releases/tag/v2.5.2
github.comgithub.com/apolloconfig/apollo/security/advisories/GHSA-4w3q-qpfq-v992

Frequently asked

questions

Exploitability depends on how widely ConfigService endpoints are exposed and whether the environment uses collations that allow ambiguous appId variants; in such setups, any party that can send authenticated requests with crafted appId values may abuse the issue.

The attacker typically needs some level of access to ConfigService using an AccessKey or management key, but can then craft non-canonical appId variants to reach configuration data belonging to another application.

Adopt strict, centralized canonicalization of appId (and similar identifiers) before any authentication or routing logic, ensure all subsystems use the same canonical form, and reject ambiguous or malformed variants outright.

Define clear normalization rules for all security-sensitive identifiers, align database/storage collations with those rules, treat canonicalization as part of input validation, and include tests and tooling that specifically check for authentication and authorization bypasses via alternate identifier encodings.

Find out what's already
exploitable in your codebase.