CVE-2024-36892 is a vulnerability in the Linux kernel's memory management subsystem, specifically within the SLUB allocator, which is responsible for efficient kernel memory allocation and deallocation. The issue arises from the way single object freeing is handled when the kernel is configured with both `slub_debug=F` and `CONFIG_SLAB_FREELIST_HARDENED=y` along with `init_on_free=1`. The vulnerability is rooted in the splitting of the free operation into two separate functions: `slab_free()` for single object frees and `slab_free_bulk()` for bulk frees. While bulk frees correctly maintain the freepointer (a pointer used to track free objects) by setting it explicitly, the single free path zeroes the object but does not properly update the freepointer stored outside the object. This leads to a scenario where the freelist consistency checks, performed in the slowpath of `do_slab_free()`, attempt to decode a zeroed freepointer, resulting in a "Freepointer corrupt" error detected by `check_object()`. This inconsistency can cause kernel warnings or errors, potentially leading to kernel instability or denial of service. The vulnerability does not appear to be exploitable for privilege escalation or arbitrary code execution directly, but it can cause kernel crashes or memory corruption under specific debug configurations. The issue was introduced by commit 284f17ac13fe, which separated bulk and single free handling, and is reproducible with specific kernel boot parameters enabling slab freelist hardening and initialization on free. The vulnerability affects Linux kernel versions containing the referenced commit and configurations enabling these debugging and hardening features.

For European organizations, the impact of CVE-2024-36892 primarily concerns system stability and reliability rather than direct data breaches or privilege escalations. Systems running Linux kernels with the affected configurations—particularly those using hardened slab freelist checks and initialization on free—may experience kernel panics or crashes when freeing memory objects singly. This can lead to denial of service conditions, disrupting critical services, especially in environments relying on Linux for servers, embedded systems, or infrastructure components. Organizations in sectors such as finance, healthcare, telecommunications, and critical infrastructure, which often deploy hardened kernels for security, may be more susceptible to operational disruptions. Additionally, debugging and development environments that enable these kernel options for testing or security hardening may face increased instability. Although no known exploits are currently in the wild, the vulnerability could be triggered inadvertently or during stress testing, impacting system availability. The lack of direct exploitation for privilege escalation reduces the risk of data confidentiality or integrity compromise but does not eliminate the risk of service outages.

Mitigation requires applying the official Linux kernel patches that correct the handling of freepointers during single object frees under the specified configurations. Organizations should: 1) Update Linux kernels to versions that include the fix for CVE-2024-36892 once available from their distribution vendors or the upstream Linux kernel. 2) Review kernel boot parameters and disable `init_on_free=1` unless explicitly required for debugging or security hardening, as this setting triggers the problematic code path. 3) Avoid enabling `slub_debug=F` and `CONFIG_SLAB_FREELIST_HARDENED=y` simultaneously in production environments unless necessary, or ensure patches are applied before enabling these options. 4) Conduct thorough testing of kernel updates in staging environments that replicate production configurations to detect any stability issues. 5) Monitor kernel logs for "Freepointer corrupt" messages as indicators of this issue. 6) For critical systems, consider fallback to alternative memory allocators or kernel configurations that do not trigger this vulnerability until patched. These steps go beyond generic advice by focusing on configuration management and proactive patching tailored to the specific kernel features involved.