Skip to content

Read in your browser. Nothing is uploaded.

Look below the operating system.

An offline rootkit and bootkit checker for incident responders. Drop a collection: the EFI system partition, Measured Boot logs, Windows drivers and their services, MBR, VBR and GPT boot sectors, Linux kernel modules and preload settings are read in your browser and checked against what a clean system looks like.

  • Runs in your browser
  • Nothing is uploaded
  • Windows, Linux and raw disks

rootkits.dev

Read in your browser. Nothing is uploaded.

Drop a collection, a folder or files

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

The sample holds four synthetic hosts: a Windows 11 workstation, an Ubuntu server, a lab disk head and a lab EFI system partition. Every file is harmless.

ReadsESP/EFIMeasuredBoot\*.logSYSTEMAmcache.hvedrivers\*.sys*.evtxdisk0.img*.kold.so.preloadkern.log.zip / .tar.gz

Collect

How to collect what the checker reads

Copy the files 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 rootkit that is running can hide its own files from the copy.

  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, paste these lines (a .bat file would read "%4" in the log's name as an argument). They copy the EFI system partition, the Measured Boot logs, the SYSTEM and Amcache hives, the drivers and two event logs into E:\case\<computer name>, keeping the 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. A shadow copy of C: (note its number in the output of the second command)
powershell -c "Invoke-CimMethod -ClassName Win32_ShadowCopy -MethodName Create -Arguments @{Volume='C:\'}"
vssadmin list shadows
mklink /d "%TEMP%\rk_vss" \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\
rem 3. Measured Boot logs, the SYSTEM and Amcache hives, the drivers
robocopy "%TEMP%\rk_vss\Windows\Logs\MeasuredBoot" "%CASE%\C\Windows\Logs\MeasuredBoot" /B /COPY:DT /R:0 /W:0
robocopy "%TEMP%\rk_vss\Windows\System32\config" "%CASE%\C\Windows\System32\config" SYSTEM /B /COPY:DT /R:0 /W:0
robocopy "%TEMP%\rk_vss\Windows\AppCompat\Programs" "%CASE%\C\Windows\AppCompat\Programs" Amcache.hve /B /COPY:DT /R:0 /W:0
robocopy "%TEMP%\rk_vss\Windows\System32\drivers" "%CASE%\C\Windows\System32\drivers" *.sys /S /B /COPY:DT /R:0 /W:0
rmdir "%TEMP%\rk_vss"
rem 4. The System and Code Integrity logs
mkdir "%CASE%\C\Windows\System32\winevt\Logs"
wevtutil epl System "%CASE%\C\Windows\System32\winevt\Logs\System.evtx"
wevtutil epl Microsoft-Windows-CodeIntegrity/Operational "%CASE%\C\Windows\System32\winevt\Logs\Microsoft-Windows-CodeIntegrity%4Operational.evtx"
  • 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.
  • Change HarddiskVolumeShadowCopy1 to the number vssadmin list shadows prints for the copy you just made.
  • If a driver service points to a file outside System32\drivers (sc qc <service> shows its path), copy that file too, into the same layout under C\.
  • Zip E:\case\<computer name> and drop the zip here, or drop the folder.

With KAPE

Command Prompt · administrator
kape.exe --tsource C: --tdest E:\case\%COMPUTERNAME% --target RegistryHivesSystem,Amcache,EventLogs,Drivers

The RegistryHivesSystem, Amcache, EventLogs and Drivers targets cover the hives, the event logs and System32\drivers. KAPE has no target for the ESP or the Measured Boot logs: also run step 1 and the MeasuredBoot copy of step 3 above, into the same folder.

Before you collect

  • Copying from a running, possibly compromised system lets a kernel rootkit hide its files from the copy. An image of the disk, or a copy made after booting trusted media, avoids that.
  • Keep the original times: robocopy /COPY:DT 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

Five places a rootkit leaves traces on disk

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

  • Boot

    EFI system partition

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

    ESP\EFI\…, EFI\Microsoft\Boot\BCD

  • Boot

    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

  • Boot

    Disk boot sectors

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

    disk0.img, *.dd, *.raw, *.bin

  • Kernel

    Windows drivers

    Kernel driver services from the SYSTEM hive, the driver files with their signatures and hashes, Amcache's driver entries, and the System and Code Integrity events about drivers.

    SYSTEM, drivers\*.sys, Amcache.hve, *.evtx

  • Kernel

    Linux kernel

    Kernel modules with their signatures, metadata and symbols, how they are loaded at boot, /etc/ld.so.preload and the libraries it names, and the kernel log's taint messages.

    lib/modules/…/*.ko, ld.so.preload, kern.log

  • Firmware · Memory

    What no disk shows

    Firmware implants in the SPI flash, rootkits that live only in 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

The catalogue

Rootkit and bootkit families

What is publicly known about each family, the traces it leaves on disk, how to check a host offline and live, and how to recover, with the sources.

All families

Reference

What rootkits and bootkits are

A rootkit hides an intruder's presence: it changes what the system reports, so that files, processes, network connections or its own code do not show. A bootkit is a rootkit that starts before the operating system, from the boot chain, so it can tamper with the system as it loads.

They are sorted here by the layer they live in, 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 install into the operating system; the firmware itself has to be dumped and compared with the vendor's image.
  2. BootUEFI bootkits change or add files on the EFI system partition and the Windows boot configuration, and those boots appear in the Measured Boot logs. Legacy bootkits change the MBR's code or a volume boot record, or keep data in sectors outside any partition.
  3. KernelWindows kernel rootkits arrive as drivers: a .sys file, a service key that loads it, events when it is installed or refused. Linux ones are loadable kernel modules: a .ko file, a line in the module load configuration, taint messages in the kernel log.
  4. UserlandUser-mode rootkits hook functions inside processes. On Linux the usual way in is /etc/ld.so.preload and a shared library it names; on Windows the hooks live in memory, and the disk shows only what loads them.

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 tail.
  • Each module parses its formats itself (PE and Authenticode, PKCS#7, registry hives, TCG event logs, MBR, GPT and boot records, ELF), 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 copied from a disk. That shows a lot about the boot chain and the kernel's load configuration, and nothing about what only exists in memory or in the firmware.

It can show

  • Boot files, drivers and kernel modules that are unsigned, signed by an unexpected name, or whose content no longer matches their signature.
  • Boot records and boot code that match no known loader, hidden data between partitions, and boot settings that weaken integrity checks.
  • Driver services and module load settings that point to odd places, with the times the files, hives and logs record.
  • Boots that Measured Boot recorded with Secure Boot off or with an unexpected boot application.

It cannot see

  • Rootkits that live only in memory, or whose files were hidden 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: 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 a loaded rootkit.
  • Dump the firmware and compare it with the vendor's image when a firmware implant is possible.
  • Collect from a mounted image or an offline boot rather than from the running system when you can.
  • 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

rootkits.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 rootkit. It is not 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, boot records, drivers, kernel modules and their load settings. A rootkit that lives only in memory, a firmware implant, or files hidden 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, C:\Windows\Logs\MeasuredBoot, the SYSTEM and Amcache hives, System32\drivers, and the System and Code Integrity event logs. On Linux: /lib/modules for the running kernel, /etc/modules-load.d, /etc/modprobe.d, /etc/ld.so.preload, the dpkg file lists and kern.log, or run the collect script. For boot sectors: the head and tail of the disk. 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 and last MiB. For the files inside the image, open it in Disk Image Parser and hand them over with “Open in rootkits.dev”.

Why does the sample flag files that do nothing?

The sample is synthetic: its lab hosts reproduce the layout publicly reported for bootkits with placeholder files 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
Hunt vulnerable (BYOVD) and malicious Windows drivers offline: service keys, driver files and signers, Amcache, LOLDrivers, the blocklist and CodeIntegrity.
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.
How to check a Linux host's kernel modules from an image: signatures, modules.order and modules.dep, package ownership, taint, symbols, live outputs and limits.