Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessControl an allowlisted Jenkins OIDC issuer
-
DeliveryServe discovery doc with malicious jwks_uri
-
ExploitSend unauthenticated POST /v1/upload/sbom
-
ExecutionPIA fetches attacker-chosen internal URL
-
ImpactProbe internal hosts and services
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V4 - API and Web Service URL allowlisting, SSRF prevention
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Credential Access 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 control the OIDC discovery document of an already-approved/allowlisted issuer - specifically a registered per-project Jenkins instance under https://ci.eclipse.org/<project>/oidc - so they can set jwks_uri to an arbitrary host:port (including plaintext http), since the code (pia/oidc.py:42-52) only checks that the field is non-empty and never parses it as a URL, compares it to the issuer origin, or requires HTTPS. The triggering request (POST /v1/upload/sbom) is itself unauthenticated and needs no user interaction, but the primitive is a blind GET from PIA's network position whose response is not reflected to the attacker. Key limiting factors: the attacker must be or compromise a trusted identity provider (PR:H), impact is confined to outbound GET requests usable mainly for internal reconnaissance/interaction, and no direct code execution, data read-back, or availability impact results. |
| Impact | This is a genuine but modest-severity blind SSRF (CWE-918), and the multiple signals largely agree on 'not a top priority.' The vendor-supplied CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:H/UI:N) scores 5.1 (medium), and the impact metrics are the key story: only SI:L (subsequent-system integrity Low) with VC:N/VI:N/VA:N/SC:N/SA:N, meaning no data is read back and no system is directly compromised - the attacker merely coerces PIA into issuing attacker-chosen GET requests from its network position. There is an important apparent contradiction worth flagging: the description stresses that the fetch happens via an 'unauthenticated POST /v1/upload/sbom,' which sounds like PR:N, yet the vendor assigns PR:H. These reconcile because triggering the SSRF to an ATTACKER-CONTROLLED target requires the attacker to control the OIDC discovery document of an already-allowlisted issuer (a registered per-project Jenkins instance), which is a privileged, trusted position - so PR:H is defensible and I concur with it. No EPSS score, no CISA KEV listing, and no public exploit were provided, so there is no public exploit identified at time of analysis and no evidence of active exploitation. Net: a real defense-in-depth bug in a trust-boundary-sensitive path, but low real-world urgency given the privileged precondition, blind/low impact, and tiny deployment footprint. |
| Exploit ScenarioDerived | An attacker who controls or compromises one of the per-project Jenkins instances that PIA already trusts as an OIDC issuer (e.g. https://ci.eclipse.org/<project>/oidc) publishes a discovery document whose jwks_uri points at an internal host and port - including plaintext http. They then send an unauthenticated POST /v1/upload/sbom to PIA, which follows that jwks_uri and issues the request from inside the Eclipse network before ultimately rejecting the upload with 401, giving a blind SSRF usable for internal port/service probing. No public exploit identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 20, 2026
Blind server-side request forgery in Eclipse PIA allows an approved OIDC identity provider to force PIA's token-verification flow to fetch an arbitrary host and port, including plaintext HTTP, from PIA's network position. The issue is in verify_token (pia/oidc.py), which follows jwks_uri from a trusted issuer's discovery document without parsing it as a URL, comparing it to the issuer origin, or requiring HTTPS, and the fetch is triggered by an unauthenticated POST /v1/upload/sbom that is then rejected with 401. Because the response is not reflected to the attacker, impact is limited to outbound GET reconnaissance/interaction; exploitation requires a high-privileged position controlling a registered per-project Jenkins issuer under https://ci.eclipse.org/<project>/oidc (PR:H), and no public exploit was identified at time of analysis.
RemediationAI
Patch available per vendor advisory (https://github.com/eclipse-csi/pia/security/advisories/GHSA-97mq-mw55-36px); the supplied data does not specify an exact fixed version, so the advisory should be used to identify the corrected release. Apply the vendor update that parses jwks_uri as a URL, enforces same-origin comparison with the approved issuer, and requires HTTPS before PIA performs the JWKS fetch. Until patched, restrict PIA egress to the known approved OIDC issuer origins and ports and block plaintext HTTP egress from PIA's network segment; this reduces blind SSRF reach but may break legitimate issuer or key-rotation traffic if the allowlist is incomplete. Also minimize and audit the set of registered per-project Jenkins issuers under https://ci.eclipse.org/<project>/oidc so only fully trusted identity providers are approved, and monitor PIA for unexpected outbound GETs to internal addresses; both controls reduce exposure but require ongoing issuer inventory maintenance and may add operational overhead for project onboarding.
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
Eclipse CSI PIA performs OpenID Connect token verification by retrieving an allowlisted issuer's OIDC discovery document and then using the jwks_uri field to fetch signing keys. In the affected code (pia/oidc.py:42-52), jwks_uri is accepted as long as it is non-empty: it is not parsed as a URL, not checked against the issuer's origin, and not required to use HTTPS. This is a classic server-side request forgery (CWE-918) in the OIDC/JWKS key-retrieval path. Each registered per-project Jenkins instance under https://ci.eclipse.org/<project>/oidc is treated as a separate approved issuer, so an attacker who controls or compromises one such issuer can redirect PIA to internal or arbitrary hosts and ports. The GET occurs before signature verification, as a side effect of an unauthenticated POST /v1/upload/sbom that ultimately returns 401, making the primitive a blind SSRF: PIA's response is not returned to the attacker. The CPE cpe:2.3:a:eclipse_foundation:eclipse_csi_-_pia:*:*:*:*:*:*:*:* identifies Eclipse Foundation Eclipse CSI - PIA as the affected product; assessed impact is limited to low subsequent-system integrity (SI:L) with no confidentiality or availability impact.
Know when Eclipse Csi Pia 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:H/UI:N/VC:N/VI:N/VA:N/SC:N/SI:L/SA:N
PR:H because the attacker must control an allowlisted OIDC issuer; S:C as the SSRF reaches other internal systems; C:N (blind, no response) with only I:L integrity impact on those systems.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
PIA's token verification (verify_token in pia/oidc.py) fetches the OIDC discovery document of an allowlisted issuer and then follows the jwks_uri contained in that response without parsing it as a URL, comparing it against the approved issuer's origin, or requiring HTTPS - the only check is that the field is non-empty (pia/oidc.py:42-52). An approved identity provider - and every registered per-project Jenkins instance under https://ci.eclipse.org/<project>/oidc is a separate such party (pia/models.py) - can therefore direct PIA to issue a GET request to an arbitrary host and port, including over plaintext http, from PIA's own network position. The fetch happens before any signature is verified, as a side effect of an unauthenticated POST /v1/upload/sbom request that is ultimately rejected with 401.
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
Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.
More in Eclipse Csi Pia
View allServer-side request forgery in the Eclipse CSI PIA `POST /v1/upload/sbom` endpoint lets remote attackers coerce the serv
Server-side request forgery and OIDC token forgery in Eclipse CSI PIA lets an unauthenticated attacker abuse a flawed Je
Log injection in Eclipse CSI PIA's unauthenticated /v1/upload/sbom endpoint allows a remote attacker to plant forged aut
Eclipse CSI PIA executes its pre-authentication OIDC discovery and JWKS fetch operations synchronously directly on the a
EUVD-2026-104909
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB