Sep 19, 2026·5 min read·16 visits
AnyCable's Pusher-compatible REST API failed to validate that the HTTP POST request body matched the signature-verified body_md5 parameter, enabling arbitrary message injection via request replays.
AnyCable is a real-time communication server. Prior to version 1.6.15, its Pusher-compatible REST API suffered from an authentication bypass vulnerability because it failed to verify that the request body matched the signature-validated body_md5 parameter. This allows attackers to perform replay attacks with modified body contents.
AnyCable is a high-performance, real-time communication server designed to handle WebSocket connections and broadcast messages across diverse application backends. To support seamless integration and migration from existing architectures, AnyCable provides a Pusher-compatible REST API endpoint. This compatibility layer allows backend applications to trigger events and query subscriber information using standard Pusher HTTP protocols.
Prior to version 1.6.15, the AnyCable server failed to validate the relationship between the HTTP request body and the signature parameters supplied in the query string. This structural omission is classified under CWE-345 (Insufficient Verification of Data Authenticity) and CWE-294 (Authentication Bypass by Capture-replay). The vulnerability is tracked under CVE-2026-63405.
This vulnerability allows unauthenticated network attackers to perform signature replay and inject arbitrary data payloads. Because the server only verified the cryptographic integrity of the query string parameters, the actual request body could be replaced without invalidating the authentication state. As a result, the server would broadcast modified message contents as if they originated from an authorized source.
The underlying flaw resides in the decouple of query-string cryptographic verification from request body content validation. The Pusher REST API protocol specifies five critical query parameters: auth_key, auth_timestamp, auth_version, body_md5, and auth_signature. The server validates that the auth_signature parameter is an HMAC-SHA256 signature calculated over the HTTP method, request path, and sorted query parameters.
In the vulnerable implementation, the cryptographic verification process succeeded if the signature matched the parameters, including body_md5. However, the server never computed the actual MD5 checksum of the incoming HTTP request body to compare it with the body_md5 parameter. The application implicitly assumed that signature validation over the query string guaranteed the integrity of the corresponding body.
Because of this assumption, there was no logical link binding the physical payload to the authenticated parameter. Furthermore, the server lacked validation for the auth_timestamp parameter. Without verifying that the timestamp fell within a reasonable threshold relative to the server time, the application permitted signatures to remain valid indefinitely, enabling permanent replay attacks.
The vulnerability was addressed in commit d2cbadec792f038f4695c84a65c0d957b0fde72c. The patch introduces two distinct validation layers: a timestamp drift verification and an MD5 payload verification step. In the original implementation, handleEvents consumed the request body stream directly from r.Body without prior checksum validation.
The updated Handler function in pusher/http.go now forces structural checks on HTTP methods, timestamp age, and body checksums before processing. Below is an excerpt of the corrected code path:
// Parse and validate the timestamp parameter
ts, err := strconv.ParseInt(authTimestamp, 10, 64)
if err != nil {
w.WriteHeader(http.StatusUnauthorized)
return
}
// Limit timestamp replay window to 600 seconds
if delta := time.Now().Unix() - ts; delta > authTimestampGracePeriod || delta < -authTimestampGracePeriod {
w.WriteHeader(http.StatusUnauthorized)
return
}
// Read body and verify MD5 checksum
if r.Method == http.MethodPost {
bodyMD5 := queryParams.Get("body_md5")
body, err = io.ReadAll(r.Body)
if err != nil {
w.WriteHeader(http.StatusUnprocessableEntity)
return
}
actualMD5 := fmt.Sprintf("%x", md5.Sum(body))
if actualMD5 != bodyMD5 {
w.WriteHeader(http.StatusUnauthorized)
return
}
}This implementation closes the bypass vector by checking that the actualMD5 matches the signature-bound bodyMD5 parameter. If an attacker alters the body, the checksum test fails, and the request is rejected with an HTTP 401 Unauthorized status code.
Exploiting this flaw requires an attacker to intercept or obtain a single, valid, signed HTTP POST request directed to the Pusher-compatible API endpoint. Because signatures do not expire due to the lack of timestamp verification, a captured signature can be replayed at any subsequent time.
An attacker constructs a new HTTP POST request to /apps/:app_id/events using the exact query string parameters retrieved from the legitimate request. The attacker alters the POST request body, inserting arbitrary event data or control structures. Because the signature matches the parameters, the server validates the signature, skips body verification, and processes the malicious JSON payload, distributing the unauthorized event to active clients.
The CVSS v3.1 base score is assessed at 5.9 (Medium), characterized by the vector CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N. The severity is mitigated to Medium because an attacker must first intercept a valid API signature, representing a high-complexity requirement. However, once a signature is obtained, the integrity impact is high.
An attacker exploiting this vulnerability can broadcast unauthorized events, distribute phishing links, inject malicious client-side scripts, or manipulate application state transitions for all active WebSocket subscribers. The lack of tenant separation within the signed request means a compromised signature can affect any channel authorized under that key.
There is no recorded in-the-wild exploitation, and the EPSS score remains low at 0.00172. Nevertheless, because the exploit mechanics are straightforward once a signature is acquired, immediate mitigation is required for all exposed AnyCable endpoints.
The recommended remediation is to upgrade AnyCable to version 1.6.15 or later. This update enforces the necessary cryptographic check on the request body and enforces the 10-minute timestamp validation window. Developers using Go modules can apply the patch by executing:
go get github.com/anycable/anycable-go@v1.6.15When immediate patching is unfeasible, administrators should restrict access to the Pusher-compatible REST API routes (typically /apps/*/events) using network-level controls. Restricting source IP addresses to trusted backend application servers prevents unauthorized external entities from sending replayed requests directly to the AnyCable server.
Additionally, upstream reverse proxies should enforce maximum request body limits to mitigate potential denial-of-service risks. Since the patched code reads the entire request body into memory using io.ReadAll to compute the MD5 sum, limiting the allowable request size prevents resource exhaustion from oversized payloads.
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
anycable-go AnyCable | < 1.6.15 | 1.6.15 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-345 / CWE-294 |
| Attack Vector | Network |
| CVSS v3.1 Score | 5.9 (Medium) |
| Exploit Status | None (No public exploit available) |
| EPSS Score | 0.00172 (0.17%) |
| CISA KEV Status | Not Listed |
The software does not sufficiently verify the authenticity of the data it receives, allowing an attacker to bypass authorization steps by replaying or modifying data.
CVE-2026-114157 is a high-severity local privilege escalation and security feature bypass vulnerability affecting ASP.NET Core on Microsoft Windows. The flaw resides in the Kestrel web server's Named Pipes transport layer (Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes) and stems from a race condition (CWE-362) during broken pipe error recovery. When an active connection throws an IOException during handshake acceptance, the connection listener previously disposed of the broken NamedPipeServerStream instance before acquiring a replacement stream from its internal pool. This sequence created a momentary window where zero server instances of the named pipe existed in the Windows Named Pipe File System (NPFS). A local, low-privileged attacker can exploit this timing window to create a named pipe with the identical name and a permissive Discretionary Access Control List (DACL), hijacking subsequent inter-process communications and escalating privileges across security boundaries.
CVE-2026-124194 is a forced authentication and spoofing vulnerability in Microsoft Office Outlook caused by a missing user interface warning before dereferencing remote network paths (CWE-356). By embedding an attacker-controlled Universal Naming Convention (UNC) path within MAPI message properties such as PidLidReminderFileParameter, an unauthenticated remote attacker can force a victim's system to initiate an outbound SMB or WebDAV connection upon opening or previewing a crafted message. This automatic authentication handshake leaks the user's NetNTLMv2 hash, enabling offline password cracking or real-time NTLM relay attacks. The vulnerability was exploited in the wild as a zero-day prior to its remediation in Microsoft's November 2026 Patch Tuesday updates and is listed in the CISA Known Exploited Vulnerabilities (KEV) catalog.
CVE-2026-114154 is a high-severity Denial of Service (DoS) and uncontrolled resource consumption vulnerability in the Microsoft.AspNetCore.Server.HttpSys component of ASP.NET Core. When processing an HTTP request that simultaneously contains a chunked Transfer-Encoding header, a Content-Length header, and an explicit X-Content-Length header, the server throws an unhandled ArgumentException during header normalization. In certain versions, subsequent exception handling attempts to dereference a disposed native request context, aborting error response dispatch and leaking unmanaged HTTP.sys request structures.
A local elevation of privilege vulnerability exists in the Microsoft .NET Aspire CLI (`Aspire.Cli`) versions 13.5.4 prior to 13.6.5. When executing SDK management commands (`aspire sdk generate`, `aspire sdk dump`, and `aspire sdk export`), the CLI creates temporary project directories inside the shared operating system temporary folder (such as `/tmp` on Unix-like systems) without restricting directory permissions or disabling MSBuild automatic response file resolution. A local, low-privileged attacker on a multi-user system can place a crafted `Directory.Build.rsp` file in the shared temporary directory hierarchy. When a victim user executes an affected Aspire CLI command, MSBuild traverses upward, ingests the attacker-controlled response file, and executes arbitrary commands in the security context of the victim user.
CVE-2026-120792 is a high-severity local information disclosure vulnerability in the Microsoft .NET Aspire CLI (Aspire.Cli) affecting versions 13.5.4 prior to 13.6.5. The flaw stems from the insertion of sensitive information into a shared temporary log file (CWE-532) combined with insecure temporary file creation (CWE-377) within the DeprecatedMcpCommandScanner component. During agent configuration scanning, the CLI unconditionally appends internal workspace paths and the first 200 characters of Model Context Protocol (MCP) agent configuration files to a statically named file in the system temporary directory. On multi-user systems, unprivileged local users can read this file to harvest API keys, authentication tokens, and internal service endpoints.
CVE-2026-114159 is a heap-based buffer overflow vulnerability (CWE-122) in Microsoft.DiaSymReader.Native affecting Microsoft Visual Studio and the .NET Runtime on Windows. An integer truncation error during the parsing of oversized document names in Portable PDB symbol files causes an undersized heap allocation, leading to an out-of-bounds memory write and remote code execution.