Skip to main content

Eclipse KeyPont gose CVE-2026-89314

| EUVDEUVD-2026-108646 MEDIUM
Inefficient Algorithmic Complexity (CWE-407)
2026-10-23 eclipse
6.9
CVSS 4.0 · Vendor: eclipse
View

Attack ChainAIDerived

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

  1. Access
    Influence or control victim's configured JWKS endpoint
  2. Delivery
    Serve sub-1 MB JWKS with ~100k distinct key_ops
  3. Exploit
    Trigger O(n²) duplicate check on unmarshal
  4. Execution
    Pin one CPU core ~15s per request
  5. Impact
    Repeat to sustain CPU-exhaustion DoS

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V2 - Validation and Business Logic Algorithmic complexity limits
Exploitation Conditions

Exploitation requires that the gose consumer parse a JWK/JWKS document originating from an attacker-controlled or attacker-influenced source, because CheckConsistency runs on every JWK and JWKS unmarshal. Concretely, the attacker must be the operator of (or a TLS-terminating MITM against) the configured JWKS endpoint, or the application must accept a JWKS/discovery URL as user input, or the discovery URL must be misconfigured to point at an untrusted host. The malicious payload is a single JWKS body under 1 MB containing roughly 100,000 distinct (non-duplicate, so no early loop exit) key_ops values on one key. LIMITING FACTORS: the advisory states this is NOT remotely triggerable against a correctly configured deployment that points at a trusted identity provider, so a deployment pinned to a trusted IdP is not exposed; a response-body size cap is only a partial mitigation because the quadratic factor makes even small bodies disproportionately expensive. No authentication of the attacker and no user interaction are required once the victim fetches from the hostile endpoint.

Impact

This is a genuine but modest-severity algorithmic-complexity DoS (CWE-407), and the signals are internally consistent rather than conflicting. The input CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L) scores 6.9 and treats the flaw as remotely and trivially reachable with only low availability impact, but the vendor advisory materially qualifies that attack vector: it states the bug 'is not remotely triggerable against a correctly configured deployment pointing at a trusted identity provider' and is only reachable when the consumer fetches a JWKS from an attacker-controlled or attacker-influenced endpoint (malicious/compromised IdP, misconfigured discovery URL, or an application that accepts a JWKS URL as user input). So the AC:L/AT:N encoding overstates real-world reachability - the true precondition is control or MITM of the configured JWKS source, which is a non-default trust condition. No CISA KEV listing and no EPSS score are present in the input, and no active exploitation is claimed; the only exploitation signal is the GHSA advisory itself, which ships a runnable reproducer. The vuln.today decision label is 'this_month' (not act_now/emergency), matching the Low vendor severity. Net: a real, confirmed, patch-worthy issue but a lower-priority one - the impact is a single CPU core pinned for ~15 s per sub-1 MB request, availability-only, gated behind a trust-boundary precondition that correctly-configured deployments do not meet. Note the input Tags label this 'Information Disclosure,' which directly contradicts the advisory's explicit 'No confidentiality or integrity impact' - treat that tag as erroneous.

Exploit ScenarioDerived

An application using eclipse-keypont/gose (or the deprecated ThalesGroup/gose) is configured - or tricked via a user-supplied or misconfigured discovery URL - to fetch a JWKS from an endpoint the attacker controls or can MITM. The attacker serves a sub-1 MB JWKS whose key contains tens of thousands of distinct, junk key_ops values; the quadratic duplicate-check in jwkFields.CheckConsistency runs to completion and pins one CPU core for roughly 15 seconds per parse. A public proof-of-concept reproducer demonstrating the quadratic timing is published in the GHSA advisory.

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 – Oct 23, 2026

CPU exhaustion in the Go JOSE library Eclipse KeyPont gose (formerly github.com/ThalesGroup/gose) allows a hostile JWK/JWKS document to pin one CPU core for roughly 15 seconds, because the duplicate key_ops validation in jwkFields.CheckConsistency runs an all-pairs nested loop whose cost grows with the square of the entry count (CWE-407). Because that check executes on every JWK and JWKS unmarshal, any consumer that parses a JWKS body from an attacker-controlled or attacker-influenced source - a compromised or malicious identity provider, a misconfigured discovery URL, or an application that accepts a JWKS URL as user input - is exposed; the authoritative assessment rates the impact as availability-only (CVSS:3.1 AV:N/AC:H, no confidentiality or integrity effect), with the higher AC reflecting the precondition that the victim must actually fetch from the hostile endpoint rather than any attacker-uncontrolled timing condition, and notes a trusted, pinned IdP deployment is not triggerable. All releases since the earliest tag are affected on the ThalesGroup module path (>= 0.7.3, <= 0.13.0-rc1, which is deprecated and unpatched) and on the Eclipse path (< 1.0.0-rc4), with the fix first shipped in v1.0.0-rc4; there is no CISA KEV listing and no public exploit identified at time of analysis.

RemediationAI

Vendor-released patch: v1.0.0-rc4 (or later) of github.com/eclipse-keypont/gose, which replaces the quadratic comparison with a set-based linear check and adds a maxKeyOps = 64 bound so oversized key_ops arrays are rejected with ErrTooManyKeyOps before any expensive work occurs; the same release also caps the JWKS HTTP response body at 1 MiB via io.LimitReader. Consumers still importing github.com/ThalesGroup/gose must change the module path, not merely bump the version, because that path terminates at v0.13.0-rc1, remains vulnerable, and carries a deprecation directive - go get -u will not remediate it; the required change is from github.com/ThalesGroup/gose v0.13.0-rc1 to github.com/eclipse-keypont/gose v1.0.0-rc4. Be aware of the deliberate behaviour change: a JWKS carrying more than 64 operations on a single key will now be rejected, which the vendor considers generous relative to RFC 7517 §4.3's eight defined operations. Where upgrading is not immediately possible, the advisory's workarounds are to fetch JWKS documents only from trusted, pinned endpoints and to impose a response-body size limit before handing bytes to gose, with the explicit caveat that a size limit alone is a partial mitigation because the quadratic factor makes even a small body disproportionately expensive. Per the authoritative assessment, deployments pinned to a trusted identity provider are not remotely triggerable, whereas applications that accept a JWKS or discovery URL as user input, or that point at a misconfigured untrusted host, remain exposed.

Affected VersionsENISA

Eclipse KeyPont - GOSE 0 <1.0.0-rc4
Eclipse KeyPont - GOSE 0.7.3 ≤0.13.0-rc1

Affected Packages

euvd eclipse_keypont_gose fix: 1.0.0-rc4

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

gose implements JWK/JWKS handling in Go for RFC 7517 documents. The key_ops field is decoded into a []KeyOps (a []string newtype) on jwkFields, and CheckConsistency is invoked unconditionally at the tail of every concrete UnmarshalJSON implementation, reached from UnmarshalJwk and therefore from Jwks.UnmarshalJSON for every element of the keys array. The vulnerable check compared every key_ops entry against every later entry in a pairwise nested loop with no early exit when all values are distinct, so a document carrying N unique operations costs O(N²) comparisons; the advisory's measurements show 6.4 ms at n=2000, 125 ms at n=8000 and 1.56 s at n=32000 (about 320 KB), extrapolating to roughly 15 seconds for a sub-1 MB body. A compounding defect is that the values were never validated, only compared, so tens of thousands of junk entries that are not well-formed per RFC 7517 §4.3 were accepted and the expensive path ran to completion. The root cause class is CWE-407 (inefficient algorithmic complexity), which is why a byte-size cap is only a partial control: the quadratic factor makes even small bodies disproportionately expensive. The upstream fix (commit be2277b, merged as 692c25c) replaces the loop with a map-based linear duplicate check and, more importantly, introduces a hard bound maxKeyOps = 64 that rejects oversized key_ops arrays with ErrTooManyKeyOps before the expensive path is entered; the same release also wraps the JWKS HTTP response body in an io.LimitReader capped at 1 MiB. CPE data (eclipse_foundation:eclipse_keypont_-_gose with wildcard versions) confirms the affected product family without narrowing a version range.

Know when Eclipse Keypont Gose 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 (eclipse) PRIMARY 6.9 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
vuln.today AI 3.7 LOW

AV:N since the JWKS is fetched over HTTP, but AC:H because exploitation requires the victim to fetch from an attacker-controlled/influenced endpoint (non-default trust condition); availability-only, transient CPU exhaustion gives A:L with C:N/I:N.

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

Primary rating from Vendor (eclipse).

CVSS VectorVendor: eclipse

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

1
Patch available
Oct 23, 2026 - 10:01 EUVD

DescriptionCVE.org

jwkFields.CheckConsistency detected duplicate key_ops entries with a pairwise nested loop, making validation cost grow with the square of the entry count. Because the check runs on every JWK and JWKS unmarshal, a modestly sized but hostile JWKS document could occupy a CPU core for many seconds.

Threat Intelligence Overview

EPSS Score
0.3%
Top 84% exploitable
Prevalence
Low
niche Go JOSE/JWK library, limited production deployment footprint
Social Media
1
Sightings
Data Quality
5 sources
Confidence: Medium

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

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

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

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