/

CVE-2026-25538

Severity:

HIGH RISK

(8.8)

Missing Authorization in Devtron Attributes API

CVE-2026-25538

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Privilege Escalation and Complete Account Takeover via JWT Forgery

Severity:

HIGH RISK

(8.8)

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

Devtron's Attributes API exposes the global API token signing key to any authenticated user via the /orchestrator/attributes?key=apiTokenSecret endpoint without proper authorization checks.

With this key, an attacker can forge valid JWTs for arbitrary users offline, potentially gaining full control over the Devtron platform and enabling lateral movement into the underlying Kubernetes cluster.

Affected context

This vulnerability occurs in Devtron instances (version 2.0.0 and prior) where:

  • The Attributes API is reachable to general authenticated users (including low-privileged CI/CD developers).
  • The global API token signing key is stored as an attribute accessible through the /orchestrator/attributes interface.
  • JWT-based authentication relies on a single, shared signing key for generating and validating API tokens.

In such environments, the lack of fine-grained access control around sensitive attributes exposes critical cryptographic material to users who should never have access to it.

Exploit preconditions

  • Attack surface: Devtron HTTP(S) API, specifically the /orchestrator/attributes endpoint.
  • Required access: Any valid authenticated Devtron account, including low-privileged or CI/CD-focused roles.
  • Trigger point: An HTTP request to /orchestrator/attributes?key=apiTokenSecret that returns the global JWT signing key.
  • Why exploitation is possible: The Attributes API returns highly sensitive configuration values without enforcing a proper authorization policy, allowing users outside of administrative roles to access cryptographic secrets used to sign and validate JWTs.

Why this happens

The core issue is a missing authorization check (CWE-862) on a highly sensitive API path that exposes the global API token signing key.

The Attributes API treats the apiTokenSecret attribute like any other configuration value, returning it to any authenticated caller without verifying whether that caller is authorized to access cryptographic material or platform-wide secrets.

Architecturally, this reflects an insecure access-control design where:

  • Secret-bearing attributes are not segregated from non-sensitive configuration.
  • Roles and permissions are not enforced at the resource or field level.
  • The principle of least privilege is not applied to the retrieval of authentication and signing keys.

As a result, the signing key becomes effectively public within the set of authenticated users, enabling offline JWT forgery and privilege escalation.

Potential impact

  • Attackers can forge valid JWT tokens for arbitrary Devtron user identities.
  • Complete takeover of the Devtron web interface and API under any existing or fabricated account.
  • Escalation from low-privileged CI/CD roles to full administrative control within Devtron.
  • Unauthorized configuration changes to CI/CD pipelines, deployments, and environment settings.
  • Abuse of Devtron's cluster integration to perform lateral movement into the connected Kubernetes cluster.
  • Potential deployment of malicious workloads, secrets exfiltration, or tampering with production deployments via compromised Devtron control.

General mitigation guidance

Effective mitigation focuses on enforcing strict access control for sensitive attributes and protecting cryptographic keys:

  • Apply explicit authorization checks on all endpoints that return secrets, API keys, signing keys, or similar high-value attributes; ensure only narrowly defined administrative roles can access them.
  • Separate sensitive attributes (e.g., signing keys, passwords, tokens) from general configuration, using different storage mechanisms, APIs, or access layers that are locked down by default.
  • Implement the principle of least privilege at the API layer, granting read access to attributes only when a business need and appropriate role are clearly established.
  • Avoid exposing raw signing keys to application users or automation where possible; instead, provide higher-level token issuance workflows that never reveal the underlying key material.
  • Use key rotation strategies so that if a signing key is ever exposed, it can be quickly replaced without long-lived impact.
  • Centralize secrets management using established secret stores or key management systems, and enforce consistent access policies across services.

How teams detect issues like this

Organizations can identify and monitor this class of issue through a combination of code-centric and operational approaches:

  • Static analysis and code review:
  • Flag internal APIs that expose configuration or attribute values and require explicit authorization guards.
  • Search for endpoints that return secrets, keys, tokens, or passwords and verify role-based access controls are applied.
  • Enforce patterns such as "no direct secret reads from public or low-trust endpoints" in secure coding guidelines.
  • Security testing:
  • Include privilege-escalation and horizontal-access tests in API security assessments, verifying low-privileged accounts cannot access sensitive attributes or cryptographic material.
  • Use automated API scanners and fuzzers configured with multiple roles to detect inconsistent access-control behavior.
  • Runtime monitoring:
  • Log access to sensitive attributes or secret-retrieval endpoints and alert on unusual patterns, such as low-privileged accounts requesting signing keys.
  • Apply API gateway or WAF rules that restrict access to sensitive paths to specific roles, networks, or service identities.
  • Governance and policy:
  • Adopt policies requiring threat modeling for any feature that handles secrets or authentication infrastructure.
  • Integrate security checks into CI/CD pipelines to ensure access-control annotations or middleware are present on sensitive routes.

Sources

SourceLink
github.comgithub.com/devtron-labs/devtron/commit/d2b0d260d858ab1354b73a8f50f7f078ca62706f
github.comgithub.com/devtron-labs/devtron/security/advisories/GHSA-8wpc-j9q9-j5m2

Frequently asked

questions

Any user who can authenticate to the Devtron instance and reach the Attributes API endpoint can potentially exploit this issue, regardless of whether they hold an administrative role, because the missing authorization applies to all authenticated callers.

The attacker only needs valid, low-privileged credentials (for example, a CI/CD developer account) and network access to the Devtron API; no direct access to the Kubernetes cluster or underlying infrastructure is required to obtain the signing key.

The safest approach is to enforce strict, role-based authorization checks on any endpoint that can return secrets or keys, segregate secret retrieval from generic configuration APIs, and ensure that only tightly controlled administrative identities can read cryptographic key material.

Preventing similar issues involves designing APIs with least privilege in mind, classifying data by sensitivity, requiring security review for features that handle authentication or secrets, and using automated checks to verify that all sensitive endpoints are guarded by appropriate authorization logic before deployment.

Find out what's already
exploitable in your codebase.