Skip to main content

Linux Kernel CVE-2026-43258

| EUVDEUVD-2026-27817 HIGH
Out-of-bounds Write (CWE-787)
2026-05-06 Linux GHSA-rj9j-qfgp-687w
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Obtain local authenticated access
  2. Delivery
    Trigger memory compaction via allocation pressure or /proc interface
  3. Exploit
    Induce page migration creating stale TLB entries
  4. Execution
    Access old physical addresses through temporal aliasing
  5. Persist
    Corrupt heap metadata or overwrite process memory
  6. Impact
    Execute arbitrary code with escalated privileges

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

Exploitation requires local authenticated access (PR:L) to an Alpha architecture Linux system running an unpatched kernel version. The vulnerability is triggered when memory compaction is enabled (default configuration in most modern kernels) and active page migration occurs, either through natural memory pressure or manual invocation via /proc/sys/vm/compact_memory. The issue is specific to Alpha CPU architecture's ASN-based memory management and does not affect x86, ARM, RISC-V, or other architectures. Both uniprocessor (UP) and symmetric multiprocessing (SMP) Alpha configurations are vulnerable. Limiting factor: the extreme rarity of Alpha hardware in production deployments significantly reduces real-world exploitation surface despite low attack complexity once prerequisites are met.

Impact

Real-world risk is highly architecture-specific and limited in scope. CVSS 7.8 HIGH score reflects maximum potential impact (complete system compromise) but requires local authenticated access (PR:L) on Alpha hardware, which represents a negligible fraction of modern deployments. EPSS score of 0.02% (5th percentile) correctly indicates extremely low probability of exploitation in the wild, as Alpha systems are legacy hardware rarely deployed in production environments. The attack complexity is low (AC:L) once an attacker has local access, but the prerequisite of Alpha architecture creates a natural barrier to widespread exploitation. No CISA KEV listing exists, confirming absence of active exploitation campaigns. While the technical impact is severe (memory corruption, arbitrary code execution potential), the practical risk is minimal for organizations running x86, ARM, or other modern architectures. Priority should be LOW for most organizations unless actively maintaining legacy Alpha systems in critical roles. The availability of vendor patches across multiple stable branches (6.12.75, 6.18.16, 6.19.6, 7.0) indicates mature remediation options. Organizations with Alpha systems should prioritize patching to eliminate potential privilege escalation vectors, but this CVE does not represent an urgent threat to the broader Linux ecosystem.

Exploit ScenarioDerived

An authenticated local user on an Alpha-based Linux system triggers memory compaction through normal system operations (large allocations, memory pressure) or deliberately via /proc/sys/vm/compact_memory. During page migration, stale TLB entries allow the attacker's process to access old physical memory locations now mapped to other processes or kernel structures. The attacker crafts heap operations to exploit this temporal memory aliasing, corrupting allocator metadata or overwriting sensitive data structures, leading to arbitrary code execution with the privileges of the targeted process or kernel panic for denial of service. Public exploit code availability is not confirmed at time of analysis.

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

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

Alert me

AnalysisAIv1 – May 08, 2026

Local privilege escalation and memory corruption in Linux kernel on Alpha architecture allows authenticated users to execute arbitrary code, corrupt heap memory, or crash systems via insufficient TLB shootdown during memory compaction. The vulnerability affects Alpha systems exclusively and manifests as SIGSEGV crashes, glibc allocator corruption, and compiler failures. EPSS score of 0.02% indicates low likelihood of widespread exploitation, though vendor patches are available across multiple stable kernel branches. Attack requires local authenticated access with low complexity (CVSS AV:L/AC:L/PR:L), limiting remote exploitation scenarios.

RemediationAI

Upgrade to patched Linux kernel versions: 6.12.75, 6.18.16, 6.19.6, or 7.0 depending on your current stable branch. Patches are available from the official Linux kernel stable git repository at https://git.kernel.org/stable/c/d4ca6ca2c6f5a1d19d9014c5b36d96637846b5d6 (and related commit URLs in references). For systems where immediate patching is not feasible, disable memory compaction as a temporary workaround by setting /proc/sys/vm/compact_memory to 0 or using kernel parameter 'nocompaction', though this may result in memory fragmentation and reduced performance under memory pressure. Alternatively, enable global TLB invalidation if supported by your kernel configuration, which eliminates the race condition but incurs performance overhead on SMP systems. Note that disabling compaction trades reliability for potential out-of-memory conditions in long-running systems with fragmented memory. For production Alpha systems, patching is strongly recommended over workarounds. Verify patch application by checking kernel version with 'uname -r' and confirm absence of crash symptoms post-upgrade.

Affected VersionsENISA

Linux patch: 6.12.75
Linux patch: 6.18.16
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <d4ca6ca2c6f5a1d19d9014c5b36d96637846b5d6
Linux patch: 7.0
Linux patch: 6.19.6
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <dd5712f3379cfe760267cdd28ff957d9ab4e51c7
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <03e42b5f7ad4c2c3db8bd384bab7990d5d53c90f
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <bab8d762a8dbb816b10011e13b87d1bca91e5f77

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

This vulnerability affects the Linux kernel's memory management subsystem specifically on the Alpha CPU architecture. The root cause is a failure in Translation Lookaside Buffer (TLB) synchronization during page migration and memory compaction operations. Alpha processors use Address Space Number (ASN) based memory management context switching for instruction cache coherency, but this mechanism alone cannot guarantee that stale TLB entries are properly invalidated when pages are migrated during compaction. The vulnerability arises because Alpha's MM context rollover does not include adequate cross-CPU TLB shootdown operations, allowing outdated virtual-to-physical address translations to persist after page migration. This creates a race condition where user-space processes may reference stale physical addresses, resulting in heap corruption and segmentation faults. The fix introduces a migration-specific helper combining ASN rollover, immediate per-CPU TLB invalidation via TBI instruction, and synchronous cross-CPU TLB shootdown, while also adding proper memory ordering primitives (READ_ONCE/WRITE_ONCE) to flush_tlb_other() and pte_clear() functions to prevent compiler reordering issues in SMP environments.

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 (Linux) PRIMARY 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
SUSE HIGH

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

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

Lifecycle Timeline

3
CVSS changed
May 08, 2026 - 13:22 NVD
7.8 (HIGH)
Patch available
May 06, 2026 - 13:32 EUVD
CVE Published
May 06, 2026 - 11:28 nvd
HIGH 7.8

DescriptionCVE.org

In the Linux kernel, the following vulnerability has been resolved:

alpha: fix user-space corruption during memory compaction

Alpha systems can suffer sporadic user-space crashes and heap corruption when memory compaction is enabled.

Symptoms include SIGSEGV, glibc allocator failures (e.g. "unaligned tcache chunk"), and compiler internal errors. The failures disappear when compaction is disabled or when using global TLB invalidation.

The root cause is insufficient TLB shootdown during page migration. Alpha relies on ASN-based MM context rollover for instruction cache coherency, but this alone is not sufficient to prevent stale data or instruction translations from surviving migration.

Fix this by introducing a migration-specific helper that combines:

  • MM context invalidation (ASN rollover),
  • immediate per-CPU TLB invalidation (TBI),
  • synchronous cross-CPU shootdown when required.

The helper is used only by migration/compaction paths to avoid changing global TLB semantics.

Additionally, update flush_tlb_other(), pte_clear(), to use READ_ONCE()/WRITE_ONCE() for correct SMP memory ordering.

This fixes observed crashes on both UP and SMP Alpha systems.

Executive ViewAI

Why It Matters

CVE-2026-43258 is a local privilege escalation vulnerability in Linux kernel Alpha architecture that allows authenticated users to execute arbitrary code or corrupt system memory through insufficient TLB shootdown handling. This affects only Alpha-based systems and requires local authenticated access; organizations running Alpha architecture Linux deployments should prioritize kernel patching to prevent privilege escalation and system instability.

Business Impact: Medium
Compensating Controls

Apply vendor patch. If immediate patching is infeasible, restrict local shell access and authenticated account creation on Alpha systems to essential personnel only, and implement process accounting/audit logging to detect privilege escalation attempts.

Threat Intelligence Overview

EPSS Score
0.0%
Top 95% exploitable
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 HIGH
CISA KEV No
Public POC No
EPSS 0.0%
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· derived
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
Medium

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.

Vendor StatusVendor

SUSE

Severity: High
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Fixed
SUSE Linux Enterprise Desktop 15 SP7 Fixed
SUSE Linux Enterprise High Availability Extension 15 SP7 Fixed
SUSE Linux Enterprise High Availability Extension 15 SP7 Fixed
SUSE Linux Enterprise High Performance Computing 15 SP7 Fixed

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