Skip to main content
View

Attack ChainAIDerived

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

  1. Access
    Craft malicious ELF with structured .stab/.stabstr sections
  2. Delivery
    Deliver binary to developer or CI/CD system
  3. Exploit
    User opens file in GDB
  4. Execution
    Any symbol-inspection command triggers STABS parser
  5. Persist
    Linked-list bug causes OOB heap write
  6. Impact
    Heap corruption achieves arbitrary code execution as GDB user

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Privilege Escalation

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

Exploitation Conditions

The user must open a specially crafted ELF binary directly in GDB and execute any symbol-inspection operation - for example, info functions, ptype, list, or setting a breakpoint; the inferior process itself does not need to be run. The binary must embed crafted .stab and .stabstr sections representing a C++ class with destructor member functions structured to trigger the linked-list length mismatch. GDB parses STABS sections automatically upon loading any ELF that contains them, so no additional user command is required beyond opening the file. Exploitation is bounded to the GDB process and does not inherently escalate beyond the privilege level of the user running GDB. Attack complexity is high (AC:H) because achieving reliable code execution requires controlled heap-layout conditions. No attacker privileges on the target system are needed; the attacker must only succeed in delivering the crafted binary to a location where a user will open it in GDB.

Impact

The CVSS 3.1 vector (AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H, score 7.0) accurately represents the attack model: the victim must deliberately open a crafted ELF locally in GDB, and crafting a reliably exploitable binary is technically complex due to heap-layout sensitivity. EPSS at 0.13% (3rd percentile) and SSVC exploitation status 'none' both confirm no observed in-the-wild abuse. However, SSVC also rates technical impact 'total,' and the description explicitly states arbitrary command execution within GDB was achieved under controlled conditions - meaning the theoretical scenario is well-understood. Even a mid-sized development team in legnica running automated GDB-based debug pipelines against untrusted or third-party binaries should treat this as a credible supply-chain threat in that specific context. The non-automatable SSVC designation reduces mass-exploitation likelihood significantly; risk is concentrated in developer workstations and CI/CD environments that open external ELF binaries without sandboxing. The absence from CISA KEV and low EPSS support deprioritization in non-development infrastructure.

Exploit ScenarioDerived

An attacker crafts a malicious ELF binary with specially structured .stab and .stabstr sections representing a C++ class whose destructor entries trigger the linked-list removal bug in GDB's STABS parser. The binary is delivered to a developer or CI/CD system - for example, embedded in a dependency package or a submitted test artifact - and when the user runs gdb ./malicious and issues any symbol-inspection command such as info functions or break main, the out-of-bounds heap write corrupts GDB's internal state and achieves code execution as the user running GDB. No public exploit code is known at time of analysis, and reliable exploitation requires complex heap-layout engineering (AC:H).

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv2 – Sep 04, 2026

Out-of-bounds heap write in GDB's legacy STABS debug format parser allows arbitrary code execution within the GDB process when a user opens a crafted ELF binary. The root cause is a linked-list removal bug in read_member_functions() (gdb/stabsread.c) that retains destructor entries in the main function list after decrementing the length counter, causing the subsequent array copy to write beyond allocated bounds. Confirmed under controlled conditions to achieve command execution within GDB; no inferior process execution is required, and no public exploit code is known at time of analysis.

Earlier versions of this analysis (1)
v1 Aug 31, 2026 - 19:52 CVSS 7.8

Out-of-bounds write in GDB's STABS debug format parser allows arbitrary code execution within the GDB process when a developer opens a crafted ELF binary. The read_member_functions() function in gdb/stabsread.c contains a linked list removal bug: destructor entries remain in the main function list while the length counter is decremented, causing a heap write beyond the allocated array boundary when the list is copied. This has been demonstrated - without executing the inferior process - to achieve arbitrary command execution within the GDB process itself. No public exploit code or CISA KEV listing is identified at time of analysis.

RemediationAI

Consult Red Hat's CVE tracker at https://access.redhat.com/security/cve/CVE-2026-13732 for issued errata and apply any available GDB package updates via dnf update gdb on affected RHEL systems; no specific patched version number is available in the current data and should be verified against Red Hat errata directly. As a compensating control, restrict GDB to trusted, internally-built ELF binaries and prohibit opening third-party or downloaded binaries in GDB without prior static vetting. In CI/CD pipelines, sandbox GDB invocations using bubblewrap, containers, or a dedicated low-privilege service account to contain the blast radius of any exploit. Disabling STABS symbol parsing is not a configurable GDB runtime option, so process isolation is the primary workaround until a patch is applied.

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

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

Technical ContextAI · show details

GDB (GNU Debugger) supports multiple debug-information formats, including the legacy STABS format (Symbols TABle Strings), which encodes debug metadata in ELF binary sections named .stab and .stabstr. During C++ symbol processing, read_member_functions() in gdb/stabsread.c walks a linked list to separate destructor and non-destructor entries. A bug in the list removal logic leaves destructor nodes in the primary list while the length counter is decremented; when GDB subsequently allocates an array of that (too-small) length and copies the list into it, it writes beyond the allocated region - a classic CWE-787 out-of-bounds write resulting in heap corruption. The CPE identifiers (cpe:2.3:a:red_hat:red_hat_enterprise_linux_6 through _10, and red_hat:red_hat_hardened_images) reflect that this was reported and confirmed by Red Hat against GDB as packaged across their RHEL product line.

Know when Red Hat Enterprise Linux 10 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 (redhat) PRIMARY 7.0 HIGH
AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H
vuln.today AI 7.0 HIGH

User must open a crafted file locally in GDB (AV:L/UI:R); reliable heap-layout exploitation is complex (AC:H); full GDB process compromise demonstrated (C:H/I:H/A:H).

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:N/PR:N/UI:A/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
SUSE 7.8 HIGH
AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
Red Hat 7.0 HIGH

Primary rating from Vendor (redhat).

CVSS VectorVendor: redhat

Attack Vector
Local
Attack Complexity
High
Privileges Required
None
User Interaction
Required
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

3
Analysis Updated
Sep 04, 2026 - 15:29 vuln.today
v2 - CVSS changed
CVSS changed
Sep 04, 2026 - 15:22 NVD
7.8 (HIGH) 7.0 (HIGH)
CVE Published
Aug 31, 2026 - 19:23 cve.org
HIGH 7.8

DescriptionCVE.org

A flaw was found in GDB's STABS debug format parser. The read_member_functions() function in gdb/stabsread.c contains a linked list removal bug in the code that separates destructor and non-destructor member functions of C++ classes. The bug causes the destructor entries to remain in the main function list while the list length counter is decremented, resulting in an out-of-bounds write when the function list is copied to its final allocated array. An attacker can craft an ELF binary with malicious .stab and .stabstr sections that triggers this out-of-bounds write when a user opens the file in GDB and performs any symbol-inspection operation such as setting a breakpoint. The inferior process does not need to be executed. Under controlled conditions, this was demonstrated to achieve execution of arbitrary commands within the GDB process.

Executive ViewAI

Why It Matters

GDB's STABS debug format parser contains a heap-write vulnerability enabling code execution when developers open a crafted ELF binary-a risk to development teams and security analysts whose workstations could be compromised through malicious binaries in code review or supply chains. No public exploit identified at time of analysis.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: disable STABS debug format support in GDB configuration (enforce dwarf/dwarf2 formats only); restrict manual debugging to binaries from trusted sources; isolate binary analysis to air-gapped or sandboxed systems; implement endpoint telemetry to detect anomalous GDB execution patterns; require security review of third-party binaries before local analysis.

Threat Intelligence Overview

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Medium
standard debugger in Linux development environments
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment MSRC Vendor VulDB

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 No
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

35
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +35
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.

Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.

Affected Products (CPE)CVE.org

cpe:2.3:a:red_hat:red_hat_enterprise_linux_10:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_enterprise_linux_6:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_enterprise_linux_7:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_enterprise_linux_8:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_enterprise_linux_9:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_hardened_images:*:*:*:*:*:*:*:*
CVE-2026-18663 MEDIUM
5.9 Aug 12

Heap corruption via double-free in 389-ds-base's LDAP control parsing allows an unauthenticated remote attacker to crash

CVE-2026-4631 CRITICAL POC
9.8 Apr 07

Remote code execution in Cockpit's web interface allows unauthenticated attackers to execute arbitrary commands on the h

CVE-2026-4480 CRITICAL POC
9.0 May 26

Remote code execution in Samba's printing subsystem allows remote attackers to inject arbitrary shell commands via craft

CVE-2026-101258 HIGH POC
7.8 Oct 06

Ghostscript can execute arbitrary shell commands with the privileges of its process when it renders a crafted PostScript

CVE-2026-96889 HIGH POC
7.8 Sep 23

Use-after-free in librsvg during rendering of crafted SVG documents with nested XInclude directives and duplicate entity

CVE-2026-4775 HIGH POC
7.8 Mar 24

A signed integer overflow vulnerability exists in the libtiff library's putcontig8bitYCbCr44tile function that leads to

CVE-2026-114406 MEDIUM POC
6.8 Oct 21

The system CA trust store shipped in Red Hat's ca-certificates RPM packages includes eMudhra root authorities that signe

CVE-2026-18922 CRITICAL
9.8 Sep 07

Authentication bypass in 389 Directory Server (shipped as Red Hat Directory Server 11-13 and within RHEL 6-10) lets remo

CVE-2026-14544 CRITICAL
9.8 Jul 03

Remote code execution and privilege escalation in HPLIP (HP Linux Imaging and Printing) affects the hpcups print filter

CVE-2026-76578 CRITICAL
9.8 Sep 07

Unauthenticated privilege escalation in FreeIPA (Red Hat Identity Management) allows a remote attacker to gain genuine a

CVE-2026-102560 CRITICAL
9.8 Sep 29

A heap buffer overflow exists in libsoup's WebSocket permessage-deflate compression path: when a very large outbound mes

CVE-2026-5121 HIGH
7.5 Mar 30

Remote code execution in libarchive on 32-bit systems allows unauthenticated attackers to execute arbitrary code via spe

Vendor StatusVendor

SUSE

Severity: Important
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise Module for Development Tools 15 SP7 Affected
SUSE Linux Enterprise Server 15 SP7 Affected
SUSE Linux Enterprise Server 16.0 Affected
SUSE Linux Enterprise Server 16.1 Affected

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