CVE-2026-80836: Linux Kernel Crypto Information Disclosure

CVE-2026-80836 Overview

CVE-2026-80836 is an out-of-bounds read vulnerability in the Linux kernel's virtio_crypto driver. The flaw resides in virtio_crypto_dataq_akcipher_callback(), which sets the akcipher result length from a device-reported response length without bounding it to the destination buffer. A malicious or malfunctioning virtio-crypto backend can report a length larger than the originally allocated buffer. The subsequent sg_copy_from_buffer() call then reads adjacent kernel heap memory into the caller's scatterlist. The upstream fix clamps the reported length to the originally requested destination length, so conforming devices are unaffected.

Critical Impact
A malicious virtio-crypto backend can trigger a kernel heap out-of-bounds read, leaking adjacent memory contents to guest components consuming asymmetric cipher (akcipher) results.

Affected Products

Linux kernel with the virtio_crypto driver enabled
Guest kernels running on hypervisors that expose a virtio-crypto device
Stable kernel branches prior to the commits referenced in the fix set

Discovery Timeline

2026-09-04 - CVE-2026-80836 published to the National Vulnerability Database (NVD)
2026-09-04 - Last updated in NVD database

Technical Details for CVE-2026-80836

Vulnerability Analysis

The virtio_crypto driver implements asymmetric cipher operations (akcipher) using the virtio transport. When a request completes, the host device signals the guest through a virtqueue, and the guest callback virtio_crypto_dataq_akcipher_callback() records the operation result. The callback trusts the length field returned by the device and assigns it directly to the akcipher request result length.

The destination scatterlist was allocated based on the guest's originally requested output size. When the device reports a larger response length, the driver still hands that inflated value to sg_copy_from_buffer(). The copy routine walks past the end of the destination buffer and reads whatever kernel heap memory follows. The over-read data is then transferred into the caller's scatterlist, exposing adjacent kernel objects to any consumer of the akcipher result.

Root Cause

The root cause is missing input validation on a device-supplied length field, classified as an Out-of-Bounds Read. The callback path did not clamp the response length to the size of the pre-allocated destination buffer. This violates the defensive contract that guest drivers must not trust host-controlled sizes without bounding them against locally known limits.

Attack Vector

Exploitation requires control over the virtio-crypto backend. This scenario is realistic when a guest is attached to an untrusted or compromised hypervisor, when a malicious vhost-user process serves the crypto device, or in confidential-computing threat models where the host is treated as adversarial. A crafted akcipher response with an oversized length field triggers the out-of-bounds heap read on every completion. See the upstream fixes in the referenced kernel git commits for the exact patched code path.

// No verified exploit code available. Refer to the upstream commits:
// 1f9f877b1ef1fbd4ee95571cddf39c8002cee252
// 3fda114a42f1510a4ec8a0b17a0cfc997952ccc2
// 5545de5050cbc3594506d74f2c392b0716cf8bca
// f77a956f6a19f9463ef1527c9d0cda50dded6b92

Detection Methods for CVE-2026-80836

Indicators of Compromise

Guest kernel logs showing unexpected akcipher completions with response sizes that exceed requested output lengths.
KASAN (Kernel Address Sanitizer) reports flagging out-of-bounds reads inside virtio_crypto_dataq_akcipher_callback() or sg_copy_from_buffer().
Anomalous virtio-crypto virtqueue activity from a host or vhost-user backend that does not match guest workload patterns.

Detection Strategies

Enable KASAN on test kernels to surface the out-of-bounds read during virtio-crypto akcipher operations.
Audit the running kernel version against the patched commits (1f9f877, 3fda114, 5545de5, f77a956) to confirm coverage.
Inventory guests that load the virtio_crypto module using lsmod | grep virtio_crypto across the fleet.

Monitoring Recommendations

Alert on kernel oops or KASAN splats referencing the virtio_crypto module in centralized logging.
Monitor guest workloads that consume akcipher results, such as user-space TLS or key-management services, for unexpected output.
Track hypervisor and vhost-user backend versions to ensure host-side implementations remain conforming.

How to Mitigate CVE-2026-80836

Immediate Actions Required

Apply the upstream Linux kernel patches referenced above and reboot affected guests.
Prioritize patching guests that run on shared, multi-tenant, or untrusted hypervisors.
If patching is not immediately possible, unload the virtio_crypto module on guests that do not require virtio-based asymmetric crypto.

Patch Information

The fix clamps the device-reported response length to the originally requested destination length in virtio_crypto_dataq_akcipher_callback(). Patched commits are available on kernel.org: 1f9f877, 3fda114, 5545de5, and f77a956. Distribution vendors typically backport these fixes into their supported stable branches.

Workarounds

Blacklist the virtio_crypto kernel module on guests that do not depend on it.
Use a trusted, conforming host-side virtio-crypto backend so response lengths remain within bounds.
Consider disabling the virtio-crypto device in guest configuration at the hypervisor level for high-assurance workloads.

bash

# Prevent the virtio_crypto module from loading on affected guests
echo 'blacklist virtio_crypto' | sudo tee /etc/modprobe.d/blacklist-virtio-crypto.conf
sudo rmmod virtio_crypto 2>/dev/null || true
sudo update-initramfs -u