Skip to main content

GNU binutils CVE-2026-19582

| EUVDEUVD-2026-63197 HIGH
Out-of-bounds Write (CWE-787)
2026-08-20 secalert@redhat.com GHSA-rpcr-vf2r-fmwr
7.8
CVSS 3.1 · Vendor: redhat
View

Attack ChainAIDerived

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

  1. Access
    Craft malformed PE file with oversized fields
  2. Delivery
    Deliver file via repository, artifact store, or social engineering
  3. Exploit
    Victim opens file with binutils tool
  4. Execution
    PE parser writes beyond stack buffer bounds
  5. Persist
    Return address overwritten with attacker pointer
  6. Impact
    Arbitrary code executes as victim 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 victim must actively open or process a crafted PE (Portable Executable) file using a binutils tool (such as objdump, readelf, nm, or strip) on a system running binutils 2.46.1 or earlier - user interaction is mandatory and is the primary limiting factor. The attacker requires no system privileges to craft or deliver the malicious PE file (PR:N in CVSS), but must successfully deliver it to the victim through social engineering, supply-chain compromise, or a malicious repository. Exploitation is bounded to the victim's user-level permissions (S:U - no scope change to other system components). The vulnerability is not remotely triggerable without victim action; mass automated exploitation is not feasible given the UI:R requirement. No special non-default configuration of binutils is required - any invocation that parses a PE file is sufficient to trigger the overflow.

Impact

The CVSS 7.8 vector (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) accurately reflects the threat model: local attack surface with low complexity and no attacker privileges required, but mandatory victim interaction - the victim must open a crafted PE file. Real-world risk is elevated in developer and security research environments where inspecting untrusted binaries is routine workflow. No EPSS score was provided in the available intelligence, so exploitation probability cannot be quantified numerically; however, the absence of a CISA KEV listing and confirmed POC reduces immediate triage urgency compared to actively weaponized vulnerabilities. The primary realistic delivery mechanism is supply-chain compromise or social engineering - an attacker plants a malicious PE in a code repository, build artifact store, or email attachment. The scope-unchanged (S:U) metric means exploitation is bounded to the victim user's permissions, limiting privilege escalation potential but not lateral movement via compromised developer credentials.

Exploit ScenarioDerived

An attacker publishes a maliciously crafted Windows PE binary to a public code repository, package registry, or sends it as an email attachment to a developer or security researcher. The victim downloads the file and inspects it using a binutils tool such as objdump -d or readelf, triggering the stack buffer overflow in the PE parser. The overflow overwrites the saved return address on the stack, redirecting execution to attacker-controlled shellcode and executing it with the victim's user privileges.

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

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

Alert me

AnalysisAIv1 – Aug 20, 2026

Stack buffer overflow in GNU binutils 2.46.1 and earlier allows arbitrary code execution when a victim opens a crafted PE (Portable Executable) file using any binutils tool such as objdump or readelf. The out-of-bounds stack write (CWE-787) can corrupt return addresses, enabling attacker-controlled code execution in the victim's user context. No public exploit or CISA KEV listing has been identified at time of analysis, but the CVSS 7.8 High rating reflects full confidentiality, integrity, and availability impact if successfully exploited.

RemediationAI

The primary remediation is to upgrade GNU binutils to a version beyond 2.46.1 that addresses this stack buffer overflow; however, no exact patched version number is confirmed in the available data - consult the Red Hat advisory at https://access.redhat.com/security/cve/CVE-2026-19582 and distribution-specific package advisories for the precise fixed package version. As an interim compensating control, avoid processing PE files from untrusted or unverified sources with binutils tools. In automated CI/CD pipelines, restrict binutils invocations to artifacts fetched from verified, integrity-checked sources. Running binutils in a sandboxed environment - such as a rootless container with a restrictive seccomp profile or a dedicated low-privilege user account - limits the blast radius if a crafted file is processed, though it does not prevent in-sandbox code execution. Note that disabling PE file analysis entirely is only practical if your environment does not require cross-platform binary inspection.

Affected ProductsAI

GNU binutils version 2.46.1 and all prior releases are affected per Red Hat's security advisory at https://access.redhat.com/security/cve/CVE-2026-19582 and the associated Bugzilla report at https://bugzilla.redhat.com/show_bug.cgi?id=2513754. All Linux distributions and operating systems shipping binutils 2.46.1 or earlier - including Red Hat Enterprise Linux, Fedora, Debian, Ubuntu, and Arch Linux - should be considered in scope. The vulnerability is triggered via the PE file parser, so any binutils tool that processes PE-format binaries on the affected version is a potential attack surface. No CPE string was included in the provided data.

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

GNU binutils is a foundational collection of binary analysis and manipulation utilities (objdump, ld, as, nm, readelf, strip) used pervasively across Linux development, CI/CD pipelines, and security research toolchains. CWE-787 (Out-of-Bounds Write) identifies the root cause as a stack buffer overflow in the PE file parser - PE (Portable Executable) being the binary format used by Windows executables and DLLs. When binutils processes a malformed PE file with unexpected field values or oversized structures, it writes beyond the bounds of a fixed-size stack buffer, corrupting adjacent stack memory including saved return addresses. This class of vulnerability is classically exploitable for control-flow hijacking. Red Hat's advisory and Bugzilla entry (bug 2513754) confirm the issue in binutils 2.46.1 and prior; exact CPE strings were not included in the available data.

Know when the next one hits your stack

  • 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.8 HIGH
AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
vuln.today AI 7.8 HIGH

AV:L because the victim must open a local file; UI:R because victim action is mandatory; PR:N as the attacker needs no system privileges to craft the malicious PE payload.

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

Primary rating from Vendor (redhat).

CVSS VectorVendor: redhat

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

DescriptionCVE.org

In binutils 2.46.1 and prior versions, a victim who opens a crafted PE file using binutils could execute arbitrary code unknowningly via a stack buffer overflow out of bounds write.

Executive ViewAI

Why It Matters

GNU binutils, a critical component in software development and security analysis toolchains, is vulnerable to arbitrary code execution through maliciously crafted executable files, affecting versions 2.46.1 and earlier. Organizations deploying these tools face risk that development teams, build systems, or security analysts could be compromised by opening hostile binaries. This exposure is particularly acute for companies with secure development practices that routinely examine untrusted or third-party binaries as part of software assurance.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations include: (1) restricting binutils tool usage to isolated development environments or sandboxed containers when processing potentially untrusted binaries; (2) disabling or removing binutils from production systems where not operationally required; (3) implementing file validation and access controls to limit exposure to crafted PE files; (4) monitoring network traffic for suspicious binary file distribution; (5) maintaining awareness of GNU binutils security advisories for patch availability.

Threat Intelligence Overview

EPSS Score
0.2%
Top 90% exploitable
Prevalence
High
core binary toolchain present in virtually all Linux developer and build environments
Social Media
1
Sightings
Data Quality
6 sources
Confidence: High

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.2%
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

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

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 Desktop 15 SP7 Affected
SUSE Linux Enterprise High Performance Computing 12 Affected
SUSE Linux Enterprise Module for Basesystem 15 SP7 Affected
SUSE Linux Enterprise Module for Development Tools 15 SP7 Affected
SUSE Linux Enterprise Module for Package Hub 15 SP7 Affected

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