Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain any validly signed OIDC token
-
ExploitCall Exchange with guessed owner/repo and identity
-
ImpactRead leaked trust-policy patterns from PermissionDenied error
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Error message sanitization
MITRE ATT&CK
1 technique across 1 tactic: Discovery The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the attacker to (1) possess any validly signed OIDC token from any accepted issuer - for example a GitHub Actions token minted from a repository the attacker owns - and (2) know or correctly guess a target's owner/repo and the trust-policy identity (file) name, against an Octo STS deployment running <= 0.11.1 where the GitHub App is installed for that owner. The flaw is triggered via the Exchange RPC: in vulnerable versions the installation and app_pattern/app pin were resolved, and TrustPolicy.CheckToken's patterns were interpolated into PermissionDenied errors, before the token was validated, so the config leaks on mismatch. LIMITING FACTORS: the attacker must already know/guess the owner/repo and identity name (not discoverable from the flaw itself); only configuration text is disclosed, with no ability to mint tokens or bypass policy; self-hosted deployments have no workaround other than upgrading to 0.11.2, while the hosted service is protected once the fix is deployed. |
| Impact | This is a genuine but moderate-severity information-disclosure issue (CWE-209) best characterized as 'medium real risk, not an emergency.' The vendor CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N = 5.3) is internally consistent with the mechanism: Octo STS's Exchange RPC is network-reachable and the flaw triggers deterministically (AC:L), impact is limited to confidentiality (C:L, I:N, A:N) because the advisory is explicit that no token minting or trust-policy bypass is possible. The PR:N rating deserves a caveat worth verifying with the vendor: exploitation does require the caller to present a validly signed OIDC token from some issuer - the vendor treats this as 'no privilege on the target' because any attacker can trivially mint a GitHub Actions token from a repository they own, which is a defensible but not strictly 'unauthenticated' reading. No EPSS score, CISA KEV listing, or public proof-of-concept was supplied in the intelligence; absence of those is not itself evidence of safety, but combined with the this_month (not act_now/emergency) priority label and the confidentiality-only impact, there is no signal of active exploitation. The practical risk is bounded by the attacker needing to know or guess a valid target owner/repo plus identity name, and the payoff is reconnaissance (leaked internal repo/branch/environment/cloud-account identifiers from private trust policies), not direct compromise - a useful stepping stone for a targeted attacker rather than a mass-exploitable flaw. |
| Exploit ScenarioDerived | An attacker obtains a GitHub Actions OIDC token from a repository they control and sends it to a target organization's Octo STS Exchange endpoint, guessing a plausible owner/repo and identity name. Because the installation and app pin were resolved before the token was checked, the returned PermissionDenied error echoes back the trust policy's issuer/subject/audience patterns and claim regexes, revealing internal repository, branch, environment, or cloud-account identifiers even when the policy lives in a private repo. No public exploit identified at time of analysis; the attack is low-complexity (AC:L) and network-based (AV:N) but yields only configuration disclosure, not token issuance. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 03, 2026
Error messages returned by the Exchange RPC in Octo STS 0.11.1 and earlier disclose the contents of trust policies to callers whose OIDC token does not satisfy them. Remote, unauthenticated callers who hold any validly signed OIDC token from an accepted issuer (for example a GitHub Actions token from a repository they own) and who know or guess a target owner/repo plus identity name can read the policy's issuer, subject and audience patterns, claim_pattern regexes, and app pin details - information that frequently names internal repositories, branches, environments or cloud account identifiers, even when the policy lives in a private repository. The flaw is confidentiality-only: no token minting or trust-policy bypass is possible; the vendor issued a fix in v0.11.2 (commit 88c6432), and no public exploit was identified at time of analysis.
RemediationAI
Upgrade Octo STS to v0.11.2 (https://github.com/octo-sts/app/releases/tag/v0.11.2), which contains commit 88c6432adc4f497ec69b574e1ce162a564a9e71a and is documented in GHSA-h5p6-j8m9-xx4p (https://github.com/octo-sts/app/security/advisories/GHSA-h5p6-j8m9-xx4p); after the fix, token mismatches return only a generic 'token does not match trust policy' while the detailed reason is written to logs and the operator audit event, and unreadable or uncompilable policies return NotFound like a missing policy. The vendor states there are no workarounds for self-hosted deployments other than upgrading, and that users of the hosted service are protected once the fix is deployed, so self-hosted operators should treat the upgrade as the only complete remediation. Because the leak is triggered through the Exchange RPC, reducing which clients can reach that endpoint limits who can exercise the disclosure while an upgrade is staged, at the cost of blocking legitimate token-exchange callers from those network paths. Note that v0.11.2 deliberately preserves the ability to distinguish PermissionDenied from NotFound, so callers can still learn whether a given identity file exists where the App is installed; treat existence of policy identity names as non-secret in your threat model.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Octo STS is a Go service that exchanges an inbound OIDC token for a GitHub App installation token, driven by trust policies stored as identity files in repositories (addressed by owner/repo and identity name) and evaluated by TrustPolicy.CheckToken in pkg/octosts/trust_policy.go over a gRPC/protobuf Exchange interface. The root cause is CWE-209 (generation of error message containing sensitive information) on two paths: CheckToken interpolated the policy's issuer/issuer_pattern, subject/subject_pattern, audience/audience_pattern and claim_pattern names and regular expressions into its PermissionDenied errors, which Exchange returned verbatim to the caller; and lookupInstallAndTrustPolicy selected the exchange installation and resolved the app/app_pattern pin before the token was checked, so resolution errors such as 'trust policy app "..." is not a configured app' also reached untrusted callers. The v0.11.2 commit restructures the flow so an authorize callback validates the token immediately after the policy is loaded and before any policy-derived work, logs the detailed reason and records it on the operator audit event, and returns only a generic 'token does not match trust policy' to the caller; policies that exist but cannot be read, parsed or compiled now return the same NotFound response as a missing policy. The vendor notes a residual, intentional signal: an unauthorized caller can still distinguish PermissionDenied (usable policy) from NotFound (absent or unusable policy), revealing whether an identity file exists where the App is installed.
Know when App gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N
Network-reachable Exchange RPC triggered deterministically (AV:N/AC:L); PR:N accepted since a valid OIDC token is trivially self-minted; only policy config leaks, so C:L with I:N/A:N.
Primary rating from Vendor (chainguard).
CVSS VectorVendor: chainguard
DescriptionCVE.org
Octo STS (github.com/octo-sts/app) before 0.11.2 returns trust policy configuration to callers whose OIDC token does not satisfy that policy. TrustPolicy.CheckToken included the policy's issuer, subject and audience values or patterns and claim_pattern names and regular expressions in its PermissionDenied errors, which Exchange returned verbatim. Exchange also selected the GitHub App installation before checking the token, so errors from resolving the policy's app or app_pattern pin were returned to callers the policy does not trust. An attacker who holds any validly signed OIDC token, such as a GitHub Actions token from a repository they own, and who knows or guesses a target owner/repo and identity name can read that policy's matching rules, even when the policy is stored in a private repository. These rules often name internal repositories, branches, environments or cloud account identifiers. The issue does not allow minting tokens or bypassing a trust policy. This issue is fixed in 0.11.2.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
The App::cpanminus package through 1.7047 for Perl downloads code via insecure HTTP, enabling code execution for network
The mintToken function of a smart contract implementation for APP, an Ethereum token, has an integer overflow that allow
OS command injection in Topluyo Desktop for Linux before 2026.9.2410 lets an unauthenticated attacker who controls a URL
Off-origin preview framing in TinaCMS (tinacms <= 3.13.0 and @tinacms/app <= 2.5.13) lets an unauthenticated attacker wh
The App::Context module 0.01 through 0.968 for Perl does not properly use the Storable::thaw function, which allows remo
octokit/webhooks is a GitHub webhook events toolset for Node.js. Rated high severity (CVSS 7.5), this vulnerability is r
EUVD-2026-115653
NVD
CVE.org
EPSS
GitHub
VulDB
Exploit-DB