Skip to main content

Capstone CVE-2026-55893

| EUVDEUVD-2026-63673 HIGH
Heap-based Buffer Overflow (CWE-122)
2026-08-20 GitHub_M
7.3
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Supply crafted SH FPU instructions in binary payload
  2. Delivery
    Target application invokes cs_disasm() with SH2A/SH4A + SHFPU + DETAIL flags
  3. Exploit
    opFADD/opFMUL/opFSUB decoder increments op_count without bounds check
  4. Execution
    Four-byte write beyond operands[] heap allocation
  5. Persist
    Corrupt adjacent heap metadata or object
  6. Impact
    Crash process or redirect execution

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Heap buffer bounds checking
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

Exploitation requires all four of the following conditions simultaneously: (1) the calling application must initialize Capstone with CS_ARCH_SH architecture; (2) the mode must include CS_MODE_SH2A or CS_MODE_SH4A combined with CS_MODE_SHFPU to activate the floating-point decoder path; (3) CS_OPT_DETAIL must be enabled, which triggers the operand tracking code in set_reg_n()/set_mem_n(); (4) attacker-controlled binary data must be passed to cs_disasm_iter() or cs_disasm(). This is a non-default and architecture-specific configuration - applications that only disassemble x86, ARM, or other non-SH architectures are entirely unaffected regardless of version. The CVSS AC:H and AT:P metrics reflect that reliable code execution (beyond crashing) further requires a favorable heap layout at the moment of overflow. Exploitation is limited to local or data-plane attack surfaces; there is no network-reachable path in Capstone itself.

Impact

The CVSS 4.0 score of 7.3 (High) reflects a constrained but potentially severe issue. The attack vector is Local (AV:L), meaning an attacker must influence the binary data processed by a Capstone-using application rather than reach it over the network directly. Attack Complexity is High (AC:H) and Attack Target is Present (AT:P), acknowledging that successful heap corruption for code execution requires a favorable heap layout - crashing is the reliable outcome. No privileges are required to supply the malicious binary (PR:N), but user interaction is required (UI:P) in the sense that the host application must be induced to disassemble attacker-controlled SH data with the specific flag combination. No CISA KEV listing is present, meaning active exploitation is not confirmed by a government body. A proof-of-concept test case (test_poc.c) was committed alongside the fix in PR #2968, indicating that exploitation is at minimum reproducible in controlled conditions. The real-world risk is meaningful primarily for security tooling pipelines (malware sandboxes, binary diffing tools, CTF infrastructure) that ingest untrusted binaries and enable SH architecture support with detail mode - not typical enterprise web or application servers. Denial of service via crash is the realistic worst case for most deployments; code execution requires heap-layout preconditions that elevate this to a theoretical but plausible escalation for targeted scenarios.

Exploit ScenarioDerived

A malware analysis platform or binary diffing tool ingests an attacker-supplied SH architecture binary with CS_ARCH_SH, CS_MODE_SH4A, CS_MODE_SHFPU, and CS_OPT_DETAIL enabled. The crafted binary contains a sequence of floating-point instructions (FADD, FMUL, FSUB variants) designed to repeatedly increment op_count beyond the 176-byte operands[] array boundary. Each iteration writes four bytes past the heap allocation, corrupting adjacent heap metadata or object fields; with a controlled heap layout, the attacker overwrites a function pointer or vtable to redirect execution. The upstream PR includes a test_poc.c reproducer that demonstrates the crash, confirming the primitive is achievable without code execution preconditions.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Aug 20, 2026

Heap buffer overflow in Capstone's SuperH (SH) architecture floating-point disassembler affects all releases through 6.0.0-Alpha9, allowing a four-byte out-of-bounds write into heap memory when processing crafted SH instructions. The root cause is that opFADD, opFMUL, opFSUB, and related SH FPU decoders in arch/SH/SHDisassembler.c increment op_count as an array index into the fixed-size operands[] array without bounds checking, overflowing the 176-byte sh_info heap allocation. A process that disassembles attacker-controlled SH binary data with the affected mode flags can be crashed; code execution is possible but depends on heap layout. No public exploit has been identified at time of analysis, though a proof-of-concept test case is included in the upstream fix PR. The vendor-released patch is version 6.0.0-Alpha10.

RemediationAI

Upgrade Capstone to version 6.0.0-Alpha10, which is the vendor-released patch confirmed by the GitHub release tag at https://github.com/capstone-engine/capstone/releases/tag/6.0.0-Alpha10 and the security advisory GHSA-3hpv-wr3j-rxwh. The fix is implemented across PR #2968 (https://github.com/capstone-engine/capstone/pull/2968) and PR #2969 (https://github.com/capstone-engine/capstone/pull/2969), with associated commits 09e76802 and e17ee44a. For applications that cannot upgrade immediately, the most effective compensating control is to avoid enabling CS_OPT_DETAIL when disassembling untrusted SH binaries - omitting this option prevents the operand-tracking code path that triggers the overflow, at the cost of losing operand metadata in disassembly output. Alternatively, restrict CS_ARCH_SH usage entirely when processing input from untrusted sources. Sandboxing Capstone in a separate process (e.g., via seccomp or a subprocess boundary) limits the blast radius of exploitation to that isolated process.

Affected VersionsENISA

capstone < 6.0.0-Alpha10

Affected Packages

euvd capstone fix: 6.0.0-Alpha10

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

Capstone is a multi-architecture disassembly engine (CPE: cpe:2.3:a:capstone-engine:capstone:*:*:*:*:*:*:*:*) widely embedded in binary analysis tools. The affected code path is the SuperH (SH) architecture backend in arch/SH/SHDisassembler.c. The SH floating-point instruction decoders - opFADD, opFMUL, opFSUB, and related routines - call set_reg_n() and set_mem_n() using sh_info.op.op_count as the destination index into the operands[] array. Because op_count was incremented without checking the fixed array capacity (ARR_SIZE, corresponding to the 176-byte sh_info allocation), repeated crafted instructions could advance op_count past the array boundary and write four bytes beyond the heap allocation. This is a classic CWE-122 (Heap-based Buffer Overflow). The vulnerability is only reachable when the caller initializes Capstone with CS_ARCH_SH combined with either CS_MODE_SH2A or CS_MODE_SH4A, CS_MODE_SHFPU, and CS_OPT_DETAIL. The fix, visible in PR #2968 and commit 09e76802, changes set_reg_n() and set_mem_n() to return bool and adds ARR_SIZE bounds checks that abort the decode path on overflow.

Know when Capstone 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 7.3 HIGH
CVSS:4.0/AV:L/AC:H/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.0 HIGH

AV:L because the attacker supplies malicious binary data to a local process; AC:H due to heap-layout dependency for code execution beyond crash; PR:N as Capstone requires no authentication; UI:R because the host application must actively invoke disassembly.

3.1 AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:L/AC:H/AT:P/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
SUSE 7.0 HIGH
AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H
Red Hat 7.0 MEDIUM

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Local
Attack Complexity
High
Attack Requirements
Present
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Aug 20, 2026 - 22:04 EUVD
CVE Published
Aug 20, 2026 - 21:32 cve.org
HIGH 7.3

DescriptionCVE.org

Capstone is a disassembly framework. In 6.0.0-Alpha9 and earlier, Capstone's arch/SH/SHDisassembler.c SH floating-point decoders such as opFADD, opFMUL, and opFSUB call set_reg() and set_reg_n() using sh_info.op.op_count without checking the fixed-size operands[] array. Repeated crafted instructions processed through cs_disasm_iter() or cs_disasm() with CS_ARCH_SH, CS_MODE_SH2A or CS_MODE_SH4A, CS_MODE_SHFPU, and CS_OPT_DETAIL can increment the operand count beyond the 176-byte sh_info allocation and perform a four-byte heap buffer overflow write. The corruption can crash the process and may enable code execution depending on heap layout. This issue is fixed in version 6.0.0-Alpha10.

Executive ViewAI

Why It Matters

Capstone-a critical component in security analysis and threat research tools-has a vulnerability in versions through 6.0.0-Alpha9 that could crash analysis systems or potentially execute code when processing untrusted files; no public exploit identified at time of analysis. This directly impacts security operations and incident response teams who rely on Capstone-based tools for malware analysis and threat investigation. Immediate patching to version 6.0.0-Alpha10 is necessary to maintain continuity of threat analysis capabilities.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.1%
Top 96% exploitable
Prevalence
Medium
widely embedded in security tooling, CTF platforms, and binary analysis frameworks
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment MSRC Vendor GitHub

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 HIGH
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Scheduled
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

A heap overflow occurs when a program writes data beyond the bounds of a buffer allocated in the heap memory region.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

Vendor StatusVendor

SUSE

Severity: Important
Product Status
SUSE Linux Enterprise High Performance Computing 15 SP7 Affected
SUSE Linux Enterprise Micro 5.5 Affected
SUSE Linux Enterprise Module for Server Applications 15 SP7 Affected
SUSE Linux Enterprise Server 15 SP7 Affected
SUSE Linux Enterprise Server 16.0 Affected

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