CVE-2026-33936: 
Python vulnerability analysis and mitigation

CVE-2026-33936 is a Denial of Service vulnerability in the ecdsa PyPI package (a pure Python implementation of ECC/ECDSA/EdDSA/ECDH) caused by improper DER length validation in low-level parsing functions. Discovered and reported by Mohamed Abdelaal (@0xmrma), it was disclosed on March 26, 2026, and affects all versions prior to 0.19.2. The vulnerability carries a CVSS v3.1 base score of 5.3 (Medium) (Github Advisory). Microsoft also tracks this vulnerability in its security guidance (Microsoft).

The root cause is improper input validation (CWE-20) combined with improper handling of length parameter inconsistency (CWE-130) in the DER parsing helper functions remove_octet_string(), remove_constructed(), and remove_implicit(). These functions fail to verify that the declared DER length field does not exceed the actual available buffer size — for example, an OCTET STRING declaring a length of 4096 bytes but providing only 3 bytes is accepted rather than rejected. This allows a crafted DER input to propagate through to SigningKey.from_der(), which then raises an internal IndexError: index out of bounds on dimension 1 instead of a clean UnexpectedDER or ValueError. The fix, applied in commit bd66899, adds a bounds check (if length > len(string) - 1 - llen: raise UnexpectedDER(...)) to each affected function (Github Advisory, Patch Commit).

The primary impact is a denial of service: applications that parse untrusted DER-encoded private keys using the ecdsa library may crash if they do not explicitly catch unexpected exception types such as IndexError. There is no confidentiality or integrity impact — the vulnerability cannot be used to extract key material or modify data. Any networked service that accepts DER-formatted cryptographic keys from untrusted sources (e.g., TLS implementations, key management APIs) is at risk of process crashes triggered by a single malformed input (Github Advisory).

Public proof-of-concept code (poc_truncated_der_octet.py and poc_signingkey_from_der_indexerror.py) is available in the official security advisory and demonstrates reliable crash reproduction (Github Advisory). An additional PoC repository exists at https://github.com/0xmrma/CVE-2026-33936, though it contains only documentation rather than runnable code. The EPSS score is approximately 0.047% (15th percentile), indicating low probability of active exploitation in the near term. There is no evidence of in-the-wild exploitation, no known threat actor attribution, and the vulnerability is not listed in the CISA KEV catalog.

1. Identify target: Find a networked application that uses the ecdsa Python package (versions < 0.19.2) and accepts DER-encoded private keys from user-supplied or external input (e.g., a key upload endpoint or TLS handshake handler).
2. Craft malformed DER input: Construct a byte sequence with an OCTET STRING tag (0x04) followed by a long-form length field declaring a large value (e.g., 0x82 0x10 0x00 = 4096 bytes) but providing only a few actual bytes of body data (e.g., b"\x04\x82\x10\x00" + b"ABC").
3. Submit crafted input: Send the malformed DER bytes to the target application's key parsing interface, triggering a call to ecdsa.der.remove_octet_string() or a higher-level function such as SigningKey.from_der().
4. Trigger crash: The library accepts the truncated DER without raising UnexpectedDER, propagating the malformed state until an IndexError: index out of bounds on dimension 1 is raised internally, crashing any application that does not catch this unexpected exception type.
5. Repeat for sustained DoS: Since the crash is deterministic and requires no authentication or prior state, the attacker can repeatedly send crafted inputs to keep the service unavailable (Github Advisory).

• Logs: Python tracebacks containing IndexError: index out of bounds on dimension 1 originating from ecdsa/der.py in application error logs; repeated exceptions from SigningKey.from_der() with no corresponding UnexpectedDER or ValueError.
• Network: Repeated inbound requests submitting DER-formatted data (e.g., binary payloads starting with \x04\x82) to key parsing endpoints, particularly from a single source IP or with high frequency.
• Process: Unexpected crashes or restarts of Python processes running services that use the ecdsa library, especially correlated with receipt of external DER key material.

Upgrade the ecdsa PyPI package to version 0.19.2 or later, which adds buffer bounds checks to remove_octet_string(), remove_constructed(), and remove_implicit() (Release Notes, Patch Commit). As a short-term workaround, wrap all calls to SigningKey.from_der() and related DER parsing functions in broad exception handlers that catch IndexError and other unexpected exceptions in addition to UnexpectedDER and ValueError. Where possible, restrict DER key parsing to trusted, validated sources to reduce attack surface. SUSE Linux has also issued security updates for the python-ecdsa package (OpenSUSE Advisory).

The vulnerability was credited to researcher Mohamed Abdelaal (@0xmrma), who submitted the report and provided detailed PoC scripts included in the official advisory (Github Advisory). The fix was merged promptly by maintainer tomato42 on the same day as disclosure. SUSE issued downstream security advisories, and Tenable published Nessus detection plugins (IDs 304163, 307426) shortly after disclosure. Community reaction has been measured given the moderate severity and limited exploitation potential.