Skip to main content

Linux Kernel CVE-2026-64130

| EUVDEUVD-2026-45815 MEDIUM
Use of Uninitialized Resource (CWE-908)
2026-07-19 Linux GHSA-jjh5-mvrv-5xmg
5.5
CVSS 3.1 · NVD
Share

Severity by source

NVD PRIMARY
5.5 MEDIUM
AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H
vuln.today AI
5.3 MEDIUM

AC:H reflects non-default init_on_free=1 plus ARM64 MTE hardware requirements; C:L added for stale tag exposure NVD omits.

3.1 AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:N/A:H
4.0 AV:L/AC:H/AT:P/PR:L/UI:N/VC:L/VI:N/VA:H/SC:N/SI:N/SA:N
SUSE
MEDIUM
qualitative
Red Hat
5.5 MEDIUM
qualitative

Primary rating from NVD.

CVSS VectorNVD

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

Lifecycle Timeline

5
Analysis Generated
Aug 13, 2026 - 15:30 vuln.today
CVSS changed
Aug 13, 2026 - 15:22 NVD
5.5 (MEDIUM)
Patch available
Jul 19, 2026 - 17:03 EUVD
CVE Published
Jul 19, 2026 - 15:40 nvd
MEDIUM 5.5
CVE Published
Jul 19, 2026 - 15:40 cve.org
UNKNOWN (no severity yet)

DescriptionNVD

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

mm/page_alloc: fix initialization of tags of the huge zero folio with init_on_free

__GFP_ZEROTAGS semantics are currently a bit weird, but effectively this flag is only ever set alongside __GFP_ZERO and __GFP_SKIP_KASAN.

If we run with init_on_free, we will zero out pages during __free_pages_prepare(), to skip zeroing on the allocation path.

However, when allocating with __GFP_ZEROTAG set, post_alloc_hook() will consequently not only skip clearing page content, but also skip clearing tag memory.

Not clearing tags through __GFP_ZEROTAGS is irrelevant for most pages that will get mapped to user space through set_pte_at() later: set_pte_at() and friends will detect that the tags have not been initialized yet (PG_mte_tagged not set), and initialize them.

However, for the huge zero folio, which will be mapped through a PMD marked as special, this initialization will not be performed, ending up exposing whatever tags were still set for the pages.

The docs (Documentation/arch/arm64/memory-tagging-extension.rst) state that allocation tags are set to 0 when a page is first mapped to user space. That no longer holds with the huge zero folio when init_on_free is enabled.

Fix it by decoupling __GFP_ZEROTAGS from __GFP_ZERO, passing to tag_clear_highpages() whether we want to also clear page content.

Invert the meaning of the tag_clear_highpages() return value to have clearer semantics.

Reproduced with the huge zero folio by modifying the check_buffer_fill arm64/mte selftest to use a 2 MiB area, after making sure that pages have a non-0 tag set when freeing (note that, during boot, we will not actually initialize tags, but only set KASAN_TAG_KERNEL in the page flags).

$ ./check_buffer_fill 1..20 ... not ok 17 Check initial tags with private mapping, sync error mode and mmap memory not ok 18 Check initial tags with private mapping, sync error mode and mmap/mprotect memory ...

This code needs more cleanups; we'll tackle that next, like decoupling __GFP_ZEROTAGS from __GFP_SKIP_KASAN.

[akpm@linux-foundation.org: s/__GPF_ZERO/__GFP_ZERO/, per David]

AnalysisAI

Stale ARM64 Memory Tagging Extension (MTE) tag exposure in the Linux kernel's huge zero folio allocation path undermines the init_on_free security guarantee on AArch64 systems. When the kernel is booted with init_on_free=1 and a 2MB anonymous mapping triggers the huge zero folio path (mapped as a PMD-special entry), the __GFP_ZEROTAGS flag causes post_alloc_hook() to skip tag memory clearing while content zeroing was already handled at free time - leaving whatever allocation tags were previously set accessible to user space. No public exploit has been identified at time of analysis, and EPSS stands at 0.17% (6th percentile), consistent with the narrow architectural and configuration prerequisites required to trigger the flaw.

Technical ContextAI

The Linux kernel's memory allocator (mm/page_alloc.c) uses the __GFP_ZEROTAGS flag alongside __GFP_ZERO and __GFP_SKIP_KASAN to manage ARM64 MTE allocation tag memory. When init_on_free=1 is active, the kernel pre-zeros pages during __free_pages_prepare() at free time, allowing the allocation path to skip redundant zeroing. The __GFP_ZEROTAGS flag in post_alloc_hook() is meant to signal that tag memory should also be cleared, but because the content was already zeroed at free time, this flag ends up causing both content and tag clearing to be skipped on the allocation path. For most anonymous pages this is harmless: set_pte_at() detects that PG_mte_tagged is not set and initializes tags on the first user-space mapping. However, the huge zero folio - a kernel-wide shared 2MB zero page mapped via a PMD entry marked as VM_SPECIAL - entirely bypasses this initialization path. ARM64 MTE documentation (Documentation/arch/arm64/memory-tagging-extension.rst) guarantees that allocation tags are zero when a page is first mapped to user space; this guarantee is violated for the huge zero folio with init_on_free enabled. CWE-908 (Use of Uninitialized Resource) precisely characterizes the root cause: MTE tag memory is consumed without being set to a known-good state. CPE cpe:2.3:a:linux:linux:*:*:*:*:*:*:*:* confirms the full upstream kernel tree is in scope for AArch64 MTE-capable deployments prior to the fix commits.

RemediationAI

The primary fix is upgrading to a patched Linux kernel: version 6.18.34, 7.0.11, or 7.1 as documented in EUVD-2026-45815. The upstream stable fix commits are available at https://git.kernel.org/stable/c/738d18f1da3513d17b6f7bf30146cc4ac2480ffd, https://git.kernel.org/stable/c/2f2aec5120b93a8f8b52dc50cdc60dbb8aec72f6, and https://git.kernel.org/stable/c/6a288a4ddb4a994490505ab5f41c445f8e6b6467. Ubuntu users should apply updates from USN-8593-1 at https://ubuntu.com/security/notices/USN-8593-1. As an interim compensating control, removing init_on_free=1 from kernel boot parameters eliminates the vulnerable code path, but this trades the MTE tag fix for losing the broader memory sanitization benefit of init_on_free - weigh this against your threat model before applying. Alternatively, suppressing transparent huge page (THP) usage via kernel hugepage policy (e.g., setting /sys/kernel/mm/transparent_hugepage/enabled to never) eliminates the huge zero folio path without sacrificing init_on_free, at a potential THP performance cost. Disabling MTE at the system level is a last resort that removes tag exposure but also eliminates MTE's memory-safety benefits entirely.

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 16.0 Not-Affected

Share

CVE-2026-64130 vulnerability details – vuln.today

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