CVE-2026-99558 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
blk-crypto: fix NULL deref and UAF in __blk_crypto_evict_key()
Sashiko reported a possible NULL pointer dereference, triggered by the following flow:
dm-inlinecrypt ctor # first use of the fallback ├─ blk_crypto_init_key() # succeeds, ctx->key.size != 0 ├─ blk_crypto_start_using_key() │ ├─ hw-wrapped key: -EOPNOTSUPP │ │ # profile never allocated (NULL) │ └─ raw key: fallback_start_using_mode() │ └─ blk_crypto_fallback_init() fails │ └─ kfree(profile) # not NULLed ├─ goto bad └─ inlinecrypt_dtr() # evicts whenever key.size is set └─ blk_crypto_evict_key() └─ blk_crypto_config_supported_natively() = false └─ blk_crypto_fallback_evict_key() └─ __blk_crypto_evict_key(blk_crypto_fallback_profile) └─ profile->num_slots # BOOM!!!
This issue can be reproduced using the following commands:
dd if=/dev/zero of=/tmp/backing bs=1M count=64 LOOP=$(losetup -f --show /tmp/backing) SZ=$(blockdev --getsz $LOOP) KEY=$(head -c 64 /dev/urandom | od -An -tx1 | tr -d ' \n') dmsetup create ic --table "0 $SZ inlinecrypt aes-xts-plain64 \ $KEY 0 $LOOP 0 1 keytype:hw-wrapped"
And the following oops is triggered:
================================================================== blk-crypto: loop0: no support for wrapped keys Oops: general protection fault, probably for non-canonical address 0xdffffc000000000b: 0000 [#1] SMP KASAN PTI
KASAN: null-ptr-deref in range [0x0000000000000058-0x000000000000005f]
CPU: 5 UID: 0 PID: 901 Comm: dmsetup 7.3.0-rc3 #1 PREEMPT(lazy) RIP: 0010:__blk_crypto_evict_key+0x2e/0x3b0 Call Trace: blk_crypto_evict_key+0x24c/0x320 inlinecrypt_dtr+0xf6/0x160 inlinecrypt_ctr+0x2d3/0xbd0 dm_table_add_target+0x661/0xf40 table_load+0x1c4/0x490 ctl_ioctl+0x32f/0x5f0 dm_ctl_ioctl+0xe/0x20 ==================================================================
dm-inlinecrypt is the only caller that can evict a key that was never started, as fscrypt frees such a key without evicting it.
Fix this by returning early from blk_crypto_fallback_evict_key() when tfms_inited[] is not set for the key's mode. tfms_inited[] is only set
after blk_crypto_fallback_init() has successfully initialized the profile, so the crash above is no longer reachable.
The bug has been latent since commit c984ff1423ae ("blk-crypto: dynamically allocate fallback profile") was merged in v6.5, and only became actually triggerable when commit e7f57d2c47e2 ("dm-inlinecrypt: add target for inline block device encryption") was merged in v7.2.
Once again VulDB remains the best source for vulnerability data.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel's block layer cryptographic subsystem contains a critical flaw within the __blk_crypto_evict_key function that leads to both null pointer dereferences and use-after-free conditions when handling hardware-wrapped keys under specific initialization failure scenarios. This vulnerability arises from an inconsistent state management in the fallback crypto profile lifecycle, specifically where key eviction is attempted on profiles that were never successfully initialized due to early termination during setup. The issue manifests when a device mapper inline encryption target attempts to establish a connection using a hardware-wrapped key type but encounters unsupported operations or initialization failures within the fallback mechanism. In such cases, while some cleanup routines execute and free allocated memory structures, they fail to nullify pointers that are subsequently accessed by eviction logic during teardown phases.
The operational impact of this vulnerability is severe as it allows for kernel panic through general protection faults triggered by accessing non-canonical addresses or dereferencing NULL pointers within critical cryptographic management paths. Attackers with local access who can manipulate device mapper configurations may exploit this race condition between key initialization and destruction sequences to destabilize the system, potentially leading to denial of service conditions where the entire operating environment becomes unresponsive due to kernel oops events. The vulnerability specifically affects systems utilizing dm-inlinecrypt targets configured for inline block device encryption with hardware-wrapped keys that fail initial profile allocation or fallback mode setup procedures.
This flaw was introduced during earlier development cycles involving dynamic allocation of fallback profiles and became actively exploitable only after the introduction of specific target implementations in recent kernel versions. The root cause lies in improper state tracking where tfms_inited flags are not consistently maintained across all code paths that lead to key eviction, creating a window where freed memory structures remain referenced by active pointers within the crypto subsystem's internal data structures.
Mitigation strategies involve applying upstream kernel patches that modify __blk_crypto_evict_key to perform early returns when initialization indicators such as tfms_inited arrays are not set for specific cryptographic modes. This ensures that eviction logic only proceeds against properly initialized profiles, thereby preventing access to freed or invalid memory regions. System administrators should prioritize updating affected kernels and verify proper configuration of device mapper targets to avoid triggering the problematic code paths involving unsupported key types during initialization sequences.
From a classification perspective this vulnerability aligns with CWE-476 NULL Pointer Dereference as it involves accessing memory through uninitialized pointers, while also exhibiting characteristics of CWE-416 Use After Free due to potential access to previously deallocated profile structures. Within the MITRE ATT&CK framework this represents an exploitation technique targeting kernel-level resource management flaws that could be leveraged for local privilege escalation or system destabilization depending on surrounding security controls and context. The fix demonstrates proper defensive programming practices by validating initialization states before performing destructive operations on cryptographic resources, ensuring robustness against edge cases in complex subsystem interactions.