Threat Intelligence Database

CVE-2026-43971 is an improper encoding or escaping vulnerability in the ninenines cowlib library affecting the cow_link:link/1 function. The vulnerability allows special characters in Link header fields to be unescaped, enabling an attacker to smuggle additional Link header directives. This can cause victim browsers to perform unintended out-of-band connections to attacker-controlled origins. The issue affects cowlib versions from 2.9.0 onward. No patch or official fix status is currently confirmed.

CVE-2026-43971 is an improper encoding or escaping vulnerability in the ninenines cowlib library affecting versions 2.9.0 and later. The flaw occurs in the cow_link:link/1 function, which improperly interpolates URI, rel, and attribute keys into the HTTP Link header without proper escaping or validation. This allows attackers to inject malicious Link header directives by exploiting special characters, potentially causing victim browsers to make unintended connections to attacker-controlled origins. The vulnerability has a medium severity rating with a CVSS score of 6.3.

Allocation of resources without limits vulnerability in ninenines cowlib allows an unauthenticated remote HTTP/2 or HTTP/3 peer to exhaust memory on the vulnerable server (or client) and cause a denial of service. The HPACK and QPACK prefixed-integer decoder cow_hpack_common:dec_big_int/3 in src/cow_hpack_common.hrl (invoked from cow_hpack:decode/2 in src/cow_hpack.erl and from cow_qpack:decode_field_section/3 in src/cow_qpack.erl) reads continuation octets until it sees one whose high bit is clear, evaluating Int + (Value bsl M) at each step with the shift M growing by seven per octet. No limit is enforced on the number of continuation octets, on the resulting bit width, or on the value; the decoder consumes whatever encoded length the peer supplies. Because Erlang integers are immutable, each intermediate Value bsl M and each accumulator update allocates a fresh bignum whose digit width grows linearly with the number of octets processed so far. Summed across the whole decode, the transient bignum digit materialization is on the order of the square of the encoded length. A single maximal HPACK indexed representation carried inside one HTTP/2 HEADERS plus one CONTINUATION frame at Cowboy's default max_frame_size_received can force hundreds of megabytes of transient allocation and garbage-collection churn before the resulting header-table index is rejected as invalid. Repeated or concurrent connections multiply the pressure and can drive the Erlang VM to memory exhaustion. Cowlib is the HTTP parser used by Cowboy, RabbitMQ's management plugin, and other Erlang and Elixir HTTP/2 and HTTP/3 servers and clients, so any exposed endpoint that accepts HPACK or QPACK from an untrusted peer is reachable. This issue affects cowlib: from 2.0.0 before 2.19.0.

Improper Neutralization of CRLF Sequences in HTTP Headers ('HTTP Request/Response Splitting') vulnerability in ninenines cowlib allows HTTP response splitting via non-VCHAR bytes in structured-fields string values. cow_http_struct_hd:escape_string/2 in cowlib only escapes \ and ", passing all other bytes through verbatim. This creates an encoder/decoder asymmetry: the matching parser accepts only printable ASCII (0x20–0x7E, excluding " and \), but the encoder emits any byte including CR and LF. An application that builds a structured HTTP header via cow_http_struct_hd:item/1 (or a higher-level wrapper such as cow_http_hd:wt_protocol/1) from attacker-controlled input can have \r\n injected into the serialized header value. Once on the wire, the injected CRLF terminates the current header and any following bytes are interpreted as a new header, enabling HTTP response splitting. This issue affects cowlib from 2.9.0.

Improper Handling of Highly Compressed Data (Data Amplification) vulnerability in ninenines cowlib allows unauthenticated remote denial of service via memory exhaustion.cow_spdy:inflate/2 in cowlib passes peer-supplied compressed bytes directly to zlib:inflate/2 with no output size bound. The SPDY header compression dictionary (?ZDICT) is public, and zlib compresses long runs of repeated bytes at roughly 1024:1, so a few kilobytes of SPDY frame payload can decompress to gigabytes on the BEAM heap, OOM-killing the node. A single unauthenticated SPDY frame is sufficient to trigger the condition. The parsers for syn_stream, syn_reply, and headers frame types are all affected via cow_spdy:parse_headers/2. This issue affects cowlib from 0.1.0 before 2.16.1.

CVE-2026-43968 is a CRLF injection vulnerability in ninenines cowlib versions from 2.6.0 before 2.16.1. It arises because the library improperly neutralizes carriage return (\r) characters in Server-Sent Events (SSE) fields, allowing attackers to inject additional SSE lines. This can lead to event splitting and injection, enabling manipulation of client-side logic and potentially stored-XSS-like behavior when event data is rendered in browsers. The vulnerability has a CVSS 4.0 score of 6.3, indicating medium severity.

CVE-2026-7790 is a high-severity vulnerability in the ninenines cowlib library, specifically in the cow_http_te module's chunked transfer-encoding parser. The parser accepts an unbounded number of hexadecimal digits in the chunk-size field, leading to excessive CPU and memory consumption. An unauthenticated remote attacker can exploit this by sending a specially crafted HTTP/1.1 request with a very long chunk-size hex string, causing denial of service through resource exhaustion. This affects cowlib versions from 0.6.0 before 2.16.1. No official patch or remediation guidance is currently provided by the vendor.

Improper Neutralization of CRLF Sequences ('CRLF Injection') vulnerability in ninenines cowlib allows HTTP request splitting and cookie smuggling via unvalidated cookie name and value fields. cow_cookie:cookie/1 in cowlib builds a client-side Cookie: request header from a list of name-value pairs without validating either field. An attacker who controls the cookie names or values passed to this function can inject ;, ,, CR, LF, or TAB characters into the serialized header. This enables two classes of attack: cookie smuggling within a single header (e.g. injecting ; admin=1 to introduce a phantom cookie that the receiving server treats as authentic) and HTTP request header splitting (injecting CRLF to append arbitrary headers or smuggle a complete second request against a shared upstream proxy). The decoder side (parse_cookie_name/1, parse_cookie_value/1) and setcookie/3 already validate and reject these characters; the encoder alone is missing the check. This issue affects cowlib: from 2.9.0 onward.