CVE-2026-47069

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, which accepts any certificate in the peer chain whose public key matches a root in the bundled certifi store, even when the connection is pinned to a private CA. 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.

Allocation of Resources Without Limits or Throttling vulnerability in hackney_conn in benoitc hackney allows a malicious HTTP server to exhaust client memory via an oversized or highly compressed response body. hackney:request/5 and hackney:body/1 return the whole response body, and nothing bounds how much the connection process buffers; affects versions from 2.0.0-beta.1 before 4.9.0.

Interpretation Conflict vulnerability in hackney_url in benoitc hackney allows Server Side Request Forgery via a percent-encoded bracketed IPv6 literal or an IP literal with a trailing dot. A host such as %5B%3A%3Affff%3A127%2E0%2E0%2E1%5D (decoding to [::ffff:127.0.0.1]) or 127.0.0.1. is not an IP address to a caller's allowlist built on uri_string:parse/1 and inet:parse_address/1, while hackney connects to the address it denotes. The same applies to a Location target when redirects are followed.

Insufficiently Protected Credentials vulnerability in hackney in benoitc hackney allows a redirecting server to obtain the basic_auth and cookie credentials of a request via a same-host redirect to another scheme or port. With follow_redirect enabled, hackney:follow_redirect/10 in src/hackney.erl reissues the request to the Location target after hackney:maybe_strip_auth_on_redirect/3, which compared only the hostname of the current and the redirect URL. A redirect from https to http on the same host resent the Authorization and Cookie headers in cleartext, where an on-path attacker can read them, and a redirect to another port on the same host handed them to a different service. location_trusted forwards credentials to any target by design and is unchanged.

In hackney (benoitc) from 2.0.0 before 4.9.0, improper neutralization of CRLF sequences in HTTP headers (HTTP Request/Response Splitting) exists in hackney_http_connect. After a 407 response from an HTTP CONNECT proxy, handle_proxy_auth/11 calls the caller's proxy_auth_fun and writes the returned binary into the Proxy-Authorization line of the CONNECT retry without checking it; a CR, LF, or NUL byte in that value adds header lines to the request sent to the proxy.

A vulnerability in the hackney library (versions 2.0.0 through 4.0.1) allows a Flooding attack due to missing size limits on the HTTP/3 response buffer. A malicious server can send small chunks, resetting the timeout, leading to unbounded memory growth and exhaustion of the BEAM process heap.

The hackney library for Erlang/OTP versions 0.13.0 through 4.0.1 contains a Server-Side Request Forgery (SSRF) vulnerability due to an interpretation conflict. The URL normalizer decodes the host after validation, allowing bypass of allowlists and access to internal IP addresses (e.g., 127.0.0.1, 169.254.169.254).

hackney before version 4.0.1 does not percent-encode CR (\r) and LF (\n) characters in the URL query component, enabling HTTP Request Splitting. An attacker controlling the URL can inject raw CRLF sequences into the query string, allowing arbitrary HTTP headers or request splitting.

A vulnerability in the hackney library (versions 2.0.0 through 4.0.1) allows memory exhaustion by an attacker-controlled WebSocket server. The WebSocket client does not limit buffer sizes in three code paths, enabling a Flooding attack.

CRLF Injection vulnerability in the hackney library allows an attacker to inject arbitrary HTTP headers into a WebSocket request. Lack of CRLF and NUL filtering at four injection points enables request manipulation, potentially leading to credential spoofing, cache poisoning, or request smuggling via proxies.