Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessOpen unauthenticated session on shared token
-
DeliveryPlant ML-KEM public key under victim's CKA_ID/CKA_LABEL
-
ExploitVictim lookup binds attacker's unverified public key
-
ExecutionEncapsulate encrypts shared secret to attacker's key
-
ImpactAttacker decapsulates to recover secret and derived keys
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V15 - Secure Coding and Architecture Data authenticity verification
|
| Exploitation Conditions | Exploitation requires two concrete preconditions tied to the PKCS#11 token model. First, the attacker must be able to open a session on the same token the victim uses and create a public object on it - the advisory states this can be an unauthenticated (public) session, so no login to the token is needed, but local/same-host reach to the token is (AV:L). Second, the victim application must use the affected lookup functions (FindMLKEMKeyPair, FindMLKEMKeyPairs, FindMLKEMKeyPairsWithAttributes) and then Encapsulate on a vulnerable version (2.0.0-rc3 through 2.0.0-rc8). A second, misconfiguration-driven path needs no planted object: if an ML-KEM private key has a CKA_LABEL but no CKA_ID and no public half with that label (deleted, renamed, or made by another tool), the 'ID only' fallback matches every ML-KEM public key and silently returns the first one the token lists. Limiting factors: attack is local to the token, confined to applications invoking the ML-KEM code path, and the v1 module paths have no ML-KEM support and are unaffected; giving ML-KEM keys a unique CKA_ID and looking them up by ID, and restricting who may open sessions on the token, constrain exploitation (per the advisory's stated workarounds). |
| Impact | All signals point to a moderate, conditional risk rather than an urgent one. The CVSS vector (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N, base 5.5) is internally consistent with the mechanism: AV:L reflects that the attacker must act against a token/HSM they can reach, PR:L reflects that they must be able to open a session on that token, and C:H/I:N/A:N matches an attack that recovers ML-KEM shared secrets (confidentiality) without tampering or denial of service. The vuln.today Decision label is 'this_month' - a prioritized-but-not-emergency signal consistent with the local attack vector and single-impact dimension. No EPSS score, no CISA KEV entry, and no SSVC automatable/exploitation fields were supplied; absence of these is not evidence either way, but there is no signal of active or widespread exploitation. The GHSA advisory includes a PoC section describing reproduction on SoftHSMv2 and SoftHSMv3, so a public PoC reference exists; it is not verified as working, distributable exploit code and must not be conflated with active exploitation. Net: this is a genuine cryptographic confidentiality flaw worth patching on a normal cadence, not a high-CVSS-but-illusory issue, but its real-world reach is bounded by the requirements that the attacker share access to the token and that the application use the affected ML-KEM lookup functions on a vulnerable release-candidate version. |
| Exploit ScenarioDerived | On a shared PKCS#11 token, an attacker opens an unauthenticated (public) session and creates a CKK_ML_KEM public key object carrying the victim's CKA_ID/CKA_LABEL but containing the attacker's own encapsulation key. When the victim application calls FindMLKEMKeyPair*/Encapsulate, the lookup binds the attacker's public key (it is never verified against the private key), so the fresh shared secret is encrypted to the attacker, who then decapsulates and recovers it along with anything derived from it (e.g. via MLKEMDeriveKey). A public PoC reference describing this on SoftHSMv2/v3 exists; it is not verified as working exploit code. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
ML-KEM key-pair lookups in Eclipse KeyPont crypto11 v2 (2.0.0-rc3 through 2.0.0-rc8) bind a public key to a private key without verifying that the two actually belong together, so Encapsulate() can encrypt a fresh shared secret to a public key whose owner is not the holder of the private key the caller looked up, letting that third party recover the secret. Two paths lead there: an attacker able to open a session on the same PKCS#11 token can plant a CKK_ML_KEM public object carrying the victim's CKA_ID/CKA_LABEL, or, when an ML-KEM private key has a label but no CKA_ID and no matching public object, an 'ID only' fallback search degrades to a class-and-type template and silently returns whichever ML-KEM public key the token lists first. The advisory documents a reproduction on SoftHSMv2 and SoftHSMv3; the issue is not listed in CISA KEV, the CVSS vector is local, low-privilege (AV:L/PR:L) with high confidentiality impact, and v1 module paths are unaffected because they have no ML-KEM support. Overall the risk is moderate and conditional: it requires a shared token, an application invoking the ML-KEM lookup and encapsulation path, and either a planting-capable session or a label-only key layout.
RemediationAI
Vendor-released patch: upgrade to v2.0.0-rc9 with go get github.com/eclipse-keypont/crypto11/v2@v2.0.0-rc9, which is the fix delivered by PR https://github.com/eclipse-keypont/crypto11/pull/172 (commit 8d99b73c721c173ad85c0ca4e063c3da360a611d, release https://github.com/eclipse-keypont/crypto11/releases/tag/v2.0.0-rc9); the advisory is at https://github.com/eclipse-keypont/crypto11/security/advisories/GHSA-7842-qc22-qh4x. In rc9 the ID-only search runs only when the private key has a CKA_ID, and a public candidate is used only after it is verified against the private key via CKA_PUBLIC_KEY_INFO or an encapsulate/decapsulate round trip (candidates from a different parameter set are skipped; if no candidate verifies, the key pair is not returned). rc9 also requires pkcs11-go v1.2.0-rc4, which fixes a separate heap over-read in C_EncapsulateKey output handling (GHSA-mwv2-h526-7gq6), so do not pin the older binding. Be aware of the accompanying behavior change: Encapsulate and Decapsulate now set CKA_SENSITIVE=true, CKA_EXTRACTABLE=false and CKA_PRIVATE on the shared-secret template instead of taking token defaults, so callers that read the secret via Bytes() must explicitly request CKA_SENSITIVE=false and CKA_EXTRACTABLE=true or they will break. If upgrading is not immediately possible, the advisory's workarounds are: always give ML-KEM keys a unique CKA_ID and look them up by ID (which avoids the label-only fallback path but does not stop a planted object from matching that ID); after every FindMLKEMKeyPair* call, run a self-test by encapsulating with an extractable session-object template, decapsulating the ciphertext with the same pair, comparing the two Bytes() values and deleting both objects (costs an extra encapsulate/decapsulate per lookup and temporarily materializes a secret on the host); and restrict which principals may open sessions on the token, including unauthenticated public sessions, which is the only control that addresses the planting vector directly but requires token-level access policy changes outside the library.
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
The flaw lives in the ML-KEM support of crypto11, a Go wrapper around PKCS#11 (Cryptoki) v3.2 tokens, where ML-KEM (FIPS 203) key establishment is exposed through C_EncapsulateKey / C_DecapsulateKey. A PKCS#11 key pair is two distinct token objects joined only by convention: applications locate the public half with C_FindObjects using attributes such as CKA_ID and CKA_LABEL, and the token does not enforce any link to the private half. CWE-345 (insufficient verification of data authenticity) is the root cause here: makeMLKEMKeyPair in mlkem.go accepts the first matching public CKO_PUBLIC_KEY / CKK_ML_KEM object it finds, both after the ID/label search (mlkem.go:274) and after the 'ID only' retry (mlkem.go:288-297), which runs even when the private key has no CKA_ID at all. Because findKeys drops empty IDs and nil labels from the template, that retry collapses to CKA_CLASS=CKO_PUBLIC_KEY plus CKA_KEY_TYPE=CKK_ML_KEM, and handles[0] from the token's C_FindObjects ordering wins. Encapsulate() then encrypts the fresh shared secret to that candidate's encapsulation key; FIPS 203 §6.3 implicit rejection means a Decapsulate() with the victim's private key returns a different, unrelated secret rather than an error, so the substitution is silent. The same class of bug was already fixed for the generic getKeyPair path in PR #144 ('Keys are what they say they are'), but the fix was never carried into the ML-KEM code path. Note that the trigger specifics - which candidate the token returns - depend on C_FindObjects ordering and on the token implementation, as demonstrated on SoftHSMv2 and SoftHSMv3.
Know when Eclipse Keypont 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:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N
Attacker needs session access to the token (PR:L) and local reach to it (AV:L); the flaw leaks ML-KEM shared secrets (C:H) without integrity or availability impact.
Primary rating from Vendor (eclipse).
CVSS VectorVendor: eclipse
DescriptionCVE.org
In github.com/eclipse-keypont/crypto11/v2 versions >= 2.0.0-rc3, <= 2.0.0-rc8, the ML-KEM key-pair lookup functions (FindMLKEMKeyPair, FindMLKEMKeyPairs, FindMLKEMKeyPairsWithAttributes) locate the public half of an ML-KEM key pair by CKA_ID/CKA_LABEL and never verify it against the private key. In addition, the "ID only" fallback search runs even when the private key has no CKA_ID, so the search template reduces to the public-key class and the ML-KEM key type and the first ML-KEM public key on the token is returned. Encapsulate() on the resulting key pair encrypts the fresh shared secret to that key, so its owner - not the holder of the private key the caller looked up - can recover the secret. An attacker who can open an unauthenticated session on the token and plant a public CKK_ML_KEM object carrying the victim's CKA_ID/CKA_LABEL receives the shared secrets for encapsulations performed through the substituted key pair, compromising the confidentiality of those secrets and of everything protected by keys derived from them. The v1 module paths have no ML-KEM support and are not affected.
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.
EUVD-2026-110816
GHSA-922w-gjph-r2q7
NVD
CVE.org
EPSS
Exploit-DB