Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify service decrypting ECDH-ES JWE with long-term X25519 key
-
DeliverySubmit crafted ciphertexts with fixed ephemeral point
-
ExploitReach pure-Erlang Curve25519 ladder during decryption
-
ExecutionMeasure secret-correlated decryption timing
-
ImpactRecover long-term X25519 private key
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V6 - Authentication Timing attack prevention
|
| Exploitation Conditions | Exploitation requires that the pure-Erlang Curve25519 fallback is the code path actually used - i.e. crypto_fallback is enabled (jose:crypto_fallback(true)/JOSE.crypto_fallback(true) or curve25519_module set to :jose_jwa_curve25519) or no constant-time native X25519 provider (OTP crypto, libdecaf, or libsodium) is available; releases up to 1.11.12 shipped crypto_fallback=true in the jose application environment, so the vulnerable path could be selected even though the README documented fallback as disabled. It further requires that the service performs X25519 scalar multiplication with a reused long-term private key in a timing-observable context, most concretely a service that decrypts attacker-supplied ECDH-ES JWE messages via JOSE.JWK.box_decrypt_ecdh_es/2. Limiting factors: no authentication is needed to submit ciphertexts, but the attacker must obtain large numbers of high-precision, low-noise timing measurements (the PoC uses warmup, 400-sample medians, and interleaved rounds to beat scheduler/JIT noise), reflected in AC:H and AT:P; deployments using a native constant-time provider with crypto_fallback=false (the default from 1.11.13) are not exposed. |
| Impact | This is a genuine but conditional, low-urgency cryptographic weakness rather than a mass-exploitation threat, and the signals are consistent with that reading. The CVSS 4.0 base score is 5.9 (medium) with AC:H and AT:P, reflecting that practical exploitation requires many high-precision, low-noise timing samples against an operation-count-balanced 254-step ladder - a high bar. EPSS is 0.14% (3rd percentile), i.e. very low predicted exploitation, and the vulnerability is not in CISA KEV, so there is no evidence of active exploitation; this aligns with the vendor's 'medium' rating and the vuln.today 'this_month' decision label (a scheduled-remediation priority, not emergency/act_now). The GHSA advisory ships a PoC, but it demonstrates that decryption time is a stable function of the private scalar - not an end-to-end key-recovery exploit - so POC-availability should not be conflated with practical key recovery or active exploitation. Note a vector/mechanism tension: the vendor scored AV:L, yet the described and most dangerous scenario is a network-reachable service decrypting attacker-submitted ECDH-ES JWE messages and leaking timing over the wire, which is naturally a network-facing attack surface; remote timing resolution is extremely noisy, which is likely why AC:H/AT:P and possibly AV:L were chosen - verify the intended attack vector with the vendor. Crucially, exploitability is gated on a non-default-documented code path (pure-Erlang Curve25519 fallback), which materially lowers real-world risk below what the C:H impact alone would suggest. |
| Exploit ScenarioDerived | An Erlang/Elixir service holding a long-term X25519 key decrypts attacker-supplied ECDH-ES (JWE) messages via JOSE.JWK.box_decrypt_ecdh_es/2, which reaches the pure-Erlang jose_jwa_x25519 Montgomery ladder. The attacker repeatedly submits ciphertexts (e.g. reusing a fixed ephemeral point) and measures decryption response time, and because the ladder's bignum arithmetic is value-dependent on the secret scalar, the timing leaks the key bit by bit. A vendor-published PoC demonstrates the secret-correlated timing delta but is not verified as a working end-to-end key-recovery exploit, and the high complexity (AC:H) plus attack requirements (AT:P) make precise measurement the limiting factor. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
Recovery of a long-term X25519 private key is possible in erlang-jose 1.10.0 through 1.11.12 whenever the pure-Erlang Curve25519 fallback is the code path actually in use, because scalar multiplication there runs in secret-dependent time and lets an attacker who can submit ECDH-ES JWE ciphertexts and measure decryption timing reconstruct the private scalar bit by bit. The assessed impact is confidentiality-only (CVSS:3.1 AV:N/AC:H/PR:N/UI:N/C:H/I:N/A:N) and depends on a service that reuses a fixed X25519 key being reachable by an attacker able to collect large numbers of low-noise timing samples, so this is a conditional cryptographic weakness rather than an opportunistic mass-exploitation issue. A public PoC reference exists in the vendor advisory - a demonstration script that forces crypto_fallback and shows a stable timing delta between two victims differing only in their private scalar - but it is not verified as working key-recovery exploit code; there is no CISA KEV listing and EPSS is 0.14% (3rd percentile).
RemediationAI
Upgrade erlang-jose to 1.11.13, which ships crypto_fallback set to false and documents the pure-Erlang Curve25519/Curve448 modules as variable-time; the patch commit is 3670f873c274bba86fb7f5ee5727a7efa1322b79 and the advisory is https://github.com/potatosalad/erlang-jose/security/advisories/GHSA-xvr2-gggj-h2pp. Where an upgrade cannot be done immediately, disable the fallback on the running release by setting crypto_fallback to false in the jose application environment or calling jose:crypto_fallback(false) / JOSE.crypto_fallback(false) at startup, and confirm that jose:crypto_fallback() returns false; the trade-off is that operations without a native provider for a given curve (for example Curve448 on older OTP releases) will fail rather than silently use the Erlang implementation, so verify provider coverage for every curve you actually use. Confirm that X25519 scalar multiplication is served by a constant-time native provider - OTP crypto with X25519 support, or a libdecaf/libsodium NIF - and avoid pinning curve25519_module to :jose_jwa_curve25519. Note that 1.11.13 does not make the Erlang fallback constant-time; explicitly re-enabling crypto_fallback still exposes this timing channel, so the pure-Erlang modules must not handle long-lived private keys anywhere an attacker can observe timing, as in ECDH-ES JWE decryption services using a reused X25519 key. Because exploitation requires sustained high-precision timing measurement (assessed AC:H/AT:P), the priority is to eliminate the fallback configuration first and schedule the version bump in the current monthly patch cycle rather than treating it as an emergency.
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 is CWE-208 (Observable Timing Discrepancy) in the pure-Erlang Curve25519 implementation shipped as src/jwa/jose_jwa_x25519.erl in potatosalad's erlang-jose library (CPE cpe:2.3:a:potatosalad:jose). curve25519/2 drives a recursive Montgomery ladder whose clauses branch on individual bits of the clamped private scalar (the F(M) when (M band 1) =:= 1 clause versus the fallthrough), and the per-step primitives montgomery_add/3 and montgomery_double/1 plus the field inversion (implemented via modular exponentiation) are built from Erlang bignum multiplication, rem and expmod, whose running time depends on operand magnitude. The ladder is operation-count balanced and fixed at 254 steps, so the coarse skipped-operation leak is absent, but operation-count balancing does not make value-dependent bignum arithmetic constant-time, and the concrete integers flowing through each step still track the secret. The result is that the public entry points scalarmult/2, x25519/2, x25519_base/1 and sk_to_pk/1 all execute in time that is a function of the private key. The path is reachable from the public API: JOSE.JWK.box_decrypt_ecdh_es/2 reaches jose_jwa_curve25519:x25519_shared_secret/2 and hence the ladder, which is why a service decrypting attacker-supplied ECDH-ES JWE messages with a long-lived X25519 key is the concrete exposure scenario. Pure Erlang integer arithmetic cannot be made constant-time, so the vendor's fix is architectural: route private-key scalar multiplication through a constant-time native provider (libsodium/libdecaf NIF, or OTP crypto x25519 via crypto:generate_key/compute_key) and stop selecting the Erlang fallback by default.
Know when Jose 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:L/AC:H/AT:P/PR:N/UI:N/VC:H/VI:N/VA:N/SC:N/SI:N/SA:N
Reachable without auth via network-submitted ECDH-ES ciphertexts (AV:N/PR:N), but needs many precise low-noise timing samples (AC:H); impact is disclosure of the private key (C:H), no direct integrity/availability loss.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Observable Timing Discrepancy vulnerability in potatosalad jose allows recovery of a long-term X25519 private key through a timing side channel in the pure-Erlang Curve25519 fallback.
The pure-Erlang X25519 implementation performs scalar multiplication over the secret private key using a recursive Montgomery ladder (jose_jwa_x25519:curve25519/2) whose clauses branch on individual bits of the clamped private scalar, and whose per-step operations (jose_jwa_x25519:montgomery_add/3 and jose_jwa_x25519:montgomery_double/1) and field inversion are built from value-dependent Erlang bignum arithmetic (multiplication, remainder, and modular exponentiation). Although the ladder is operation-count balanced and fixed at 254 steps, the concrete integer values processed at each step, and therefore the running time, depend on the secret scalar. The execution time of the public entry points jose_jwa_x25519:scalarmult/2, jose_jwa_x25519:x25519/2, jose_jwa_x25519:x25519_base/1, and jose_jwa_x25519:sk_to_pk/1 is thus a function of the private key.
This path is reachable from the public API, most notably when a service decrypts attacker-supplied ECDH-ES (JWE) messages with a long-term X25519 key (for example through JOSE.JWK.box_decrypt_ecdh_es/2, which reaches jose_jwa_curve25519:x25519_shared_secret/2 and the ladder). An attacker who can submit ciphertexts and measure decryption timing can, in principle, recover the private key bit by bit, defeating the resistance X25519 was designed to provide. Recovery of the key compromises the confidentiality and authenticity of all data protected by it.
This issue affects jose: from 1.10.0 before 1.11.13.
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.
JOSE is "JSON Web Almost Everything" - JWA, JWS, JWE, JWT, JWK, JWKS with no dependencies using runtime's native crypto
Signature verification bypass in the OCaml jose library (ulrikstrid/ocaml-jose) before 0.11.0 lets attackers forge valid
JWT token forgery in appsup-dart/jose library (versions prior to 0.3.5+1) enables remote attackers to bypass authenticat
Password-protected private-key exports produced by the Erlang/Elixir `jose` library between 1.10.0 and 1.11.12 are encry
Memory-exhaustion denial of service in the erlang-jose JOSE/JWE library for Erlang and Elixir (versions 1.0.0 through 1.
CPU-exhaustion denial of service in the erlang-jose library (versions 1.7.7 through 1.11.12) lets remote attackers who c
jose is an npm library providing a number of cryptographic operations. Rated medium severity (CVSS 5.9), this vulnerabil
The Erlang/Elixir JOSE library (potatosalad/erlang-jose) can be driven into an unbounded tail-recursive loop through JOS
Authentication-tag forgery in the Erlang JOSE library (jose 1.2.0 through 1.11.12) lets an unauthenticated remote attack
Bleichenbacher padding-oracle weakness in erlang-jose's pure-Erlang RSAES-PKCS1-v1_5 decryption (jose 1.3.0 through befo
jose is JavaScript module for JSON Object Signing and Encryption, providing support for JSON Web Tokens (JWT), JSON Web
ECDSA JWS signature malleability in erlang-jose (potatosalad:jose) 1.0.0 through 1.11.12 lets anyone holding a single le
EUVD-2026-110311
NVD
CVE.org
EPSS
GitHub
Exploit-DB