Http4s - CraftedSignal Threat Feedhttps://feed.craftedsignal.io/vendors/http4s/Trending threats, MITRE ATT&CK coverage, and detection metadata. Fed continuously.Hugoenhello@craftedsignal.iohello@craftedsignal.ioFri, 24 Jul 2026 22:35:42 +0000Unbounded WebSocket Message Aggregation Leads to Denial of Service in http4s-blaze-serverhttps://feed.craftedsignal.io/briefs/2026-07-unbounded-websocket-dos-http4s-blaze/Fri, 24 Jul 2026 22:35:42 +0000hello@craftedsignal.iohttps://feed.craftedsignal.io/briefs/2026-07-unbounded-websocket-dos-http4s-blaze/A vulnerability in `http4s-blaze-server` allows an attacker to cause a denial of service by exploiting unbounded WebSocket message aggregation, enabling an attacker to drive unbounded heap growth in the server's JVM by sending an unterminated fragmented WebSocket message, leading to an `OutOfMemoryError` and server termination, affecting any http4s application serving WebSocket routes over `BlazeServerBuilder` and triggerable by unauthenticated or authenticated clients.A critical vulnerability exists in http4s-blaze-server versions prior to 0.23.18 and within versions 1.0.0-M1 to 1.0.0-M41, stemming from unbounded WebSocket message aggregation. Attackers can exploit this by establishing a WebSocket connection and sending fragmented messages without setting the final (FIN) bit. The server, particularly when using BlazeServerBuilder, buffers these fragments without any size limit, irrespective of the maxWebSocketBufferSize setting which only applies to individual frames. This leads to continuous and uncontrolled heap memory growth in the server's Java Virtual Machine (JVM). Ultimately, this resource exhaustion results in an OutOfMemoryError and the termination of the JVM process, effectively causing a Denial of Service (DoS) for the affected http4s application. Both unauthenticated and authenticated clients can trigger this vulnerability, depending on the WebSocket endpoint's exposure, making it a severe threat to the availability of affected services.

Attack Chain

  1. An attacker establishes a WebSocket connection with a vulnerable http4s-blaze-server application.
  2. The attacker sends an initial WebSocket message fragment.
  3. The attacker continues to send a series of subsequent WebSocket message fragments.
  4. These fragments intentionally do not set the FIN (final fragment) bit, indicating an unterminated message.
  5. The http4s-blaze-server buffers all incoming fragments of this unterminated message without an aggregate size limit.
  6. Due to the lack of an aggregate size limit, the server's JVM heap memory grows uncontrollably as fragments accumulate.
  7. The server's JVM encounters an OutOfMemoryError as it exhausts available memory resources.
  8. This OutOfMemoryError leads to the termination of the server JVM, resulting in a Denial of Service for the affected http4s application.

Impact

Any http4s application that serves WebSocket routes over BlazeServerBuilder is directly impacted by this vulnerability. Successful exploitation leads to an OutOfMemoryError within the server's JVM, causing it to terminate. This results in complete unavailability of the affected application, leading to a Denial of Service. The maxWebSocketBufferSize configuration parameter does not mitigate this issue as it only limits individual frame sizes, not the aggregated message size. A single malicious connection can exhaust the server's heap, even with a modest volume of wire bytes if many small fragments are used, amplifying the per-frame object overhead. The attacker can be unauthenticated if the WebSocket endpoint is publicly reachable or an authenticated client if the handshake requires authentication.

Recommendation

  • Terminate or limit WebSocket traffic at a fronting layer (e.g., a reverse proxy or load balancer) that enforces message-size and fragment count limits, or disable WebSocket routes entirely on affected http4s-blaze-server instances.
  • Plan migration to a maintained backend (e.g., http4s-ember) as the upstream blaze server is End-of-Life, addressing the root cause in affected http4s-blaze-server versions.
]]>mediumadvisorydenial-of-servicewebserverjvmwebsocketMultiple HTTP/1.1 Request Smuggling Primitives in Blaze Java Parserhttps://feed.craftedsignal.io/briefs/2026-07-blaze-http-request-smuggling/Fri, 24 Jul 2026 22:28:58 +0000hello@craftedsignal.iohttps://feed.craftedsignal.io/briefs/2026-07-blaze-http-request-smuggling/Five independent HTTP/1.1 conformance laxities in Blaze's Java parser cause request-boundary disagreement with a stricter intermediary proxy, enabling front-end ACL/authentication bypass, response-queue poisoning on pooled backend connections, and cache poisoning in affected `http4s-blaze-server` and `blaze-http` components.Five distinct HTTP/1.1 conformance vulnerabilities have been identified in Blaze's hand-written Java parser, specifically within the http/src/main/java/org/http4s/blaze/http/parser/ component. These laxities in parsing HTTP requests can lead to request-boundary disagreement between a strict intermediary proxy and a vulnerable Blaze server, a classic HTTP request smuggling scenario. The issue affects http4s-blaze-server_2.13 (versions up to 0.23.17), blaze-http_2.13 (versions up to 0.23.17 and from 1.0.0-M1 to 1.0.0-M41), and blaze-http_3 (versions up to 0.23.17 and from 1.0.0-M1 to 1.0.0-M41). These vulnerabilities are reachable via a default BlazeServerBuilder configuration. Attackers can leverage this discrepancy to bypass front-end access controls or authentication, poison response queues on pooled backend connections, and corrupt web caches, impacting the integrity and security of web applications. The primary risk lies in deployments using lenient or legacy intermediary proxies that do not strictly conform to RFC HTTP/1.1 parsing rules.

Attack Chain

  1. An attacker crafts a single HTTP/1.1 request containing ambiguous Content-Length or Transfer-Encoding headers, or other conformance violations, designed to be interpreted differently by an intermediary proxy and the vulnerable Blaze server.
  2. The attacker sends this specially crafted, malformed request to the fronting proxy of the target web application.
  3. The intermediary proxy, being RFC-strict, processes the initial part of the request, sanitizes or re-serializes it according to its own parsing rules, and forwards what it believes to be a complete, valid request to the backend Blaze server.
  4. The vulnerable Blaze server, due to its parsing laxities, interprets the forwarded request differently from the proxy, potentially seeing a second, embedded request where the proxy only saw data for the first.
  5. The Blaze server processes this "smuggled" second request, which could contain unauthorized commands or access to restricted resources.
  6. This discrepancy leads to various outcomes, such as bypassing authentication, accessing internal resources, poisoning caches, or manipulating subsequent requests in the proxy's queue, ultimately achieving the attacker's objective.

Impact

The actual exploitability of these vulnerabilities depends heavily on the fronting proxy's behavior, requiring a specific disagreement between the proxy's and the Blaze server's HTTP/1.1 parsers. If the proxy forwards malformed bytes that the Blaze server interprets differently, the consequences include bypassing front-end access control lists (ACLs) or authentication mechanisms, leading to unauthorized access. Attackers can also achieve response-queue poisoning on pooled backend connections, potentially serving malicious content or responses to other users. Additionally, web caches can be poisoned, leading to a denial-of-service or content manipulation. Risk is concentrated on systems using lenient or legacy intermediary proxies that do not strictly enforce HTTP/1.1 RFC compliance.

Recommendation

  • Upgrade http4s-blaze-server and blaze-http components to patched versions that address these HTTP/1.1 parsing vulnerabilities immediately.
  • Deploy affected applications behind an RFC-strict reverse proxy (such as nginx, HAProxy, Envoy, or AWS Application Load Balancer) that explicitly rejects or re-serializes malformed requests at the edge, mitigating the parsing discrepancies before they reach the vulnerable server.
  • Monitor web server logs and network traffic for anomalous HTTP request patterns, such as duplicate or malformed Content-Length or Transfer-Encoding headers, which could indicate request smuggling attempts.
]]>highadvisoryrequest-smugglinghttp/1.1javavulnerability