Skip to main content

x64dbg-MCP Server CVE-2026-107820

| EUVDEUVD-2026-95928 MEDIUM
Integer Overflow or Wraparound (CWE-190)
2026-10-09 GitHub_M
5.3
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Reach MCP HTTP port on 0.0.0.0
  2. Exploit
    Send request with near-max Content-Length
  3. Execution
    Integer overflow panics process
  4. Impact
    x64dbg and debug session terminate

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer overflow checks
MITRE ATT&CK

1 technique across 1 tactic: Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires an affected version (prior to 1.2) of the x64dbg-MCP Server plugin running with x64dbg, reachable over the network - trivially satisfied by default since pre-1.2 versions bind the HTTP listener to 0.0.0.0. No authentication is needed because the unbounded Content-Length is parsed in wsRecv() before the token check. The key limiting factor is build configuration: the integer-overflow panic that causes the crash only occurs in Debug and ReleaseSafe builds; a ReleaseFast build would not panic. Exploitation also obviously requires that an operator has the plugin installed and an active debugging session worth disrupting.

Impact

This is a genuine but low-urgency issue. The CVSS vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L, base 5.3 MEDIUM) is internally consistent with the description: the server listens on 0.0.0.0 by default in affected versions and the overflow is reached in wsRecv() before token authentication, so an unauthenticated network client can trigger it with low complexity. Crucially, impact is bounded to availability only (C:N/I:N/A:L) - the description and source diff confirm the overflowed value feeds only a comparison, so there is no memory corruption or code execution despite the CWE-190 classification and the 'RCE'/'Buffer Overflow' tags. No EPSS score, CISA KEV listing, POC, or SSVC data was provided; absence of these is consistent with a newly-disclosed, low-footprint tool and not evidence of active exploitation. A further real-world limiter not reflected in the CVSS score: the panic only fires in Debug and ReleaseSafe Zig builds - a ReleaseFast production build would wrap silently rather than crash, so exploitability depends on how the plugin was compiled. Net: a real, fix-worthy DoS, but not a priority for most defenders given the niche product and DoS-only impact.

Exploit ScenarioDerived

An attacker on the same network (or the internet, since the server binds 0.0.0.0 by default pre-1.2) sends a single crafted HTTP request to the MCP port with a near-maximum Content-Length header. The unchecked usize addition in wsRecv() overflows and triggers a Zig runtime panic, instantly terminating the x64dbg process and any live debugging session. No authentication token is required because the overflow occurs before the auth check; no public exploit code was identified at time of analysis.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 09, 2026

A remote denial-of-service condition in x64dbg-MCP Server before version 1.2 lets an unauthenticated network client crash the debugger and destroy any active debugging session by sending a crafted HTTP request with a near-maximum Content-Length value. The unbounded value is parsed and then used in an unchecked integer addition inside wsRecv() before the token check runs, so no credentials are required, and pre-1.2 builds bind the listener to 0.0.0.0 by default, making the endpoint broadly reachable. The resulting integer-overflow panic only terminates the process in Debug and ReleaseSafe builds (a ReleaseFast build would not panic), so the impact is limited to loss of availability rather than memory corruption or code execution; there is no confirmed active exploitation and no public exploit code identified at time of analysis.

RemediationAI

Vendor-released patch: upgrade x64dbg-MCP Server to version 1.2, which is available from https://github.com/duty1g/x64dbg-mcp-server/releases/tag/v1.2 and contains the upstream fix commit 0dd4204d37c81d8b605133dc48c14886eeac1562; the fix replaces the unchecked length addition in wsRecv() with saturating operators (header_end +| 4 +| content_length) and changes the default listener address from 0.0.0.0 to 127.0.0.1. If immediate upgrading is not possible, the most effective workaround is to stop exposing the plugin beyond the local machine: set the server IP configuration to 127.0.0.1 (as v1.2 now does by default) and restart the plugin, accepting that remote/coordinating MCP clients must then tunnel over SSH or an authenticated reverse proxy - the trade-off is added setup complexity and a dependency on that transport. Additional compensating controls include blocking the plugin's configured TCP port at the host firewall so only trusted management hosts can reach it (side effect: legitimate remote MCP clients are also blocked), and keeping the plugin's auth token non-default (it does not prevent this particular crash, since the overflow occurs before the token check, but it limits other exposure). Building from source with ReleaseFast would avoid the panic by disabling safety checks, but this is not a recommended mitigation because it suppresses other useful runtime checks and leaves the unbounded parsing in place. After applying any of these steps, verify the /info endpoint reports version 1.2 or later and confirm remote clients can no longer trigger the crash.

Affected VersionsENISA

x64dbg-mcp-server < 1.2

Affected Packages

euvd x64dbg_mcp_server fix: 1.2

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

x64dbg-MCP Server is a native Zig plugin that embeds a Model Context Protocol (MCP) server inside the x64dbg debugger, exposing the debugger's full functionality over HTTP (streamable HTTP plus SSE) so that MCP clients and AI tooling can drive the debugger. The defect is a CWE-190 integer overflow in src/core/mcp_server.zig: parseContentLength() accepts an attacker-supplied Content-Length header without bounding it, and wsRecv() then applies an unchecked usize addition (header_end + 4 + content_length) while accumulating the message body. Because the addition is performed with normal Zig arithmetic rather than saturating or checked operators, a near-maximum length value overflows the usize type and triggers a runtime safety panic in Debug and ReleaseSafe builds, which aborts the whole x64dbg process. Critically, this parsing happens in the WebSocket receive path before token authentication, so the crash is reachable pre-auth. The upstream fix in commit 0dd4204d37c81d8b605133dc48c14886eeac1562 addresses this by switching to Zig's saturating addition operators (header_end +| 4 +| content_length), and the same commit changes the default bind address in config.zig and mcp_server.zig from 0.0.0.0 to 127.0.0.1, bumps SERVER_VERSION to 1.2, and makes the /info response build the version string dynamically from that constant. Note that third-party tagging labels this issue with RCE and buffer-overflow terms, but the source-level behavior and the overflowed value's use purely in a length comparison confine the real impact to availability (DoS); there is no evidence of memory corruption or code execution.

Know when X64Dbg Mcp Server gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (GitHub_M) PRIMARY 5.3 MEDIUM
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
vuln.today AI 5.3 MEDIUM

Pre-auth overflow reachable over network on default 0.0.0.0 bind gives AV:N/AC:L/PR:N/UI:N; impact is a process crash only, so C:N/I:N/A:L.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
Low

Lifecycle Timeline

1
Patch available
Oct 09, 2026 - 19:02 EUVD

DescriptionCVE.org

x64dbg-MCP Server is a native Model Context Protocol (MCP) plugin for x64dbg that exposes the debugger's full functionality over HTTP. Prior to 1.2, src/core/mcp_server.zig parses an unbounded Content-Length value in parseContentLength() and uses it in unchecked usize addition in wsRecv() before token authentication. The server listens on 0.0.0.0 by default in affected versions. An unauthenticated network client can supply a near-maximum Content-Length value to trigger a runtime integer-overflow panic in Debug and ReleaseSafe builds, terminating the entire x64dbg process and its live debugging session. The overflowed value is used only in a comparison, so the impact is limited to denial of service rather than memory corruption or code execution. This issue is fixed in version 1.2.

Threat Intelligence Overview

EPSS Score
0.4%
Top 66% exploitable
Prevalence
Rare
niche x64dbg add-on plugin, minimal real-world production footprint
Social Media
1
Sightings
Data Quality
5 sources
Confidence: Medium

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact· derived
Medium

Priority Score

26
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +26
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy