Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessInfluence or control victim's configured JWKS endpoint
-
DeliveryServe sub-1 MB JWKS with ~100k distinct key_ops
-
ExploitTrigger O(n²) duplicate check on unmarshal
-
ExecutionPin one CPU core ~15s per request
-
ImpactRepeat 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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
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
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
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.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
Lifecycle Timeline
1DescriptionCVE.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
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
More in Eclipse Keypont Gose
View allThe AES-CBC-with-HMAC JWE path in Eclipse KeyPont gose (published as github.com/ThalesGroup/gose v0.9.0 through v0.13.0-
Denial of service in Eclipse KeyPont's `gose` JOSE/JWT Go library: `JwtClaims.MarshalJSON` builds a runtime struct with
Denial of service in the Eclipse Keypont gose Go JWE library (published historically as github.com/ThalesGroup/gose) whe
Eclipse KeyPont GoSE's JWE decryptor panics instead of returning an error when a compact JWE carries an incorrectly size
Denial of service in Eclipse KeyPont Gose affects the AES-CBC-HMAC direct decryption path (NewJweDirectDecryptorBlock) i
Denial of service in Eclipse KeyPont gose occurs when a JWK declares kty EC with a non-EC alg and is passed directly to
JwksTrustStore.Get in the Eclipse KeyPont gose JOSE library (formerly github.com/ThalesGroup/gose) can return the last k
Eclipse KeyPont gose (formerly github.com/ThalesGroup/gose) fails to enforce the JWS `crit` header: any token carrying a
EUVD-2026-108646
NVD
CVE.org
EPSS
GitHub
Exploit-DB