CVE-2025-68741
Description
In the Linux kernel, the following vulnerability has been resolved:
scsi: qla2xxx: Fix improper freeing of purex item
In qla2xxx_process_purls_iocb(), an item is allocated via qla27xx_copy_multiple_pkt(), which internally calls qla24xx_alloc_purex_item().
The qla24xx_alloc_purex_item() function may return a pre-allocated item from a per-adapter pool for small allocations, instead of dynamically allocating memory with kzalloc().
An error handling path in qla2xxx_process_purls_iocb() incorrectly uses kfree() to release the item. If the item was from the pre-allocated pool, calling kfree() on it is a bug that can lead to memory corruption.
Fix this by using the correct deallocation function, qla24xx_free_purex_item(), which properly handles both dynamically allocated and pre-allocated items.
AI Insight
LLM-synthesized narrative grounded in this CVE's description and references.
In the Linux kernel's qla2xxx driver, an error path incorrectly used kfree() instead of qla24xx_free_purex_item(), potentially corrupting memory when the item was from a pre-allocated pool.
Vulnerability
Details
In the Linux kernel's qla2xxx SCSI driver, the function qla2xxx_process_purls_iocb() allocates a purex item via qla27xx_copy_multiple_pkt(), which internally calls qla24xx_alloc_purex_item(). This allocator may return a pre-allocated item from a per-adapter pool for small allocations, rather than dynamically allocating memory with kzalloc(). An error handling path in qla2xxx_process_purls_iocb() incorrectly uses kfree() to release the item, causing a mismatch if the item was from the pre-allocated pool [1][2].
Exploitation
To exploit this vulnerability, an attacker would need to trigger the error path in the qla2xxx driver. This could be achieved by sending malformed or abnormal SCSI commands that cause an allocation failure or other error condition, requiring local access to the system or the ability to interact with the Fibre Channel device. No special authentication is needed beyond the ability to issue SCSI commands.
Impact
If the item is from the pre-allocated pool, calling kfree() on it leads to memory corruption. This can result in system instability, denial of service, or potentially arbitrary code execution in kernel context, as the corrupted memory may be reused or freed improperly.
Mitigation
The Linux kernel has addressed this issue by replacing the kfree() call with the correct deallocation function qla24xx_free_purex_item(), which properly handles both dynamically allocated and pre-allocated items. The fix is included in stable kernel updates; administrators should update their kernels to include commits cfe3e2f768d2 and 5fa1c8226b453 (or later versions). No workaround is available [1][2].
AI Insight generated on May 19, 2026. Synthesized from this CVE's description and the cited reference URLs; citations are validated against the source bundle.
Affected products
1Patches
0No patches discovered yet.
Vulnerability mechanics
AI mechanics synthesis has not run for this CVE yet.
References
5- git.kernel.org/stable/c/4bccd506a1f1ab01d1f45b2a3effff6bedc73cf9nvd
- git.kernel.org/stable/c/5fa1c8226b4532ad7011d295d3ab4ad45df105aenvd
- git.kernel.org/stable/c/78b1a242fe612a755f2158fd206ee6bb577d18canvd
- git.kernel.org/stable/c/8e9f0a0717ba31d5842721627ade1e62d7aec012nvd
- git.kernel.org/stable/c/cfe3e2f768d248fd3d965d561d0768a56dd0b9f8nvd
News mentions
0No linked articles in our index yet.