CVE-2026-53362 — Linux Kernel: Out-of-Bounds Write | CVSS 7.8 HIGH

HIGH

CVSS 7.8 HIGH  ·  EPSS 0%  ·  Linux Kernel

Severity Overview

Summary

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

ipv6: account for fraggap on the paged allocation path

In __ip6_append_data(), when the paged-allocation branch is taken
(MSG_MORE / NETIF_F_SG / large fraglen), alloclen and pagedlen are
computed as

alloclen = fragheaderlen + transhdrlen;
pagedlen = datalen – transhdrlen;

datalen already includes fraggap (datalen = length + fraggap). When
fraggap is non-zero, this is not the first skb and transhdrlen is zero.
The fraggap bytes carried over from the previous skb are copied just past
the fragment headers in the new skb's linear area. The linear area is
therefore undersized by fraggap bytes while pagedlen is overstated by the
same amount, and the copy writes past skb->end into the trailing
skb_shared_info.

An unprivileged user can trigger this via a UDPv6 socket using
MSG_MORE together with MSG_SPLICE_PAGES.

The bad accounting was introduced by commit 773ba4fe9104 ("ipv6:
avoid partial copy for zc"). Before commit ce650a166335 ("udp6: Fix
__ip6_append_data()'s handling of MSG_SPLICE_PAGES"), the negative
copy value caused -EINVAL to be returned. That later commit allowed
MSG_SPLICE_PAGES to proceed in this case, making the corruption
triggerable.

The non-paged branch sets alloclen to fraglen, which already accounts
for fraggap because datalen does. Bring the paged branch in line by
adding fraggap to alloclen and subtracting it from pagedlen.

After this adjustment, copy no longer collapses to -fraggap on the
paged path, so remove the stale comment describing that old arithmetic.
Since a negative copy is no longer expected for a valid MSG_SPLICE_PAGES
case, remove the MSG_SPLICE_PAGES exception from the negative copy check.

What the Attack Looks Like

How it works: Writing data beyond the bounds of an allocated buffer corrupts adjacent memory, which can be exploited to hijack control flow or execute arbitrary code.

If successfully exploited: A successful exploit grants the attacker elevated privileges on the target system — typically administrator or root — enabling full control of the affected host. Full confidentiality and integrity impact means an attacker can both read and modify sensitive data — useful for credential harvesting, data theft, or manipulating application state. High availability impact means the vulnerability can also cause a denial of service, which may be used for disruption or as a diversion during a broader attack.

Analyst Takeaway

The attack is launched by an attacker with local access to the target system and low-privileged credentials are required. This vulnerability is already in CISA KEV, which means exploitation has been confirmed in the wild — treat this as active risk, not theoretical exposure. Linux Kernel is associated with technology that is commonly deployed in enterprise environments, so defenders should assume a higher probability of broad target interest and prioritize validation across the environment. The ATT&CK mapping suggests public-facing exploitation risk, so external exposure validation should be part of immediate triage. The mapping indicates possible privilege escalation behavior, so local admin and kernel-level activity should be reviewed if compromise is suspected. In parallel with patching, defenders should review external exposure, hunt for signs of exploitation, and validate whether compensating controls are in place for vulnerable assets.

MITRE ATT&CK Mapping

• T1068 – Exploitation for Privilege Escalation
  Rationale: The vulnerability context indicates local or kernel-level privilege escalation behavior.
• T1190 – Exploit Public-Facing Application
  Rationale: The product appears likely to be internet-facing or commonly exposed in enterprise environments.

Detection Guidance

• CWE-787 — Out-of-Bounds Write
  • Application crashes as reconnaissance signal: Out-of-bounds write exploits commonly crash the application repeatedly before the attacker achieves reliable code execution. Multiple crashes of the affected service in a short window should prompt immediate investigation.
  • EDR heap/stack protection alerts: Windows DEP (Data Execution Prevention), stack canary violations, and EDR heap corruption alerts are the primary OS-level signals. Correlate alert timestamps with inbound traffic to identify the triggering request.
  • Crash dump analysis: If core dumps or crash dumps are captured, analyze them for signs of controlled data at the crash address — this indicates an exploitation attempt even if not yet successful.
• T1068 — Exploitation for Privilege Escalation
  • Monitor for unexpected privilege changes, token manipulation, or process execution under SYSTEM or root that is not consistent with your baseline.
  • Review service creation (Event ID 7045), scheduled task creation (Event ID 4698), and kernel driver load events for unexpected entries.
  • Inspect EDR kernel-level alerts and OS-level memory protection violations associated with the vulnerable host or process.
• T1190 — Exploit Public-Facing Application
  • Inspect web server, reverse proxy, load balancer, and WAF logs for abnormal request patterns — unusual URIs, oversized payloads, HTTP verb abuse, or encoding anomalies.
  • Monitor for spikes in HTTP 4xx/5xx responses that may indicate probing or failed exploitation attempts preceding a successful hit.
  • Review outbound connections from affected servers for unexpected command-and-control callbacks or secondary payload retrieval to external IPs.
  • Validate which internet-facing assets are running the vulnerable version and verify whether compensating controls (WAF rules, network ACLs) are in place and effective.

Hunting Considerations

These are proactive hunts mapped to the ATT&CK techniques identified for this CVE. Run them now — do not wait for an alert to fire.

• T1068 — Exploitation for Privilege Escalation
  • Privilege assignment events (Windows): Search for Event ID 4672 (Special Privileges Assigned to New Logon) for accounts that should not hold elevated rights. Correlate with Event ID 4688 (process creation) to see what ran immediately after the privilege was granted.
  • Unexpected SYSTEM/root processes: Hunt for processes running as NT AUTHORITY\SYSTEM or root that are not part of your baseline — particularly interactive shells (cmd.exe, PowerShell, bash) or network utilities running at that privilege level.
  • Service and driver installation (Windows): Event ID 7045 (new service installed) and kernel driver load events are key. Privilege escalation exploits frequently install a service or load a driver as the escalation mechanism — any unexpected entry here warrants investigation.
  • Linux-specific indicators: Search auditd for unexpected setuid/setgid executions, sudo invocations by users outside your admin group, and privilege-change syscalls (setuid, setreuid, setresuid) from non-root processes.
  • Token manipulation (Windows): Sysmon Event 10 (process access) targeting lsass.exe or other high-privilege processes often precedes or accompanies privilege escalation. Unusual OpenProcess calls against security processes are a strong signal.
• T1190 — Exploit Public-Facing Application
  • Web/app server logs: Search for unusual HTTP methods, requests to non-standard paths, oversized payloads, or encoding anomalies (URL-encoded or double-encoded sequences) targeting the vulnerable application. Cluster by source IP and look for low-volume probing patterns before any successful hit.
  • Process telemetry: Hunt for child processes spawned by the web server or application process (e.g., apache2, nginx, w3wp.exe, java). Web server processes should not be launching shells, scripting engines (PowerShell, bash, python), or download utilities.
  • Outbound connections from the server: Alert on unexpected outbound HTTP/S or DNS from the application server to external IPs not in your CDN or update allowlist — this is a common secondary payload retrieval indicator post-exploitation.
  • File system writes: Look for new files written to web root directories, temp folders, or cron directories by the application process — especially scripts or executables placed there after an unusual inbound request.
  • Internal pivot follow-on: After gaining a foothold, attackers move laterally. Search for new internal connections originating from the compromised server in the hour following any suspicious external request.

Recommended Actions

Immediate (0–24 Hours)

• Inventory: Identify all systems running Linux Kernel. Include production, staging, dev, and cloud environments — untracked instances are the most likely to remain unpatched.
• Review local access scope: This vulnerability requires local access — assess which users or processes have local access to affected systems and whether that access could be reached from a compromised adjacent host.

Remediation

• Apply the vendor patch: Apply mitigations in accordance with vendor instructions, ensuring compliance with CISA’s BOD 26-04 Prioritizing Security Updates Based on Risk (see URL in Notes) guidance and CISA’s “Forensics Triage Requirements” (see URL in Notes). Follow applicable BOD 26-04 guidance for cloud services or discontinue use of the product if mitigations are unavailable. Stakeholders are responsible for evaluating each asset's internet exposure and ensuring adherence to BOD 26-04 patching guidelines.
• CISA directive deadline: 2026-08-30 — this is the mandatory deadline for US federal civilian agencies under BOD 22-01. All organizations should treat this date as a strong target regardless of federal mandate.
• Verify remediation: After patching, confirm the correct version is installed on all affected hosts. Run a vulnerability scan or use your asset management tooling to verify — do not rely solely on change tickets.
• Post-patch compromise assessment: Privilege escalation and lateral movement techniques can result in persistent access that survives patching. After remediation, review the hunting considerations in this alert to assess whether compromise occurred before the patch was applied.

Detection Coverage

• Verify ATT&CK coverage: Confirm your SIEM and EDR have detection logic in place for T1068, T1190. Review the Detection Guidance and Hunting Considerations sections of this alert for the specific log sources and behavioral patterns to monitor.
• Threat intelligence feeds: Monitor your TI feeds and vendor advisory channels for published indicators of compromise (IOCs), proof-of-concept exploit releases, or active campaign reporting associated with this CVE — these should trigger an immediate hunt even if no internal alerts have fired.

Detection Playbooks

Vulnerability Details

Additional Notes

This vulnerability affects an open-source component, third-party library, protocol, or proprietary implementation that could be used by different products. For more information, please see: ; https://git.kernel.org/stable/c/14200d435af9a9eeb444f529fc2f689a236b7962; https://git.kernel.org/stable/c/65fb14cbebb0cd0eff903a22d33537ddc8b95769; https://git.kernel.org/stable/c/46f201f8b4c39633a1fa3dc12459f506d470993d; https://git.kernel.org/stable/c/6374fb9edf72c67a118a2c214a0dddd04c921e0a; https://git.kernel.org/stable/c/e9eacf19281ea2498b36291b56c9606118c2d74e; https://git.kernel.org/stable/c/736b380e28d0480c7bc3e022f1950f31fe53a7c5 ; BOD 26-04: https://www.cisa.gov/news-events/directives/bod-26-04-prioritizing-security-updates-based-risk ; Forensics Triage Requirements: https://www.cisa.gov/news-events/directives/bod-26-04-implementation-guidance-prioritizing-security-updates-based-risk ; https://nvd.nist.gov/vuln/detail/CVE-2026-53362