Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain on-path network position between client and pinned host
-
DeliveryObtain publicly trusted certificate for the pinned hostname
-
ExploitPresent chain ending in a certifi-bundled root
-
Executionhackney partial_chain overrides the pinned private CA
-
ImpactImpersonate server and intercept/modify TLS traffic
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A07:2025 - Authentication Failures
ASVS 5.0
V12 - Secure Communication Certificate validation
|
| Exploitation Conditions | Exploitation requires a specific non-default pinning configuration: the application must call hackney with verify_peer and replace the trust store by passing cacerts or cacertfile in ssl_options to pin a private certificate authority, WITHOUT supplying its own partial_chain callback (a caller-supplied partial_chain is preserved and is not vulnerable). The attacker additionally must hold an on-path/MITM position and must possess a certificate for the pinned hostname that is both publicly trusted (chaining to a certifi-bundled root) and passes the still-enforced hostname check. Connections relying on hackney's default certifi trust store are not the target of this flaw. Limiting factors: config-dependent (private-CA pinning only), restricted to hackney 1.24.0 through 4.8.x, and the need for both network interception and a valid publicly trusted certificate for the exact pinned host. |
| Impact | This is a genuine high-priority issue for the specific population that uses it, but its real-world blast radius is narrower than the 9.1 CVSS 4.0 score suggests. The vuln.today Decision label is act_now and a vendor patch exists (hackney 4.9.0), which should drive urgency. The CVSS 4.0 vector (AV:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:N) correctly captures that no privileges or user interaction are needed but that meaningful attack requirements apply: the AC:H/AT:P metrics reflect that the attacker must already hold an on-path (MITM) position AND must obtain a publicly trusted certificate valid for the pinned hostname (the hostname check is still enforced per the description). The high impact (VC:H/VI:H) is justified because successful exploitation yields full server impersonation - read and modify of TLS-protected traffic. However, exploitation is strictly conditional on a non-default deployment: the caller must pin to a private CA via cacerts/cacertfile under verify_peer without supplying its own partial_chain. No EPSS score, KEV status, or POC/exploit reference was provided in the input; the only code references are the fix PR and patch commits, so there is no public exploit identified. The absence of EPSS/KEV is not evidence of low risk, but combined with the specific configuration prerequisite this reads as a 'serious-but-targeted' flaw rather than a mass-exploitation event. |
| Exploit ScenarioDerived | An Erlang/Elixir application uses hackney to reach an internal service and pins trust to a private CA by passing cacerts (or cacertfile) in ssl_options under verify_peer. An on-path attacker who holds a publicly trusted certificate for that exact hostname presents a chain ending in a root bundled in hackney's certifi store; hackney's retained partial_chain callback picks that root as the trust anchor over the operator's pinned CA, so the handshake succeeds and the attacker impersonates the server to intercept and alter traffic. No public exploit was identified at time of analysis; the mechanism is confirmed only by the fix diff in PR #978. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 26, 2026
Improper certificate validation in the Erlang HTTP client hackney (1.24.0 through 4.8.x) lets an on-path attacker impersonate a server that an application has pinned to a private certificate authority. Because hackney adds its own {partial_chain, fun hackney_ssl:partial_chain/1} to every verify_peer configuration and OTP honours that callback over a caller-supplied cacerts/cacertfile trust store, a chain ending in any certifi-bundled public root can be accepted as the trust anchor; the attacker still needs a man-in-the-middle position and a publicly trusted certificate for the exact pinned hostname that satisfies the hostname check, so only non-default private-CA pinning deployments are exposed. No public exploit identified at time of analysis and no CISA KEV entry, though the issue is triaged as act_now and fixed in hackney 4.9.0.
RemediationAI
Upgrade hackney to 4.9.0 (https://github.com/benoitc/hackney/releases/tag/4.9.0), which is the vendor-released patch; the change is in PR https://github.com/benoitc/hackney/pull/978 and the patch commit https://github.com/benoitc/hackney/commit/915eb5737e9c489d8fc22eec8cdae30e9b027be4, with a related commit at https://github.com/benoitc/hackney/commit/d8a9afcf5c3849904274e2eba1df56c63d1a1a0c and advisory context at https://cna.erlef.org/cves/CVE-2026-115693.html. If an immediate upgrade is not possible, the fix's own behaviour shows the workaround: pass an explicit partial_chain function in ssl_options alongside your cacerts/cacertfile so a caller-supplied callback overrides hackney's certifi-backed one - the trade-off is that you must implement the callback correctly so it accepts only your private CA's root and returns unknown_ca for everything else, and a mis-written callback will break legitimate connections. Deployments that rely on hackney's default certifi trust store do not need this change. Verify the effective options after any configuration change, since the merge happens both when building SSL options and again on the handshake path.
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-295 (Improper Certificate Validation) in hackney's TLS option handling. hackney_ssl ships a hard-coded partial_chain callback that scans the peer chain and returns as trust anchor any certificate whose public key matches a root in the bundled certifi store. In Erlang/OTP's ssl application, a partial_chain callback takes precedence over the configured cacerts/cacertfile when the path validation builds the chain, so a peer presenting a leaf issued for the pinned hostname by a public CA will validate even though the caller intended to trust only a private root. hackney_ssl:merge_ssl_opts/3 preserved this callback when a caller replaced the trust store through ssl_options, and the same merge path is used by effective_opts/3 at handshake time. The upstream fix keeps the callback only when hackney's own trust store is in effect: if the caller supplies cacerts or cacertfile and does not bring its own partial_chain, the callback is dropped; a caller-supplied partial_chain is retained, and ssl_options that leave the trust store alone keep hackney's default behaviour. Hostname verification is unaffected, which limits the attack to a publicly trusted certificate issued for the exact pinned host.
Know when Hackney 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:N/AC:H/AT:P/PR:N/UI:N/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N
On-path position plus a publicly trusted cert for the host make AC:H; no target privileges or interaction give PR:N/UI:N; server impersonation breaks confidentiality and integrity but not availability.
Primary rating from Vendor (EEF).
CVSS VectorVendor: EEF
DescriptionCVE.org
Improper Certificate Validation vulnerability in hackney_ssl in benoitc hackney allows an on-path attacker to impersonate a server pinned to a private certificate authority via a certificate chain that ends in a publicly trusted root. hackney adds {partial_chain, fun hackney_ssl:partial_chain/1} to every verify_peer configuration. The callback returns any certificate in the peer chain whose public key matches a root in the bundled certifi store as the trust anchor, and OTP honours that callback over the configured cacerts. hackney_ssl:merge_ssl_opts/3 kept the callback when the caller replaced the trust store with cacerts or cacertfile in ssl_options, so a connection pinned to a private CA still accepted any chain that carried a publicly trusted root.
The hostname check still applies, so the attacker needs a publicly trusted certificate for the pinned hostname.
This issue affects hackney: from 1.24.0 before 4.9.0.
Executive ViewAI
CVE-2026-115693 is a critical flaw in the Erlang HTTP client hackney that undermines certificate pinning, allowing an attacker with a man-in-the-middle position and a publicly trusted certificate for the pinned hostname to impersonate servers in non-default private-CA pinning deployments. Only applications relying on private certificate authority pinning are exposed, but for those, the vulnerability breaks a key defense against interception of sensitive communications. Leadership should prioritize identification and patching of affected Erlang services to prevent potential data breaches and maintain trust.
Apply vendor patch.
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.
Denial of service in benoitc hackney (Erlang HTTP client) versions 2.0.0 through 4.0.0 allows a malicious WebSocket serv
Denial of service in benoitc hackney (Erlang HTTP client) 2.0.0 through 4.0.0 allows remote unauthenticated attackers to
Denial-of-service in benoitc's hackney Erlang HTTP client (versions 2.0.0-beta.1 through 4.0.0) allows any HTTP origin s
Remote denial of service in benoitc hackney 2.0.0 through 4.0.0 lets a malicious HTTP/3 server exhaust a client's BEAM p
Denial of service in benoitc hackney (Erlang HTTP client) versions 0.10.0 through 4.0.0 lets a hostile SOCKS5 or HTTP CO
CRLF injection in hackney (Erlang HTTP client, versions 2.0.0-4.0.1) enables header injection into outbound WebSocket up
SSRF allowlist bypass in hackney (Erlang HTTP client) versions 0.13.0 through before 4.0.1 allows attackers who control
HTTP Request Splitting via CRLF injection in hackney, the Erlang/Elixir HTTP client library, allows an attacker who cont
Credential leakage in the hackney Erlang HTTP client library (versions 3.1.1 through before 4.0.1) allows a malicious or
Memory exhaustion in the Erlang hackney HTTP client (2.0.0-beta.1 through 4.8.x) lets any server the client requests for
Server-side request forgery in the Erlang hackney HTTP client (versions 4.0.1 up to but not including 4.9.0) lets an att
CRLF injection in the hackney Erlang HTTP client library's hackney_cookie:setcookie/3 function enables HTTP response spl
EUVD-2026-109836
GHSA-g7gg-9jhv-68h6
NVD
CVE.org
EPSS
Exploit-DB