Skip to main content

Octo STS EUVDEUVD-2026-115653

| CVE-2026-105770 MEDIUM
Error Message Information Leak (CWE-209)
2026-11-03 chainguard
5.3
CVSS 3.1 · Vendor: chainguard
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Obtain any validly signed OIDC token
  2. Exploit
    Call Exchange with guessed owner/repo and identity
  3. Impact
    Read 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

App 0 <0.11.2

Affected Packages

euvd app fix: 0.11.2

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

Vendor (chainguard) PRIMARY 5.3 MEDIUM
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N
vuln.today AI 5.3 MEDIUM

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (chainguard).

CVSS VectorVendor: chainguard

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
Low
Integrity
None
Availability
None

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

EPSS Score
0.3%
Top 83% exploitable
Prevalence
Low
niche open-source GitHub OIDC trust broker by Chainguard
Social Media
1
Sightings
Data Quality
6 sources
Confidence: High

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact· derived
Medium

Priority Score

26
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +26
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy