CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-63405

CVE-2026-63405: Insufficient Verification of Data Authenticity in AnyCable Pusher REST API

Amit Schendel
Amit Schendel
Senior Security Researcher

Sep 19, 2026·5 min read·16 visits

Executive Summary (TL;DR)

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.

Vulnerability Overview

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.

Root Cause Analysis

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.

Code-Level Patch Analysis

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.

Exploitation Methodology

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.

Impact & Risk Assessment

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.

Mitigation & Remediation

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.15

When 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.

Fix Analysis (1)

Technical Appendix

CVSS Score
5.9/ 10
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N
EPSS Probability
0.17%
Top 93% most exploited

Affected Systems

AnyCable Go Server (anycable-go)

Affected Versions Detail

Product
Affected Versions
Fixed Version
anycable-go
AnyCable
< 1.6.151.6.15
AttributeDetail
CWE IDCWE-345 / CWE-294
Attack VectorNetwork
CVSS v3.1 Score5.9 (Medium)
Exploit StatusNone (No public exploit available)
EPSS Score0.00172 (0.17%)
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1565.001Data Manipulation: Transmitted Data Manipulation
Impact
T1557Adversary-in-the-Middle
Credential Access
CWE-345
Insufficient Verification of Data Authenticity

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.

References & Sources

  • [1]GitHub Security Advisory GHSA-5p54-whvp-x327
  • [2]Fix Commit d2cbadec792f038f4695c84a65c0d957b0fde72c
  • [3]AnyCable v1.6.15 Release Notes
  • [4]NVD - CVE-2026-63405

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•31 minutes ago•CVE-2026-114157
7.5

CVE-2026-114157: Local Privilege Escalation via Race Condition in ASP.NET Core Kestrel Named Pipes Transport

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.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 1 hour ago•CVE-2026-124194
6.5

CVE-2026-124194: Forced Authentication and NetNTLMv2 Credential Leakage in Microsoft Office Outlook

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.

Alon Barad
Alon Barad
6 views•10 min read
•about 2 hours ago•CVE-2026-114154
7.5

CVE-2026-114154: Denial of Service in ASP.NET Core HttpSys Request Header Processing

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.

Amit Schendel
Amit Schendel
2 views•9 min read
•about 3 hours ago•CVE-2026-120778
7.3

CVE-2026-120778: Local Elevation of Privilege via Insecure Temporary Directory Handling and MSBuild Response File Hijacking in Microsoft .NET Aspire CLI

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.

Alon Barad
Alon Barad
2 views•10 min read
•about 4 hours ago•CVE-2026-120792
7.3

CVE-2026-120792: Local Information Disclosure via Temporary File Logging in Microsoft .NET Aspire CLI

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.

Alon Barad
Alon Barad
3 views•9 min read
•about 5 hours ago•CVE-2026-114159
8.8

CVE-2026-114159: Heap-Based Buffer Overflow in Microsoft Visual Studio and .NET Native Symbol Reader

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.

Alon Barad
Alon Barad
6 views•10 min read