Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver crafted pcap to analyst
-
DeliveryAnalyst runs ssldump -j -N on file
-
Exploitfanx_fingerprint undersizes heap buffer
-
Executionsprintf writes 3 bytes past buffer
-
ImpactHeap corruption crashes process (worst case code execution)
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Heap buffer bounds checking
MITRE ATT&CK
1 technique across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires that the victim run ssldump with FAN/1 X.509 fingerprinting enabled - specifically the -j (JSON output) and -N options - against an attacker-supplied pcap that contains a TLS handshake with a valid X.509 server certificate. The overflow is deterministic and fires on every invocation of fanx_fingerprint with valid certificate inputs, so no special payload tuning is needed. Limiting factors that reduce real-world risk: exploitation is local only (the attacker cannot reach the tool over the network), it depends on the victim actively choosing to process the malicious file with the non-default FAN/1 fingerprinting options, and the overflow is only 3 bytes of largely fixed content, making a crash far more likely than code execution. |
| Impact | This is a genuine but modest-priority memory-safety bug, not a drop-everything emergency. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:A) correctly models the real constraint: exploitation is LOCAL and requires active user interaction - a victim must voluntarily run ssldump against an attacker-supplied pcap with FAN/1 fingerprinting enabled (-j -N). There is no network-facing attack surface; ssldump is an offline/CLI analysis tool, so this is an analyst-workstation / sandbox-detonation risk rather than a server-compromise risk. No EPSS score, KEV listing, or public POC was provided in the input, so there is no public exploit identified at time of analysis and no evidence of active exploitation. The vendor-assigned VI:H/VA:H is debatable: the root cause is a fixed, deterministic 3-byte heap overflow whose overflowing bytes are the constant tail of the format string plus a NUL terminator (from the +31 vs +34 calloc miscalculation). A reliable crash (DoS) is plausible, but 'arbitrary code execution' is a worst-case claim dependent on heap layout and allocator behavior - the input data does not substantiate reliable RCE, and the 'RCE' tag should be read as theoretical worst case rather than demonstrated. Net: treat as a low-to-moderate priority fix, higher only for operators who routinely process untrusted pcaps with -j -N. |
| Exploit ScenarioDerived | An attacker crafts a pcap file containing a TLS handshake with an X.509 server certificate and delivers it to an analyst (e.g. as a 'suspicious capture' sample). When the analyst runs ssldump with FAN/1 fingerprinting enabled (-j -N) against the file, fanx_fingerprint writes 3 bytes past an undersized heap buffer, corrupting the heap and most likely crashing the process (DoS), with arbitrary code execution as an unproven worst case. No public exploit code was identified in the provided data; exploitation requires the victim to actively open the file with the specific options. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 16, 2026
A deterministic 3-byte heap-based buffer overflow in ssldump's FAN/1 X.509 fingerprinting routine (fanx_fingerprint in ssl/sslxprint.c) corrupts the heap on every call that processes a valid certificate. Exploitation requires the victim to run ssldump with FAN/1 fingerprinting enabled (the -j and -N options) against an attacker-supplied pcap containing a TLS handshake with a valid X.509 server certificate; the attack vector is local and depends on the user actively choosing to parse the malicious capture with non-default options. The most likely outcome is a crash/denial of service, with arbitrary code execution in the context of the ssldump user remaining a worst-case possibility; no public exploit code has been identified at time of analysis, and the overflow content is largely fixed, which makes code execution substantially harder than a denial of service.
RemediationAI
Apply the upstream fix, available as commit 8ad55683cc0186600c085d33be5a5b627db78467 in adulau/ssldump (https://github.com/adulau/ssldump/commit/8ad55683cc0186600c085d33be5a5b627db78467); this is a source commit rather than a tagged release, so an upstream fix is available but a released patched version is not independently confirmed - rebuild from the patched commit or wait for your distributor's package update and verify the fix is present before deployment. The change replaces the undersized calloc(strlen(b64) + strlen(hex) + 31, 1) plus sprintf() with snprintf(NULL, 0, ...) length calculation, calloc(fp_len + 1, 1), and a bounded snprintf(), and it also adds a CTest regression and an ASan CI job, so pulling the full commit (not just the C file) gives you the accompanying tests. Until the patched build is deployed, the effective compensating control is to avoid the vulnerable code path: do not run ssldump with the -j and -N options (disable FAN/1 X.509 fingerprinting) when processing untrusted or third-party pcap files, and treat captured traffic from untrusted sources as hostile input. Because the trigger is a valid X.509 certificate in a TLS handshake, sanitizing or rejecting captures that contain TLS handshakes is impractical for a TLS analyzer and would defeat the tool's purpose; the trade-off of dropping -j/-N is simply the loss of JSON-formatted FAN/1 fingerprint output for those captures. Building with AddressSanitizer (-fsanitize=address, as the upstream CI does) will reliably detect the overflow during testing but is not a production remediation, and an ASan-instrumented binary should be used only to validate the fix, not as a mitigation.
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
ssldump is a network protocol analyzer for SSL/TLS traffic maintained in the adulau/ssldump project, and its FAN/1 (Forensic Analysis Network) output mode emits JSON records that include a fingerprint string built from a certificate's feature set. The vulnerable routine, fanx_fingerprint, formats that output with the literal template "fan1:x509:server:passive:%s:sha256:%s", which contributes 33 fixed bytes, then concatenates two variable-length fields (a base64-url-encoded feature blob and its SHA-256 hex digest). The code sized its heap buffer as strlen(b64) + strlen(hex) + 31 and wrote into it with unbounded sprintf(), so the calculation falls three bytes short of what the format string actually requires, producing a heap-based buffer overflow (CWE-122) with null-terminator and adjacent-byte corruption on every invocation with valid inputs. Because FAN/1 fingerprints are the intended, always-emitted output when the feature is enabled, there is no partial-trigger condition: any TLS handshake bearing a valid certificate drives the vulnerable path. The upstream fix replaces the fixed-size arithmetic and sprintf() with a length-first idiom: snprintf(NULL, 0, format, b64, hex) to compute the exact required length, calloc(fp_len + 1, 1) to allocate it, and a bounded snprintf() for the write, and it adds a CTest regression (tests/test_fan1_x509.py) plus a Linux AddressSanitizer CI job that exercises the sample TLS 1.2 capture to catch invalid buffer accesses.
Know when Ssldump 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:A/VC:N/VI:H/VA:H/SC:N/SI:N/SA:N
Local attack requiring the victim to run ssldump on an attacker-supplied file (AV:L, UI:R); no privileges needed (PR:N); reliable crash gives A:H while the fixed 3-byte overflow makes integrity impact low (I:L) and confidentiality none.
Primary rating from Vendor (CIRCL).
CVSS VectorVendor: CIRCL
DescriptionCVE.org
The fanx_fingerprint function in ssl/sslxprint.c of ssldump allocates a heap buffer for formatting FAN/1 X.509 certificate fingerprints. The allocation size is computed as strlen(b64) + strlen(hex) + 31, but the format string "fan1:x509:server:passive:%s:sha256:%s" contains 33 fixed characters in addition to the two variable-length fields and a null terminator, requiring strlen(b64) + strlen(hex) + 34 bytes. This miscalculation results in a 3-byte heap-based buffer overflow on every invocation of the function with valid inputs. The overflow occurs because sprintf writes the full formatted string into the undersized heap buffer without bounds checking. An attacker who can supply a crafted pcap file containing a TLS X.509 certificate to a user running ssldump with FAN/1 fingerprinting enabled (for example with the -j -N options) can trigger the overflow. The resulting heap corruption may lead to denial of service through a crash or, in a worst-case scenario, arbitrary code execution in the context of the user running ssldump. The vulnerability is deterministic and requires no special privileges beyond the ability to provide input to the tool.
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
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
A heap overflow occurs when a program writes data beyond the bounds of a buffer allocated in the heap memory region.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
EUVD-2026-102656
GHSA-px2j-96c7-vxc7
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB