Linux Kernel
CVE-2024-26789
HIGH
Severity by source
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
Local access and low privilege required to invoke kernel crypto API; no scope change; worst-case read/write of adjacent kernel memory justifies C:H/I:H/A:H.
Primary rating from Vendor (416baaa9-dc9f-4396-8d5f-8c081fb06d67).
CVSS VectorVendor: 416baaa9-dc9f-4396-8d5f-8c081fb06d67
Lifecycle Timeline
6DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
crypto: arm64/neonbs - fix out-of-bounds access on short input
The bit-sliced implementation of AES-CTR operates on blocks of 128 bytes, and will fall back to the plain NEON version for tail blocks or inputs that are shorter than 128 bytes to begin with.
It will call straight into the plain NEON asm helper, which performs all memory accesses in granules of 16 bytes (the size of a NEON register). For this reason, the associated plain NEON glue code will copy inputs shorter than 16 bytes into a temporary buffer, given that this is a rare occurrence and it is not worth the effort to work around this in the asm code.
The fallback from the bit-sliced NEON version fails to take this into account, potentially resulting in out-of-bounds accesses. So clone the same workaround, and use a temp buffer for short in/outputs.
AnalysisAI
Out-of-bounds memory access in the Linux kernel's ARM64 AES-CTR bit-sliced NEON cryptographic implementation allows a local low-privileged attacker to read or corrupt kernel memory when short inputs (fewer than 16 bytes) are processed. The flaw exists specifically in the fallback path from the 128-byte-block bit-sliced NEON routine to the plain NEON assembler helper, which accesses memory in 16-byte NEON register granules without the temporary-buffer safeguard that the plain NEON glue code applies. No public exploit or CISA KEV listing has been identified; EPSS of 0.23% (13th percentile) reflects low observed exploitation pressure at time of analysis.
Technical ContextAI
The affected code resides in the ARM64 architecture-specific crypto subsystem of the Linux kernel (cpe:2.3:o:linux:linux_kernel). AES in Counter Mode (AES-CTR) has two ARM64 implementations: a high-throughput bit-sliced NEON variant that operates on 128-byte blocks, and a plain NEON variant for smaller or tail blocks. The plain NEON assembler helper performs all memory reads and writes in 16-byte increments (one NEON Q register at a time). The plain NEON glue layer protects against this by copying inputs shorter than 16 bytes into a properly sized temporary buffer before calling the asm helper. The bit-sliced fallback path, however, calls the plain NEON asm helper directly without applying this guard, causing reads or writes beyond the actual input buffer boundary. The root cause class is CWE-125 (Out-of-Bounds Read), though the accompanying 'Buffer Overflow' tag and CVSS I:H suggest the access can also overwrite adjacent memory. This is strictly an ARM64 issue tied to NEON hardware support and is not relevant to x86 or other architectures.
RemediationAI
Apply the upstream stable kernel patches available at the following commits: https://git.kernel.org/stable/c/034e2d70b5c7f578200ad09955aeb2aa65d1164a, https://git.kernel.org/stable/c/1291d278b5574819a7266568ce4c28bce9438705, https://git.kernel.org/stable/c/1c0cf6d19690141002889d72622b90fc01562ce4, and https://git.kernel.org/stable/c/9e8ecd4908b53941ab6f0f51584ab80c6c6606c4. These are upstream git commits against stable kernel branches; a specific tagged release version incorporating these fixes is not independently confirmed from the provided data-consult your distribution's security advisories (e.g., Ubuntu USN, Red Hat RHSA, Debian DSA) for backported packages. As a compensating control where patching is not immediately possible, disabling user-space access to the AF_ALG kernel crypto interface (e.g., via seccomp policy or restricting CAP_NET_ADMIN) reduces the attack surface by limiting which processes can invoke AES-CTR operations through the kernel, though this may break applications that rely on kernel-accelerated cryptography. No other workaround eliminates the underlying memory safety issue.
Same weakness CWE-125 – Out-of-bounds Read
View allSame technique Buffer Overflow
View allShare
External POC / Exploit Code
Leaving vuln.today