Skip to content

Read in your browser. Nothing is uploaded.

Check what runs before the OS.

An offline bootkit checker for incident responders. Drop a collection: the EFI system partition, the Measured Boot logs and the disk's boot sectors (MBR, VBR, GPT) are read in your browser and checked against what a clean boot chain looks like.

  • Runs in your browser
  • Nothing is uploaded
  • UEFI and legacy BIOS

bootkits.dev

Read in your browser. Nothing is uploaded.

Drop a collection, a folder or files

A copy of an EFI system partition, a Windows Measured Boot folder, a zip or tar.gz from the Linux collect script, a KAPE or Velociraptor collection, or a raw disk image. Disk images are read at their head and end only.

The sample holds three synthetic hosts: a Windows 11 workstation's boot files, the head of a lab disk and a lab EFI system partition. Every file is harmless.

ReadsESP/EFI*.efiBCDMeasuredBoot\*.logbinary_bios_measurementsdisk0.img*.dd / *.raw.zip / .tar.gz

Windows drivers and Linux kernel modules are checked on rootkits.dev.

Collect

How to collect what the checker reads

Copy the files and sectors from the host you are investigating, keep them in one folder per host, then zip the folder or drop it here. Work from an image or an offline copy when you can: a bootkit that is running can filter what the copy reads.

  1. Run the commands as administrator or root
  2. Keep one folder per host, then zip it
  3. Drop the zip or the folder here

In an elevated Command Prompt, run these lines. They copy the EFI system partition and the Measured Boot logs into E:\case\<computer name>, keeping the ESP\… and C\Windows\… layout.

Command Prompt · administrator
set "CASE=E:\case\%COMPUTERNAME%"
rem 1. The EFI system partition: mount it on a free letter (S:), copy it, unmount it
mountvol S: /S
robocopy S:\ "%CASE%\ESP" /E /COPY:DT /DCOPY:T /R:0 /W:0
mountvol S: /D
rem 2. The Measured Boot logs, in backup mode
robocopy C:\Windows\Logs\MeasuredBoot "%CASE%\C\Windows\Logs\MeasuredBoot" /B /COPY:DT /DCOPY:T /R:0 /W:0
  • mountvol S: /S needs a UEFI machine and a free drive letter; pick another letter if S: is taken. Windows mounts the ESP writable: only copy from it, and unmount it at once.
  • robocopy /B reads the Measured Boot logs in backup mode, whatever their permissions; it needs the elevated prompt.
  • The disk's boot sectors (MBR, GPT, VBR and the sectors around them): Windows has no built-in command that reads a disk's raw sectors without being able to write them. Image the disk with your forensic imager and drop the raw image here, or open an E01 in Disk Image Parser; or boot the machine from trusted Linux media and use the Linux commands.
  • Zip E:\case\<computer name> and drop the zip here, or drop the folder.

Before you collect

  • Reading a running, possibly compromised system lets a bootkit filter what you read: MBR and VBR bootkits return the original sectors, and a UEFI bootkit can hide its files. An image of the disk, or a copy made after booting trusted media, avoids that.
  • Keep the original times: robocopy /COPY:DT, cp -p and tar keep modification times; copying through Explorer or some sync tools does not.
  • Collections contain personal data and security-sensitive settings: store and share them accordingly.

What it checks

Three places a bootkit leaves traces on disk

Each module reads one part of the boot chain, lists what it finds and flags what does not fit, with the reason and the evidence.

  • UEFI

    EFI system partition

    Boot managers, loaders and other EFI binaries with their Authenticode signatures and digests, the Windows boot configuration (BCD), and files and folders that should not be on the ESP.

    ESP\EFI\…, EFI\Microsoft\Boot\BCD, /boot/efi

  • TPM event log

    Measured Boot logs

    The TCG event logs Windows keeps for each boot, and Linux's binary_bios_measurements: Secure Boot state, the boot applications that ran, and boot settings such as test signing.

    Windows\Logs\MeasuredBoot\*.log, binary_bios_measurements

  • BIOS and GPT

    Disk boot sectors

    The MBR, the GPT and its backup, each partition's volume boot record and the sectors around them, read from a disk image's head and end.

    disk0.img, disk0.tail-…img, *.dd, *.raw

  • Firmware · Memory

    What no disk shows

    Firmware implants in the SPI flash, bootkits that patch only memory, and the Secure Boot variables are not in a disk collection. The checker says so, and points to memory forensics and firmware dumps.

    The limits
  • Kernel · Userland

    Drivers and kernel modules

    What loads after the boot chain, Windows kernel drivers and Linux kernel modules with their load and preload settings, is checked by the sister site rootkits.dev, offline in the browser too.

    Open rootkits.dev

Boot chain map

Where each bootkit lives

The boot chain from power-on, and what each family in the catalogue writes or patches at each step. Follow one family to see its whole path, and which steps the checker reads.

All families

Written herePatched in memory, files unchanged

  1. 01

    Firmware

    The SPI flash: runs before any disk is read.

    Not on disk: needs a firmware dump, compared with the vendor's image

  2. 02

    Boot code on disk

    What the firmware starts: files on the ESP, or the disk's boot sectors.

  3. 03

    OS loader and kernel

    Patched as they load; the files on disk stay unchanged.

    Not on disk: needs a memory image, or the place it starts from

  4. 04

    Operating system

    Files the bootkit writes as the system starts.

    OS-level traces: checked by rootkits.dev

How they work

Techniques bootkits use

What each technique changes in the boot chain, the traces it leaves and how to check a host for it, grouped by what it achieves for the bootkit, with the families that use it.

All techniques

Reference

What bootkits are

A bootkit is malware that starts before the operating system, from the boot chain: the firmware runs a boot manager, which loads the operating system's loader, which loads the kernel. A bootkit takes one of those steps, so it runs first and can tamper with the system as it loads, below what the operating system's own security sees.

They are sorted here by where they live, from the hardware up. The lower the layer, the earlier it runs, the more it can hide, and the less a live tool on the running system can be trusted to see it.

Layer by layer: what each leaves on disk

  1. FirmwareImplants in the SPI flash run before any disk is read. On disk they leave at most what they drop into the operating system; the firmware itself has to be dumped and compared with the vendor's image.
  2. UEFI bootUEFI bootkits replace or add files on the EFI system partition, such as a boot manager, a loader or a staging folder, and change the Windows boot configuration (BCD). The boots they start appear in the Measured Boot logs: Secure Boot state, the boot applications that ran, test signing or integrity checks turned off.
  3. Legacy bootOn BIOS machines, MBR bootkits replace the boot code in the disk's first sector, VBR bootkits change a partition's boot record or its parameters, and both keep their code in sectors outside any partition, before the first one or after the last.
  4. KernelWhat a bootkit loads next, a driver or a kernel module, lives in the operating system. Its traces are in the system's files and logs, which rootkits.dev checks.

How the checker reads them

  • Everything runs in your browser, in a Web Worker. Archives are opened in place; only the files a module asks for are read, and disk images only at their head and end.
  • Each module parses its formats itself (PE and Authenticode, PKCS#7, registry hives for the BCD, TCG event logs, MBR, GPT and boot records), bounded against damaged or hostile files: sizes, counts, offsets and loops are capped.
  • A finding names what is unexpected, why it matters, the evidence (names, paths, values and raw bytes) and, when the evidence matches public reporting, the families it is consistent with.
  • Times are shown in UTC as the files record them. Exports (Markdown report, CSV, JSON) are generated in the page.

What an offline check can and cannot show

The checker reads files and sectors copied from a disk. That shows a lot about the boot chain, and nothing about what exists only in memory or in the firmware.

It can show

  • Boot managers, loaders and other EFI binaries that are unsigned, signed by an unexpected name, or whose content no longer matches their signature.
  • Files and folders on the EFI system partition that do not belong there, and boot settings (BCD) that weaken integrity checks.
  • Boot records and boot code that match no known loader, and data hidden between and after partitions.
  • Boots that Measured Boot recorded with Secure Boot off, with an unexpected boot application, or with test signing on.

It cannot see

  • Bootkits that patch only memory, or whose files and sectors were filtered from the tool that made the collection on a running, compromised system.
  • Firmware (SPI flash) implants: the firmware is not part of a disk collection.
  • The UEFI variables (NVRAM), including the Secure Boot databases db and dbx and the MOK list: whether a revoked boot manager would still be allowed to run.
  • Whether a certificate chain is trusted: it names the signers and checks digests, it does not validate chains against a trust store or revocation lists.

What to do next

  • Capture and analyse memory (for example with Volatility or MemProcFS) on a host you suspect: it is the reference for code that is running.
  • Dump the firmware and compare it with the vendor's image when a firmware implant is possible.
  • Image the disk offline, powered off or booted from trusted media, rather than reading it from the running system.
  • Reinstall from known-good media, and reflash the firmware or replace the hardware when a boot or firmware implant is confirmed; follow vendor guidance for Secure Boot revocations.

Privacy

Your files never leave your device: there is no upload and no server-side analysis. The page makes no request to a third party while it reads them, and closing or reloading it forgets everything.

About this site

bootkits.dev is an independent, free site by a DFIR engineer, written for incident responders and defenders. It covers detection and response only: no code, procedures or details that would help build or deploy a bootkit. Its sister site rootkits.dev covers what loads after the boot chain: Windows drivers and Linux kernel modules. Neither is affiliated with Microsoft, the Linux kernel project, the UEFI Forum or any security vendor.

Frequently asked questions

Is anything uploaded?

No. The files are read by code running in your browser, in a Web Worker; they are never sent to a server. Exports are generated in the page too.

If the checker finds nothing, is the host clean?

No. It shows what a disk collection can show: boot files, the boot configuration, the recorded boots and the boot sectors. A bootkit that patches only memory, a firmware implant, or files and sectors filtered from the tool that made the collection are outside its reach. Use memory forensics and a firmware dump when the stakes call for it.

Does it check Secure Boot revocations (dbx)?

No. The UEFI variables are not part of a disk collection. The checker can tell you which boot manager was on the ESP and which boot application ran in each recorded boot, but not whether the firmware's dbx would block it.

What should I collect?

On Windows: the EFI system partition and C:\Windows\Logs\MeasuredBoot, and an image of the disk for its boot sectors. On Linux: run the collect script, or copy /boot/efi, /sys/kernel/security/tpm0/binary_bios_measurements and each disk's first 4 MiB and last MiB. The collect guide has the commands.

Can I check a whole disk image?

Yes, for its boot sectors: drop the raw image and the checker reads only its first 4 MiB and last MiB. For the files inside the image, open it in Disk Image Parser and hand them over with “Open in bootkits.dev”.

Where are Windows drivers and Linux kernel modules checked?

On the sister site rootkits.dev, which reads the SYSTEM hive, driver files and event logs on Windows, and kernel modules, their load settings and ld.so.preload on Linux, in the browser too.

Why does the sample flag files that do nothing?

The sample is synthetic: its lab hosts reproduce the layouts publicly reported for bootkits with placeholder files and sectors that contain no malicious code. Their signature results therefore differ from a real infection's, which the sample banner says.

From the blog

Blog

Read the blog
A worked bootkit check of three synthetic hosts: a clean ESP and two Measured Boot logs, a Gapz-like disk head and a BlackLotus-like EFI system partition.
Collect the EFI system partition on Windows and Linux, learn what a normal one holds, and check signers, the BCD store, file times and BlackLotus traces.
Where Windows keeps Measured Boot logs, how the TCG log and its SIPA events are built, how to decode and compare boots, and what BlackLotus leaves in them.