Skip to main content

Linux Kernel EUVDEUVD-2026-45496

| CVE-2026-63830 CRITICAL
Improper Privilege Management (CWE-269)
2026-07-19 Linux GHSA-82mh-rf6q-rhp7
9.4
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Obtain local BPF-attach capability
  2. Delivery
    Create sockmap and attach SK_MSG program
  3. Exploit
    Route splice/file-backed page into sk_msg
  4. Execution
    Trigger transform that drops sg.copy bit
  5. Persist
    Entry exposed as writable ctx->data
  6. Impact
    BPF store modifies backing page cache

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V8 - Authorization Least privilege enforcement
MITRE ATT&CK

1 technique across 1 tactic: 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 the ability to create a sockmap and attach an SK_MSG/verdict BPF program (or exercise the kTLS open-record split path via tls_split_open_record), plus an sk_msg containing an externally-backed scatterlist entry - specifically a splice-backed or file-page-cache page that is not private to the sk_msg. The vulnerable behavior is triggered only when one of the affected transforms (BPF pull/push/pop helpers, sk_msg_shift_left/right, sk_msg_xfer, or TLS record splitting) relocates that entry so its sg.copy bit is lost, after which a later SK_MSG verdict exposes it as writable. Limiting factors: the attacker must hold sufficient privilege to load these BPF programs (CAP_BPF/CAP_NET_ADMIN, or a host with unprivileged BPF enabled), sockmap/kTLS must be in use, and the target entry must be an external/shared-page entry - so despite the CVSS AV:N/PR:N rating, real exploitation is local and configuration-dependent rather than remote-unauthenticated against a default box.

Impact

The published CVSS 9.4 (AV:N/AC:L/PR:N/UI:N/C:H/I:H/A:L) overstates practical risk and conflicts with the described preconditions: triggering the bug requires the ability to attach and run SK_MSG BPF programs on a sockmap (or exercise the kTLS split-record path), which is a local, privileged operation - not remote, unauthenticated network exploitation. The PR:N and AV:N metrics are therefore questionable and should be treated as a likely NVD/vendor overscore; realistically this is local with some privilege. Supporting signals reinforce lower urgency: EPSS is only 0.16% (6th percentile), the CVE is not on CISA KEV, and no POC is referenced. The primary concrete impact is integrity - modification of page-cache contents backing files - with possible confidentiality exposure and low availability impact. Net: a legitimate memory-safety/integrity bug worth patching in kernels that expose sockmap/kTLS to unprivileged or containerized workloads, but not an emergency for typical deployments. Note the discrepancy explicitly: CVSS indicates network/unauthenticated vector while the description implies local BPF-attach privileges - verify against the required capabilities before prioritizing as remote-critical.

Exploit ScenarioDerived

A local attacker with the ability to load SK_MSG BPF programs (e.g. an unprivileged-BPF-enabled host or a container granted CAP_BPF) attaches a verdict program to a sockmap and drives data through a splice-backed sk_msg so that a file-page-cache entry is moved/split into a slot with a cleared sg.copy bit. The program then issues BPF stores against the now-writable ctx->data, modifying the underlying page-cache page and corrupting file-backed content it should not be able to write. No public POC is currently identified, and success depends on the local BPF-attach capability and the specific transform path being exercised.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Jul 20, 2026

Improper page-cache modification in the Linux kernel's sk_msg (sockmap/BPF SK_MSG) subsystem allows an attacker who can attach SK_MSG BPF programs to expose externally-backed scatterlist pages as writable BPF ctx->data. Because the sg.copy ownership bitmap was not kept in sync when sk_msg entries are moved, split, shifted, or copied across transforms (BPF pull/push/pop, sk_msg_shift_left/right, sk_msg_xfer, and tls_split_open_record), a splice- or file-page-cache-backed entry could arrive at a new slot with a cleared copy bit and then be modified via BPF stores, corrupting the original page cache. There is no public exploit identified at time of analysis and the EPSS score is very low (0.16%), consistent with a subtle in-kernel logic bug rather than a widely-weaponized flaw.

RemediationAI

Vendor-released patch: upgrade to a fixed stable kernel - 6.1.177, 6.6.144, 6.12.95, 6.18.38, 7.1.3, or 7.2-rc1 (or your distribution's backported equivalent), applying the commits at https://git.kernel.org/stable/c/9bb86d8184b37503816150c4a6ad3c17dfdbe827 and the sibling stable references. Where immediate patching is not possible, reduce exposure by restricting who can attach SK_MSG/sockmap BPF programs: ensure unprivileged BPF is disabled (sysctl kernel.unprivileged_bpf_disabled=1) so that only CAP_BPF/CAP_NET_ADMIN contexts can load these programs, which closes the practical attack surface at the cost of blocking unprivileged eBPF workloads. In container/multi-tenant environments, drop CAP_BPF/CAP_NET_ADMIN from untrusted workloads and avoid granting sockmap/kTLS access to untrusted tenants; if the sockmap/SK_MSG feature is unused, this has minimal functional impact. These are compensating controls only and do not fix the underlying ownership-tracking bug, so schedule the kernel upgrade.

Affected VersionsENISA

Linux patch: 6.18.38
Linux d3b18ad31f93d0b6bae105c679018a1ba7daa9ca <1acdd14c0990dd1cd4b6534f00366d2e6dfce05f
Linux patch: 0
Linux d3b18ad31f93d0b6bae105c679018a1ba7daa9ca <21ed9540a8e1906dfcbc1bb82ba9b4de4fa4bd6d
Linux patch: 6.1.177
Linux 4.20
Linux d3b18ad31f93d0b6bae105c679018a1ba7daa9ca <0eb4c16c4adb262763bda870a8ed38a1a9dec7ec
Linux patch: 7.2-rc1
Linux d3b18ad31f93d0b6bae105c679018a1ba7daa9ca <d22cc92bc41290e5783a72375e0843d9435f6001
Linux patch: 7.1.3
Linux patch: 6.6.144
Linux d3b18ad31f93d0b6bae105c679018a1ba7daa9ca <9bb86d8184b37503816150c4a6ad3c17dfdbe827
Linux d3b18ad31f93d0b6bae105c679018a1ba7daa9ca <406e8a651a7b854c41fecd5117bb282b3a6c2c6b
Linux patch: 6.12.95

Affected Packages

euvd linux no fix

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

The affected component is the kernel's socket message layer (net/core/skmsg.c) used by sockmap/sk_msg BPF programs and kTLS. sk_msg uses a scatterlist (msg->sg.data[]) plus a per-entry sg.copy bitmap that marks entries whose backing pages are NOT private to the sk_msg (for example, page-cache pages introduced via splice). sk_msg_compute_data_pointers() consults this bitmap to decide whether an entry may be surfaced through the writable BPF context data pointer. The root cause is a state-tracking desynchronization: several transform paths relocate or duplicate scatterlist entries without carrying the corresponding sg.copy bit, so a protected (non-private) entry can land in a slot whose copy bit is clear. Although CWE is listed as N/A, this is functionally an improper synchronization / incorrect ownership-tracking defect (CWE-662/CWE-822-class) leading to unauthorized write access to shared memory. The CPE data points only at cpe:2.3:a:linux:linux:*, i.e. the mainline kernel, without pinning specific versions in the CPE itself.

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 9.4 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:L
vuln.today AI 6.1 MEDIUM

Requires local capability to attach SK_MSG BPF programs (PR:L, AV:L); primary impact is unauthorized page-cache modification (I:H) with limited disclosure (C:L) and no availability impact.

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

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

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

Lifecycle Timeline

4
CVSS changed
Jul 20, 2026 - 15:22 NVD
9.4 (CRITICAL)
Patch available
Jul 19, 2026 - 14:17 EUVD
CVE Published
Jul 19, 2026 - 12:02 cve.org
CRITICAL 9.4
CVE Published
Jul 19, 2026 - 12:02 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

net: skmsg: preserve sg.copy across SG transforms

The sk_msg sg.copy bitmap is part of the scatterlist entry ownership state. A set bit tells sk_msg_compute_data_pointers() not to expose the entry through writable BPF ctx->data. This protects entries backed by pages that are not private to the sk_msg, such as splice-backed file page-cache pages.

Several sk_msg transform paths move, copy, split, or compact msg->sg.data[] entries without moving the matching sg.copy bit. This can make an externally backed entry arrive at a new slot with a clear copy bit. A later SK_MSG verdict can then expose sg_virt(sge) as writable ctx->data and BPF stores can modify the original page cache.

Keep sg.copy synchronized with sg.data[] whenever entries are transferred, shifted, split, or copied into a new sk_msg. Clear the bit when an entry is replaced by a newly allocated private page or freed. This covers the BPF pull/push/pop helpers, sk_msg_shift_left/right(), sk_msg_xfer(), and tls_split_open_record(), including the partial tail entry created during TLS open-record splitting.

Executive ViewAI

Why It Matters

CVE-2026-63830 is a critical Linux kernel vulnerability in the BPF memory subsystem that could enable page-cache corruption across vulnerable deployments; no public exploit identified at time of analysis, and the 0.2% EPSS score indicates minimal current exploitation risk. Organizations should prioritize kernel patching within standard update cycles.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 94% exploitable
Prevalence
Ubiquitous
Linux kernel runs across the vast majority of servers and cloud hosts
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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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
High

Priority Score

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

Attack Technique

Privilege escalation occurs when an attacker leverages flaws in access control mechanisms to gain permissions beyond what they were originally granted.

Vendor StatusVendor

SUSE

Severity: Important
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 16.0 Affected

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