Linux Kernel
CVE-2024-26768
HIGH
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconProvision LoongArch system with >64 CPUs
-
DeliveryBoot unpatched Linux kernel
-
Exploitplatform_init() parses ACPI MADT table
-
Installacpi_core_pic[] written beyond NR_CPUS boundary
-
C2Adjacent kernel memory corrupted
-
ExecuteKernel paging fault at efi_runtime_init
-
ImpactSystem crashes, unbootable
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Buffer copy size validation
MITRE ATT&CK
1 technique across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires an LoongArch-architecture system - physical or virtualized - where the number of physical or virtual CPU cores present in the ACPI MADT table exceeds NR_CPUS (64 by default). In virtualized environments the hypervisor administrator must explicitly provision more than 64 vCPUs, for example via QEMU -smp 128. On bare-metal hardware, the server must physically contain more than 64 LoongArch CPU cores enumerated by firmware. The crash occurs unconditionally during the ACPI MADT parsing phase of early boot - no network access, no user session, no runtime input, and no application-layer interaction is involved. Factors limiting exploitation: the vulnerability is LoongArch-specific and does not affect x86, ARM, or other architectures; triggering it requires administrative control over VM provisioning or physical hardware selection; and it produces a crash rather than a controlled code-execution primitive, limiting utility as an attack vector beyond denial-of-service. |
| Impact | Real-world risk is low despite the NVD CVSS score of 7.2. The assigned vector AV:N/AC:L/PR:H is questionable: the vulnerability is triggered by a hardware configuration or hypervisor CPU-count setting, not by any network-reachable input, making AV:L more accurate. PR:H correctly reflects that provoking the crash requires hypervisor or physical hardware administrator control over CPU topology. EPSS at 0.24% (14th percentile) signals negligible threat-actor interest, and the vulnerability is absent from CISA KEV. No standalone exploit code is referenced in available data. The impact is confined to LoongArch systems - a niche architecture with deployment concentrated largely in Chinese datacenter environments - that happen to be provisioned with more than 64 CPUs. In practice the flaw is a denial-of-service (unbootable system) rather than a code-execution primitive; achieving reliable arbitrary code execution from this crash would require sophisticated kernel exploitation beyond the described crash path. There is no conflicting signal between EPSS and description, but the NVD CVSS attack vector is inconsistent with a boot-time configuration-driven crash - defenders should not treat this as a remotely exploitable vulnerability in the traditional sense. |
| Exploit ScenarioDerived | A cloud operator provisions a LoongArch virtual machine on a QEMU host with 128 vCPUs (-smp 128) running an unpatched Linux kernel. During early boot, platform_init() iterates over all 128 MADT entries and writes CORE_PIC structures into acpi_core_pic[], which is only allocated for 64 entries, overwriting adjacent kernel memory. The kernel immediately faults with a paging error at efi_runtime_init and crashes before reaching the init process, leaving the VM permanently unbootable until the kernel is replaced. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Aug 04, 2026
Boot-time buffer overflow in the LoongArch ACPI initialization path of the Linux kernel causes a deterministic kernel crash when the physical or virtual CPU count exceeds 64 (the default NR_CPUS limit). The statically-sized acpi_core_pic[NR_CPUS] array is overwritten during MADT table parsing whenever MAX_CORE_PIC exceeds NR_CPUS, corrupting adjacent kernel memory and producing an unrecoverable paging fault before userspace is reached. No active exploitation is confirmed (not in CISA KEV), and EPSS stands at 0.24% (14th percentile), consistent with the niche architecture and the specialized triggering conditions required.
Earlier versions of this analysis (1)
Boot-time array overflow in the Linux kernel's LoongArch ACPI MADT parsing code causes a kernel panic on systems with more than 64 physical or virtual CPUs. The fixed-size array acpi_core_pic[NR_CPUS] (default 64 entries) is overrun when the MADT table enumerates more physical cores than NR_CPUS allows, crashing the kernel during platform_init before userspace is ever reached. No active exploitation has been confirmed (not in CISA KEV), and EPSS is very low at 0.24% (14th percentile), consistent with a hardware-configuration-dependent availability issue rather than a remotely weaponizable flaw. Patches are available via the Linux stable kernel tree.
RemediationAI
The primary remediation is to apply the upstream kernel fix commits available at https://git.kernel.org/stable/c/0f6810e39898af2d2cabd9313e4dbc945fb5dfdd, https://git.kernel.org/stable/c/4551b30525cf3d2f026b92401ffe241eb04dfebe, and https://git.kernel.org/stable/c/88e189bd16e5889e44a41b3309558ebab78b9280 and upgrade to a patched stable kernel release that includes them. For LoongArch systems that cannot be immediately patched, a direct workaround is to restrict the virtual or physical CPU count to 64 or fewer: in QEMU this means setting -smp to 64 or below, which prevents the overflow without requiring a kernel rebuild. A second workaround - rebuilding the kernel with a higher NR_CPUS value - expands the logical CPU limit but does not fix the underlying design flaw (physical vs. logical array sizing) and may increase kernel memory usage. Physical LoongArch servers with more than 64 cores that cannot be patched should be considered non-functional at boot until the patch is applied, as the crash is deterministic and occurs before userspace initialization.
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
The flaw resides in the LoongArch architecture-specific ACPI CPU enumeration code (CWE-120: Classic Buffer Overflow). During early boot, platform_init() parses the ACPI MADT (Multiple APIC Description Table) to discover physical processor cores and populates the acpi_core_pic[] array. That array is statically allocated to NR_CPUS entries - 64 in a default kernel build - which represents the maximum number of logical, schedulable CPUs. However, the physical core count advertised in MADT (MAX_CORE_PIC) can legally exceed NR_CPUS on machines or VMs with large CPU counts, causing an out-of-bounds write into adjacent kernel data structures. The fix resizes the array to MAX_CORE_PIC so that MADT parsing can safely enumerate all physical entries and leave excess cores in BIOS without corrupting memory. Affected CPEs per NVD include cpe:2.3:o:linux:linux_kernel covering the 6.8-rc1, 6.8-rc2, and 6.8-rc3 pre-release series as well as prior stable branches before the fix commits were backported.
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
AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H
Crash triggered solely by hypervisor or hardware CPU-count configuration, not network input; PR:H for required admin control; no confidentiality or integrity impact beyond system availability.
Primary rating from Vendor (416baaa9-dc9f-4396-8d5f-8c081fb06d67).
CVSS VectorVendor: 416baaa9-dc9f-4396-8d5f-8c081fb06d67
Lifecycle Timeline
5DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
LoongArch: Change acpi_core_pic[NR_CPUS] to acpi_core_pic[MAX_CORE_PIC]
With default config, the value of NR_CPUS is 64. When HW platform has more then 64 cpus, system will crash on these platforms. MAX_CORE_PIC is the maximum cpu number in MADT table (max physical number) which can exceed the supported maximum cpu number (NR_CPUS, max logical number), but kernel should not crash. Kernel should boot cpus with NR_CPUS, let the remainder cpus stay in BIOS.
The potential crash reason is that the array acpi_core_pic[NR_CPUS] can be overflowed when parsing MADT table, and it is obvious that CORE_PIC should be corresponding to physical core rather than logical core, so it is better to define the array as acpi_core_pic[MAX_CORE_PIC].
With the patch, system can boot up 64 vcpus with qemu parameter -smp 128, otherwise system will crash with the following message.
[ 0.000000] CPU 0 Unable to handle kernel paging request at virtual address 0000420000004259, era 90000000037a5f0c, ra 90000000037a46ec [ 0.000000] Oops[#1]: [ 0.000000] CPU: 0 PID: 0 Comm: swapper Not tainted 6.8.0-rc2+ #192 [ 0.000000] Hardware name: QEMU QEMU Virtual Machine, BIOS unknown 2/2/2022 [ 0.000000] pc 90000000037a5f0c ra 90000000037a46ec tp 9000000003c90000 sp 9000000003c93d60 [ 0.000000] a0 0000000000000019 a1 9000000003d93bc0 a2 0000000000000000 a3 9000000003c93bd8 [ 0.000000] a4 9000000003c93a74 a5 9000000083c93a67 a6 9000000003c938f0 a7 0000000000000005 [ 0.000000] t0 0000420000004201 t1 0000000000000000 t2 0000000000000001 t3 0000000000000001 [ 0.000000] t4 0000000000000003 t5 0000000000000000 t6 0000000000000030 t7 0000000000000063 [ 0.000000] t8 0000000000000014 u0 ffffffffffffffff s9 0000000000000000 s0 9000000003caee98 [ 0.000000] s1 90000000041b0480 s2 9000000003c93da0 s3 9000000003c93d98 s4 9000000003c93d90 [ 0.000000] s5 9000000003caa000 s6 000000000a7fd000 s7 000000000f556b60 s8 000000000e0a4330 [ 0.000000] ra: 90000000037a46ec platform_init+0x214/0x250 [ 0.000000] ERA: 90000000037a5f0c efi_runtime_init+0x30/0x94 [ 0.000000] CRMD: 000000b0 (PLV0 -IE -DA +PG DACF=CC DACM=CC -WE) [ 0.000000] PRMD: 00000000 (PPLV0 -PIE -PWE) [ 0.000000] EUEN: 00000000 (-FPE -SXE -ASXE -BTE) [ 0.000000] ECFG: 00070800 (LIE=11 VS=7) [ 0.000000] ESTAT: 00010000 [PIL] (IS= ECode=1 EsubCode=0) [ 0.000000] BADV: 0000420000004259 [ 0.000000] PRID: 0014c010 (Loongson-64bit, Loongson-3A5000) [ 0.000000] Modules linked in: [ 0.000000] Process swapper (pid: 0, threadinfo=(____ptrval____), task=(____ptrval____)) [ 0.000000] Stack : 9000000003c93a14 9000000003800898 90000000041844f8 90000000037a46ec [ 0.000000] 000000000a7fd000 0000000008290000 0000000000000000 0000000000000000 [ 0.000000] 0000000000000000 0000000000000000 00000000019d8000 000000000f556b60 [ 0.000000] 000000000a7fd000 000000000f556b08 9000000003ca7700 9000000003800000 [ 0.000000] 9000000003c93e50 9000000003800898 9000000003800108 90000000037a484c [ 0.000000] 000000000e0a4330 000000000f556b60 000000000a7fd000 000000000f556b08 [ 0.000000] 9000000003ca7700 9000000004184000 0000000000200000 000000000e02b018 [ 0.000000] 000000000a7fd000 90000000037a0790 9000000003800108 0000000000000000 [ 0.000000] 0000000000000000 000000000e0a4330 000000000f556b60 000000000a7fd000 [ 0.000000] 000000000f556b08 000000000eaae298 000000000eaa5040 0000000000200000 [ 0.000000] ... [ 0.000000] Call Trace: [ 0.000000] [<90000000037a5f0c>] efi_runtime_init+0x30/0x94 [ 0.000000] [<90000000037a46ec>] platform_init+0x214/0x250 [ 0.000000] [<90000000037a484c>] setup_arch+0x124/0x45c [ 0.000000] [<90000000037a0790>] start_kernel+0x90/0x670 [ 0.000000] [<900000000378b0d8>] kernel_entry+0xd8/0xdc
Executive ViewAI
A buffer overflow in the Linux kernel's LoongArch boot initialization can render systems unbootable when configured with more than 64 CPU cores, creating potential business continuity risks for organizations using this processor architecture. No public exploit identified at time of analysis, and exploitation probability remains low (EPSS 0.2%), yet affected systems experience complete boot failure requiring patching to restore operations. Organizations operating LoongArch infrastructure should prioritize rapid assessment of high-CPU-count deployments.
Apply vendor patch.
Threat Intelligence Overview
NVD
CVE.org
EPSS
VulDB
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.
What every action level means
SSVC AssessmentENISA
Priority Score
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.
GitHub PoC
Exploit-DB