Skip to content

Taking over the boot

Turning Off Driver Signing From the Boot Chain (DSE, HVCI)

How bootkits defeat kernel code signing before Windows or Linux enforces it: TDL4's WinPE trick, ESPecter's DSE patch, BlackLotus and HVCI, Bootkitty. Checks.

Goal
Taking over the boot
Layer
Boot
Where it acts
UEFI variablesEFI system partitionIn memoryOn the system volumeOn the boot chain map
Platforms
Windows, Linux
Also known as
DSE bypass from the boot chain, Code integrity bypass, Module signature bypass
Checked by
EFI system partitionMeasured Boot logs

Overview

64-bit Windows loads kernel code only if it is signed: the kernel-mode code signing policy has applied since Windows Vista, and since Windows 10 version 1607 new drivers must, with few exceptions, be signed through Microsoft's portal. Memory integrity (HVCI) moves the check into a hypervisor-protected environment. Linux kernels that enforce module signatures load only validly signed modules (kernel.org).

A bootkit runs before the check exists. From the boot chain it can switch the check off for this boot, patch the code that performs it, load its own kernel code by a path the check never sees, or stop the hypervisor layer from starting. ESET's Virus Bulletin 2014 paper ties the return of bootkits after 2007 to the code signing policy of 64-bit Vista. For most families in this catalogue, this is what the boot infection is for.

Doing the same from the running operating system, with a vulnerable signed driver or by patching code integrity variables in kernel memory, is a different technique, covered on rootkits.dev as driver signature enforcement tampering.

How it works

ApproachWhat changesWhere it livesFamilies
Change the configurationA boot option the loader reads: test signing, integrity checks off, Windows PE modeThe BCD on disk, or the loader's copy in memoryTDL4; BlackLotus's exploit configuration
Patch the checkThe code that sets up or performs signature checksKernel or loader memory, every bootESPecter, Bootkitty
Go around the checkKernel code loaded by the bootkit itself, never by the Windows loaderKernel memoryRovnix, Gapz, TDL4
Stop the enforcerMemory integrity and virtualization-based securityRegistry and a UEFI variableBlackLotus

The configuration route is the one Windows exposes. bcdedit /set testsigning on lets drivers signed with any certificate load and shows a "Test Mode" watermark; nointegritychecks disables integrity checks. Both need administrator rights and both are guarded by Secure Boot: nointegritychecks "cannot be set when secure boot is enabled", and setting test signing fails with "The value is protected by Secure Boot policy". A bootkit does not need bcdedit: it can change the settings in memory as the loader reads them.

The patching route leaves the configuration alone: the patch exists only in memory, redone at every boot. Nothing in ESET's descriptions of ESPecter or Bootkitty touches the boot configuration, so the settings on disk, and those Windows measures at boot, would show their defaults.

Going around the check changes nothing in it. The loader and kernel check the drivers they load; a bootkit that hooks the kernel during initialisation copies its own code into kernel memory and runs it, and no check ever sees it.

How families use it

FamilyApproachWhat the reports describeSource
TDL4Configuration, in memory; going aroundReplaces the BCD element BcdLibraryBoolean_EmsEnabled (16000020) with BcdOsLoaderBoolean_WinPEMode (26000022) as the loader reads it: "There is no code integrity control in WinPE mode". It then substitutes its own kdcom.dll, which loads the rootkit driver from the hidden store, and disables WinPE mode again by distorting the /MININT optionKaspersky, 2011; ESET, 2011 and 2014
ESPecterPatchingPatches the kernel function SepInitializeCodeIntegrity in memory to disable Driver Signature Enforcement, and also MiComputeDriverProtection; without that patch it does not drop its driverESET, 2021
RovnixGoing aroundCopies itself over the second half of the IDT, sets hardware breakpoints, regains control during kernel initialisation and "manually loads its own malicious driver", "thus bypassing the kernel-mode code integrity check"ESET, 2011
GapzGoing aroundHooks IoInitSystem, then reads its kernel code from disk and runs it in a new system thread. Its kernel code is position-independent blocks, not a driver, and ESET notes that ELAM cannot help, since it "is only able to monitor legitimately loaded drivers"ESET, 2012 and 2013
BlackLotusStopping the enforcer; configuration for the exploitThe installer sets HypervisorEnforcedCodeIntegrity\Enabled to 0 "to be able to run custom unsigned kernel code later". At boot the bootkit creates the boot-only VbsPolicyDisable variable, which the Windows loader evaluates so that HVCI and Credential Guard "will not be initialized", and hooks the entry point of disk.sys to run its kernel driver. The attacker BCD used for CVE-2022-21894 sets testsigning and nointegritychecks so that hvloader.efi runs self-signed codeESET, 2023
BootkittyPatchingIn the Linux kernel, "the function module_sig_check is patched to always return 0", so "the kernel will load any module without verifying the signature". Earlier it hooks GRUB's signature checks and, with Secure Boot on, the firmware's EFI_SECURITY_ARCH_PROTOCOL and EFI_SECURITY2_ARCH_PROTOCOL authentication functions so that they report successESET, 2024

Microsoft closed TDL4's route in April 2011 with update 2506014: ESET found that the WinPE option "is no longer used in the initialization of code integrity policy" and that kdcom.dll gained an export so TDL4 no longer recognised it; infected machines could not be expected to install it.

Traces it leaves

WhereTraceRoute
BCD (ESP\EFI\Microsoft\Boot\BCD, or \Boot\BCD on BIOS systems)testsigning or nointegritychecks set; a store pointing at another BCDConfiguration on disk (BlackLotus's staging BCD)
C:\Windows\Logs\MeasuredBoot\Test signing on, code integrity off, a transfer without signature check, modules loaded without a validated imageConfiguration, when the loader saw it
SYSTEM hiveDeviceGuard\Scenarios\HypervisorEnforcedCodeIntegrity, Enabled = 0BlackLotus
UEFI NVRAMVbsPolicyDisableBlackLotus
Live WindowsMemory integrity configured but not running; "Test Mode" watermarkStopping the enforcer; test signing
Linux kernelTaint flag E ("unsigned module was loaded") in /proc/sys/kernel/taintedBootkitty and its unsigned modules
MemoryPatched code integrity routines; kernel code with no driver filePatching; going around

The patch and go-around routes leave no configuration trace. Their evidence is the rest of the infection: the boot sectors, the ESP files and the unsigned kernel code.

How to check a host

Offline.

  • Read every BCD store: the one on the ESP, any other on the ESP (BlackLotus stages one in ESP:\system32\), and \Boot\BCD on BIOS systems. On an analysis machine, bcdedit /store <file> /enum all lists their settings.
  • Decode the Measured Boot logs boot by boot and compare Windows' boot settings: test signing, code integrity, debugging, Windows PE, and the memory integrity and VBS policy events. Reading Measured Boot logs shows how.
  • Read the memory integrity value in the SYSTEM hive; on Linux, the kernel log's taint messages.

Live, Windows, elevated:

bcdedit /enum "{current}"
powershell -c "Confirm-SecureBootUEFI"
powershell -c "Get-CimInstance -ClassName Win32_DeviceGuard -Namespace root\Microsoft\Windows\DeviceGuard | Format-List SecurityServicesConfigured, SecurityServicesRunning, VirtualizationBasedSecurityStatus"

In Microsoft's documentation, the value 2 in SecurityServicesConfigured and SecurityServicesRunning means memory integrity is configured and running. Memory integrity off where policy wants it on, or configured but not running, needs an explanation: BlackLotus does the first through the registry and the second through VbsPolicyDisable.

Live, Linux: mokutil --sb-state, cat /proc/sys/kernel/tainted (0 means untainted; the kernel documentation decodes the bits) and uname -v, where ESET lists BoB13 as a Bootkitty sign. ESET adds that an unsigned test module that loads on a Secure Boot system means signature checking is off; run that test only on a host you can afford to taint.

Memory. For patched code integrity state in a Windows memory image, see rootkits.dev's DSE tampering page. A live check runs under the bootkit's kernel code, so a clean answer is weak.

What the checker looks for

  • esp reads every BCD store on the ESP and BIOS-era \Boot\BCD stores, and raises "The BCD enables test signing", "The BCD disables integrity checks" (for nointegritychecks or a DISABLE_INTEGRITY_CHECKS load option), "The BCD turns the hypervisor off", "The BCD disables early-launch anti-malware drivers" and the debugging findings. On BlackLotus's staging BCD it also raises "The boot manager is told to load another BCD store".
  • measuredboot reads Windows' boot settings in each log and raises "Test signing was on at boot", "Code integrity was off at boot", "The boot manager handed over to an application without a signature check" and "A module was loaded without a validated signature", plus kernel, boot and hypervisor debugging. It shows Windows PE, safe mode and the hypervisor launch type in the boot's details without a finding, and it does not report the VBS and memory integrity policy events: read those with TCGLogTools.

What it cannot see: in-memory patches (ESPecter, Bootkitty, TDL4's WinPE switch), kernel code loaded around the check (Rovnix, Gapz), and the VbsPolicyDisable variable in NVRAM. The SYSTEM hive's memory integrity value and the Linux kernel taint are read by the rootkits.dev checker instead. The family pages list what the checker sees of each bootkit's own files.

Mitigation and recovery

Prevention.

  • Secure Boot on. It locks the test signing and integrity options and, on Windows 10 version 1607 and later, limits kernel drivers to Microsoft's roots (Driver Signing Policy). It also stops unsigned boot code such as ESPecter's patched boot manager. Keep its revocations current: BlackLotus ran with Secure Boot on (see Secure Boot rollback).
  • Memory integrity with UEFI lock. Microsoft notes that the lock prevents it being disabled "remotely or by policy update"; turning it off then needs access to the firmware menu.
  • Linux: Secure Boot with a kernel that enforces module signatures (lockdown allows "only validly signed modules"), a reviewed MOK list (see shim and MOK abuse), and firmware updates for LogoFAIL.
  • Measured Boot with remote attestation, so that the TPM, not the host, reports a boot with test signing or integrity checks off.

Recovery. Undoing a setting is not enough. Unsigned kernel code ran with full control for at least one boot. Preserve the ESP, the boot sectors, the Measured Boot logs and the SYSTEM hive, then rebuild from trusted media, restore the settings (test signing off, memory integrity on), remove attacker keys from the MOK list, and rotate the credentials used on the host.

Sources

Primary public reports, newest first.

  1. 2026-10-21Enable memory integrityMicrosoft
  2. 2025-04-16Loading Test Signed CodeMicrosoft
  3. 2024-11-27Bootkitty: Analyzing the first UEFI bootkit for LinuxESET
  4. 2024-08-19Driver Signing PolicyMicrosoft
  5. 2023-04-11Guidance for investigating attacks using CVE-2022-21894: The BlackLotus campaignMicrosoft
  6. 2023-03-01BlackLotus UEFI bootkit: Myth confirmedESET
  7. 2022-03-16BCDEdit /setMicrosoft
  8. 2021-10-05UEFI threats moving to the ESP: Introducing ESPecter bootkitESET
  9. 2014-11-12Bootkits: past, present & futureVirus Bulletin (ESET)
  10. 2013-04-08Mind the Gapz: The most complex bootkit ever analyzed?ESET
  11. 2012-12-27Win32/Gapz: New Bootkit TechniqueESET
  12. 2011-08-23Hasta La Vista, Bootkit: Exploiting the VBRESET
  13. 2011-04-15KB2506014 kills TDL4 on x64ESET
  14. 2011-01-25TDSS. TDL-4Kaspersky

See also

Related techniques

Families that use it