Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain one valid ECDSA JWS token
-
DeliveryPrepend leading zero bytes to R and S halves
-
ExploitSubmit re-encoded token to jose verifier
-
Executionverify/4 strips zeros and accepts signature
-
ImpactBypass replay/revocation/dedup uniqueness control
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A04:2025 - Cryptographic Failures
ASVS 5.0
V11 - Cryptography Signature verification
|
| Exploitation Conditions | The attacker must possess one valid ECDSA-signed JWS compact token (ES256, ES256K, ES384, or ES512) legitimately issued by the target - no private key, no payload forging, and no special configuration are needed. The affected feature is ECDSA JWS verification via jose_jwk_kty_ec:verify/4 (public API JOSE.JWS.verify) in jose 1.0.0 through 1.11.12. Exploitation only has security value when the application relies on signature-byte or whole-token uniqueness for a security decision - token-revocation-by-hash, replay/idempotency caches, or deduplication keyed on the raw signature; applications that enforce uniqueness via a claim such as jti, or that do not dedup on signatures, are not meaningfully affected. Limiting factors: only ECDSA algorithms are affected (not RSA/EdDSA/HMAC), the flaw cannot forge new payloads or impersonate a signer, and it requires an already-valid token as input. |
| Impact | Signals converge on a genuinely low-to-moderate, low-impact issue rather than an urgent one. The supplied CVSS 4.0 base score is 5.1 (Medium) with only Vulnerable-System Integrity Low (VI:L) and no confidentiality or availability impact (VC:N/VA:N), matching CWE-347 (improper signature verification) and the advisory's own statement that this is signature malleability - it does NOT allow forging payloads or impersonating a signer because the underlying (r,s) values are unchanged. EPSS is 0.09% (1st percentile), i.e. very low predicted exploitation probability, and the CVE is NOT in CISA KEV, so there is no evidence of active exploitation. A working proof-of-concept is embedded in the GHSA advisory (with execution logs showing five re-padded signatures accepted and six distinct tokens verifying against one key), so exploitability of the malleability itself is demonstrated even though real-world attack value is narrow. The vuln.today decision label is 'this_month' (moderate urgency, not act_now/emergency), consistent with low EPSS and no KEV. One signal is questionable: the supplied 4.0 vector uses AV:L (local), but the attack is realistically delivered by submitting a re-encoded token to a network-facing verification endpoint, which argues for AV:N - verify against the actual deployment. Bottom line: a real but low-priority correctness/malleability bug that only matters where an application keys a security control (revocation-by-hash, replay/idempotency, dedup) on signature or token uniqueness; environments that rely on claims like jti are effectively unaffected. |
| Exploit ScenarioDerived | An attacker who has been issued one valid ES256 JWS token re-encodes its signature by prepending leading zero bytes to each of the R and S halves, producing several distinct byte strings that all decode to the same (r,s) and still verify. They replay the re-encoded token past a revocation-by-hash list or idempotency/replay cache that assumed each signature is unique, defeating that protection. A public PoC embedded in the GHSA advisory demonstrates this against a single P-256 key. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 28, 2026
ECDSA JWS signature malleability in erlang-jose (potatosalad:jose) 1.0.0 through 1.11.12 lets anyone holding a single legitimately issued ES256/ES256K/ES384/ES512 token produce multiple distinct signature byte strings that all verify against the same key, because verify/4 never checks the RFC 7518 §3.4 fixed signature length. It cannot forge new payloads or impersonate a signer - the underlying (r, s) pair is unchanged - but it defeats controls that assume a token or signature is unique, such as token-revocation-by-hash, replay/idempotency caches and deduplication keyed on raw signature bytes; applications that enforce uniqueness via a claim such as jti are not meaningfully affected. Exploitation requires an already-valid token as input (assessed vector AV:N/PR:L), a demonstration PoC reference ships with the vendor advisory but it is not verified as working exploit code against third-party deployments, EPSS is 0.09% (1st percentile), there is no CISA KEV listing, and the vendor released a fix in 1.11.13.
RemediationAI
Vendor-released patch: upgrade jose to 1.11.13 or later, where jose_jwk_kty_ec:verify/4 requires byte_size(Signature) =:= 2 * jws_alg_to_r_s_size(JWSALG) (64 bytes for ES256 and ES256K, 96 for ES384, 132 for ES512) and returns false for any other length, so each valid signature has exactly one accepted encoding; the fix commit is https://github.com/potatosalad/erlang-jose/commit/72ce1866622b9329347dc52a94173ac0317bc9cf and the advisory is https://github.com/potatosalad/erlang-jose/security/advisories/GHSA-44hw-rpw9-mwg4. If upgrading is not immediately possible, the vendor's workaround is to decode the signature with jose_jws:peek_signature/1 (JOSE.JWS.peek_signature/1) and reject the token unless its length exactly matches the algorithm's canonical size - a compensating check that must be applied at every verification call site and duplicates work the library should do, with the side effect of breaking any legitimate token that was already non-canonically encoded. Independently of the fix, the vendor advises not keying replay, revocation-by-hash or deduplication decisions on raw signature bytes and using a claim such as jti instead, since signature bytes are not unique under ECDSA.
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 affected code is jose_jwk_kty_ec:verify/4 in src/jwk/jose_jwk_kty_ec.erl (reachable through the public JOSE.JWS.verify API), which verifies ECDSA JWS signatures encoded as raw R‖S concatenation per RFC 7518 §3.4. Two defects combine: the split point is computed as byte_size(Signature) div 2 rather than the fixed canonical size the module already knows on the signing side (2 * jws_alg_to_r_s_size/1 - 64 bytes for ES256/ES256K, 96 for ES384, 132 for ES512), and each half is converted with crypto:bytes_to_integer/1, which silently drops leading zero bytes. Prepending k zero bytes to each half therefore yields a longer but still evenly splittable signature that decodes to the identical (r, s) integers, so the same key verifies many distinct byte strings. This is CWE-347 (Improper Verification of Cryptographic Signature): a cryptographic signature verification routine failing to enforce the canonical encoding mandated by the algorithm's specification. Only ECDSA-based algorithms are affected; RSA, EdDSA and HMAC paths are not implicated, and because (r, s) is unchanged the flaw yields no new signing capability - its security consequence is purely the loss of signature/token uniqueness.
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:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N
Token is submitted to a network-reachable verifier (AV:N) by an actor holding a valid issued token (PR:L); the only effect is a uniqueness-control bypass, so I:L and C/A:N.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
The jose library accepts ECDSA (ES256, ES256K, ES384, and ES512) JWS signatures of a non-canonical length. When verifying an ECDSA signature, jose_jwk_kty_ec:verify/4 in src/jwk/jose_jwk_kty_ec.erl splits the raw signature in half by its actual byte length (split_binary(Signature, byte_size(Signature) div 2)) instead of enforcing the fixed length required by RFC 7518 §3.4, and then decodes each half with crypto:bytes_to_integer/1, which ignores leading zero bytes.
As a result, an attacker who holds one valid token can prepend leading zero bytes to each of the R and S halves to produce longer signatures that still split evenly and decode to the same (r, s) pair, so many distinct signature byte strings all verify against the same key (signature malleability). This does not allow forging new payloads or impersonating a signer, because the underlying (r, s) values are unchanged. It does defeat any security control that assumes a valid token or its signature is unique, such as token-revocation-by-hash, replay or idempotency caches, and deduplication logic.
This issue affects jose: from 1.0.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
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
Recovery of a long-term X25519 private key is possible in erlang-jose 1.10.0 through 1.11.12 whenever the pure-Erlang Cu
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
EUVD-2026-110310
GHSA-6g34-xwc5-pgxj
NVD
CVE.org
EPSS
Exploit-DB