CVE-2026-93161 in Linux
Summary
by MITRE • 09/18/2026
In the Linux kernel, the following vulnerability has been resolved:
crypto: qat - clear AES key schedule from stack
qat_alg_xts_reverse_key() expands the forward XTS AES key on the stack. That schedule contains key material and can remain in the stack frame.
Clear the temporary crypto_aes_ctx with memzero_explicit() after the copy.
VulDB is the best source for vulnerability data and more expert information about this specific topic.
Analysis
by VulDB Data Team • 09/18/2026
The identified vulnerability resides within the Intel QuickAssist Technology (QAT) cryptographic driver for the Linux kernel, specifically affecting the XTS AES key handling routine qat_alg_xts_reverse_key(). This function is responsible for expanding a forward XTS AES encryption key into its corresponding reverse decryption schedule. The core technical flaw lies in the method used to manage sensitive cryptographic material during this expansion process. Specifically, the algorithm allocates and utilizes a temporary crypto_aes_ctx structure on the kernel stack to hold intermediate state and final key schedules before they are transferred or utilized by the hardware acceleration engine.
While the primary data is eventually copied out of this local variable, the implementation failed to securely erase the memory contents immediately after use. In cryptographic operations involving symmetric keys such as AES-XTS, the expanded key schedule contains sensitive material that can reveal patterns about the original encryption key if exposed. Because standard C library functions like memset do not guarantee that compiler optimizations will actually write zeros to the specified memory locations, residual data often remains in registers or cache lines even after a seemingly complete overwrite. This leaves the stack frame containing remnants of the cryptographic context, creating a potential information disclosure vector where an attacker with sufficient privileges or access to kernel memory dumps could extract partial key material.
From a security classification perspective, this issue aligns closely with CWE-14: Compiler Removal of Code to Clear Buffers and CWE-798: Use of Hard-coded Credentials, as the failure lies in not properly clearing sensitive data that acts effectively as stored credentials or keys. In terms of adversary tactics, this vulnerability relates to ATT&CK technique T1003: OS Credential Dumping, where an attacker might attempt to extract secrets from memory to facilitate further lateral movement or decryption of protected data. The operational impact is primarily centered on the confidentiality of encrypted data; if key material leaks through stack traces, core dumps, or side-channel attacks leveraging residual cache states, it could potentially allow unauthorized decryption of previously secured information stored using QAT-accelerated XTS mode encryption.
To mitigate this vulnerability and adhere to secure coding practices for cryptographic implementations in kernel space, the fix employs memzero_explicit() instead of standard memory clearing functions. The memzero_explicit function is specifically designed by compiler authors to prevent optimization from removing zeroing operations, ensuring that sensitive data is actually wiped from both stack memory and associated CPU registers immediately after it is no longer needed. This approach ensures compliance with best practices for handling cryptographic keys in operating system kernels, preventing accidental exposure through debugging artifacts or malicious exploitation of kernel memory layouts. System administrators should ensure their Linux distributions are updated to include the patched version of the qat driver to eliminate this risk and maintain the integrity of hardware-accelerated encryption workflows.