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
rootkits.dev · local analysisRead 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.
or
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.
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.
1Run the commands as administrator or root
2Keep one folder per host, then zip it
3Drop 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.
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.
The collect script copies what the Linux module reads, and a few live outputs, into one .tar.gz named after the host. It only reads the system, writes nothing but that archive in the folder you name, and uses no network. Read it before you run it.
#!/bin/sh
# rootkits-collect-linux.sh: collect the files rootkits.dev's offline checker
# reads on a Linux host (kernel modules and their indexes, module load
# configuration, ld.so.preload and the libraries it names, the dpkg file
# lists, kernel logs, the EFI system partition, the TPM event log) plus a few
# live outputs (/proc/modules, /sys/module, the taint value, uname, dmesg).
#
# Read-only: it changes nothing on the host. It writes only inside the output
# directory you choose: one .tar.gz, and a temporary folder for the live
# outputs that it removes when it exits. No network access.
#
# Usage: sudo sh rootkits-collect-linux.sh -o /media/usb [-a]
# -o DIR where to write the archive (required)
# -a collect the modules of every installed kernel, not only the running one
# -h this help
# Testing: ROOT=/path/to/fake/root sh rootkits-collect-linux.sh -o DIR
# reads every file and /proc, /sys value under ROOT instead of /.
#
# Caveat: this runs on the suspect system. A kernel rootkit or an
# ld.so.preload library can hide files and processes from it, and live
# outputs come from the suspect kernel. Prefer an image of the disk taken
# offline, and capture memory first if you can.
#
# MIT License
#
# Copyright (c) 2026 Florian Amette
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
set -u
umask 077
VERSION="1.0"
OUT=""
ALL_KERNELS=no
ROOT="${ROOT:-/}"
usage() {
# The header comment, up to the licence.
sed -n '2,/^# MIT License/p' "$0" | sed '$d' | sed 's/^# \{0,1\}//'
}
while getopts "o:ah" opt; do
case "$opt" in
o) OUT="$OPTARG" ;;
a) ALL_KERNELS=yes ;;
h) usage; exit 0 ;;
*) usage >&2; exit 2 ;;
esac
done
say() { printf '%s\n' "$*"; }
warn() { printf 'warning: %s\n' "$*" >&2; }
if [ -z "$OUT" ]; then
usage >&2
say "error: choose an output directory with -o" >&2
exit 2
fi
if [ ! -d "$OUT" ] || [ ! -w "$OUT" ]; then
say "error: $OUT is not a writable directory" >&2
exit 2
fi
case "$ROOT" in
/) R="" ;;
*) R="${ROOT%/}" ;;
esac
if [ ! -d "$ROOT" ]; then
say "error: ROOT=$ROOT is not a directory" >&2
exit 2
fi
if [ "$(id -u)" != "0" ]; then
warn "not running as root: some files (dmesg, module trees, logs) may be unreadable"
fi
# ----------------------------------------------------------------- naming ---
HOST=$(cat "$R/etc/hostname" 2>/dev/null || hostname 2>/dev/null || echo host)
HOST=$(printf '%s' "$HOST" | head -n 1 | tr -c 'A-Za-z0-9._-' '_' | cut -c1-63)
# The host folder of every member: never "." or "..", never an option to tar.
case "$HOST" in
.* | -*) HOST="_$HOST" ;;
esac
[ -n "$HOST" ] || HOST=host
STAMP=$(date -u +%Y%m%dT%H%M%SZ)
ARCHIVE="$OUT/rootkits-$HOST-$STAMP.tar.gz"
if [ -e "$ARCHIVE" ]; then
say "error: $ARCHIVE already exists" >&2
exit 2
fi
STAGE=$(mktemp -d "$OUT/.rootkits-collect.XXXXXX") || { say "error: cannot create a temporary folder in $OUT" >&2; exit 1; }
DONE=no
# Interrupted: no half-written archive is left to pass for a complete one.
cleanup() {
rm -rf "$STAGE"
[ "$DONE" = yes ] || rm -f "$ARCHIVE"
}
trap cleanup EXIT
trap 'exit 130' INT TERM HUP
LIVE="$STAGE/_live"
mkdir "$LIVE"
LIST="$STAGE/files.txt"
: > "$LIST"
# ------------------------------------------------------------ file list ---
# Paths are relative to ROOT. Only regular files are listed, so symbolic
# links inside the trees (such as lib/modules/*/build) are never followed.
# tar reads the list one path per line: a name holding a line break would
# add a second, planted path (bsdtar even a whole directory), so such names
# are left out.
NL='
'
add_file() { # relative path
[ -f "$R/$1" ] && [ -r "$R/$1" ] && printf '%s\n' "$1" >> "$LIST"
}
add_tree() { # relative directory, then find(1) name tests
dir="$1"
shift
[ -d "$R/$dir" ] || return 0
(cd "$R/" && find "$dir" "$@" -type f ! -path "*$NL*" -print 2>/dev/null) >> "$LIST"
}
# A library ld.so.preload names (path relative to ROOT): only an ELF file of
# at most 128 MiB inside ROOT, what the loader can load. A planted entry or
# link never brings /etc/shadow or /proc/kcore into the archive, and never
# reads or writes outside ROOT and the output folder.
add_lib() {
case "$1" in
"" | -* | /* | .. | ../* | */.. | */../*) return 0 ;;
esac
[ -f "$R/$1" ] && [ -r "$R/$1" ] || return 0
[ "$(dd if="$R/$1" bs=4 count=1 2>/dev/null | od -An -tx1 | tr -d ' \n')" = 7f454c46 ] || return 0
[ "$(dd if="$R/$1" bs=65536 count=2049 2>/dev/null | wc -c | tr -d ' ')" -le 134217728 ] || return 0
add_file "$1"
}
# Merged /usr: /lib is /usr/lib; list each file once.
LIB_IS_LINK=no
[ -L "$R/lib" ] && LIB_IS_LINK=yes
RELEASE=$(cat "$R/proc/sys/kernel/osrelease" 2>/dev/null || uname -r)
if [ -d "$R/lib/modules" ]; then MODBASE=lib/modules; else MODBASE=usr/lib/modules; fi
if [ "$ALL_KERNELS" = yes ]; then
KTREES=$(cd "$R/$MODBASE" 2>/dev/null && ls -1)
else
KTREES="$RELEASE"
fi
nkernels=0
set -f
for k in $KTREES; do
[ -d "$R/$MODBASE/$k" ] || { warn "no module tree for kernel $k"; continue; }
nkernels=$((nkernels + 1))
(cd "$R/" && find "$MODBASE/$k" -type f \( -name '*.ko' -o -name '*.ko.zst' -o -name '*.ko.xz' -o -name '*.ko.gz' \
-o -name 'modules.order' -o -name 'modules.dep' -o -name 'modules.builtin' -o -name 'modules.builtin.modinfo' \) \
! -path "*/build/*" ! -path "*/source/*" ! -path "*$NL*" -print 2>/dev/null) >> "$LIST"
done
set +f
add_file etc/modules
for d in etc/modules-load.d etc/modprobe.d run/modules-load.d run/modprobe.d usr/lib/modules-load.d usr/lib/modprobe.d \
usr/local/lib/modules-load.d usr/local/lib/modprobe.d etc/depmod.d usr/lib/depmod.d; do
add_tree "$d"
done
if [ "$LIB_IS_LINK" = no ]; then
add_tree lib/modules-load.d
add_tree lib/modprobe.d
add_tree lib/depmod.d
fi
# ld.so.preload and every library it names.
PRELOAD_NOTE=""
if [ -f "$R/etc/ld.so.preload" ]; then
add_file etc/ld.so.preload
PRELOAD_NOTE="etc/ld.so.preload exists: a preloaded library may have hidden files from this collection"
# Entries are separated by whitespace or colons; no globbing.
set -f
# shellcheck disable=SC2013
for lib in $(sed -e 's/#.*//' -e 's/:/ /g' "$R/etc/ld.so.preload" 2>/dev/null); do
case "$lib" in
/*) add_lib "${lib#/}" ;;
esac
done
set +f
fi
add_tree var/lib/dpkg/info -name '*.list'
add_tree var/log -maxdepth 1 -name 'kern.log*'
add_tree var/log -maxdepth 1 -name 'messages*'
add_tree boot/efi/EFI
# ------------------------------------------------------------ live outputs ---
run_live() { # name, then the command
name="$1"
shift
"$@" > "$LIVE/$name" 2>/dev/null || { [ -s "$LIVE/$name" ] || rm -f "$LIVE/$name"; }
}
run_live proc_modules cat "$R/proc/modules"
run_live tainted cat "$R/proc/sys/kernel/tainted"
run_live modules_disabled cat "$R/proc/sys/kernel/modules_disabled"
run_live uname uname -a
# shellcheck disable=SC2016
run_live boot_time awk '/^btime/ { print $2 }' "$R/proc/stat"
if [ -d "$R/sys/module" ]; then
(cd "$R/sys/module" && ls -1) > "$LIVE/sys_module" 2>/dev/null
# name, initstate (only loadable modules have one), taint letters.
for m in "$R"/sys/module/*; do
[ -d "$m" ] || continue
st=$(cat "$m/initstate" 2>/dev/null)
tn=$(cat "$m/taint" 2>/dev/null)
printf '%s %s %s\n' "${m##*/}" "${st:--}" "${tn:--}"
done > "$LIVE/sys_module_detail"
fi
# dmesg reads the running kernel, so only without ROOT.
[ "$R" = "" ] && run_live dmesg dmesg
# The TPM event log is a sysfs file whose size reads as 0: copy its content.
if [ -r "$R/sys/kernel/security/tpm0/binary_bios_measurements" ]; then
mkdir -p "$STAGE/sys/kernel/security/tpm0"
cat "$R/sys/kernel/security/tpm0/binary_bios_measurements" > "$STAGE/sys/kernel/security/tpm0/binary_bios_measurements" 2>/dev/null
fi
{
say "rootkits-collect-linux.sh $VERSION"
say "host: $HOST"
say "started: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
say "uid: $(id -u)"
say "root: $ROOT"
say "running kernel: $RELEASE"
say "all kernels: $ALL_KERNELS"
[ -n "$PRELOAD_NOTE" ] && say "note: $PRELOAD_NOTE"
} > "$LIVE/collect.txt"
# ---------------------------------------------------------------- archive ---
# Every member goes under "<host>/": GNU tar --transform, bsdtar -s.
nfiles=$(wc -l < "$LIST" | tr -d ' ')
STAGED="_live"
[ -d "$STAGE/sys" ] && STAGED="_live sys"
if tar --version 2>/dev/null | grep -q 'GNU tar'; then
# shellcheck disable=SC2086
tar -czf "$ARCHIVE" --dereference --no-recursion --transform="s,^,$HOST/," -C "$R/" -T "$LIST" --recursion -C "$STAGE" $STAGED
elif tar --version 2>/dev/null | grep -q 'bsdtar'; then
# bsdtar reads directory changes from the list itself: "-C" on a line, the folder on the next.
BLIST="$STAGE/bsdtar-files.txt"
{ printf -- '-C\n%s\n' "$R/"; cat "$LIST"; printf -- '-C\n%s\n' "$STAGE"; for s in $STAGED; do printf '%s\n' "$s"; done; } > "$BLIST"
tar -czf "$ARCHIVE" -h -s ",^,$HOST/," -T "$BLIST"
else
# Other tar (busybox): copy into the temporary folder first.
mkdir -p "$STAGE/$HOST"
while IFS= read -r f; do
mkdir -p "$STAGE/$HOST/$(dirname "$f")" && cp -p "$R/$f" "$STAGE/$HOST/$f" 2>/dev/null
done < "$LIST"
for s in $STAGED; do mv "$STAGE/$s" "$STAGE/$HOST/"; done
tar -czf "$ARCHIVE" -C "$STAGE" "$HOST"
fi
status=$?
if [ $status -ne 0 ] && [ ! -s "$ARCHIVE" ]; then
say "error: tar failed (status $status)" >&2
exit 1
fi
DONE=yes
if command -v sha256sum >/dev/null 2>&1; then
SUM=$(sha256sum "$ARCHIVE" | cut -d' ' -f1)
elif command -v shasum >/dev/null 2>&1; then
SUM=$(shasum -a 256 "$ARCHIVE" | cut -d' ' -f1)
else
SUM=$(openssl dgst -sha256 "$ARCHIVE" 2>/dev/null | sed 's/.*= //')
fi
say "Collected $nfiles files from $ROOT ($nkernels kernel module tree(s)) and the live outputs in _live/."
[ -n "$PRELOAD_NOTE" ] && say "Note: $PRELOAD_NOTE."
say "Archive: $ARCHIVE"
say "SHA-256: $SUM"
say "Open it at https://www.rootkits.dev/ (nothing is uploaded)."
-o is the folder for the archive: a USB drive or a mounted share rather than the suspect disk. -a also takes the modules of every installed kernel, not only the running one.
The script prints the archive's name (rootkits-<host>-<UTC time>.tar.gz) and its SHA-256: note both, then drop the archive here.
On a running system, a loaded LKM rootkit or a preload library can hide files and lie in /proc: the _live outputs are what that kernel chose to show. Collect from a mounted image too when you can.
By hand, tar warns about paths that do not exist on the host (no ld.so.preload, no ESP at /boot/efi) and goes on.
Open a disk image in Disk Image Parser and use “Open in rootkits.dev” to hand over the files inside it (the EFI system partition, hives, drivers, event logs, kernel modules), browser to browser. For the boot sectors themselves, drop the raw image here, or copy the boot regions of an attached disk with dd:
Linux: the first 4 MiB and the last MiB of the disk
diskutil list
sudo dd if=/dev/rdisk0 of=disk0.img bs=1m count=4
Replace /dev/sda (or /dev/rdisk0) with the disk to check; lsblk and diskutil list show them. dd only reads the disk.
The Linux commands make one sparse file the size of the disk, with only its head and its tail filled (the GPT backup sits in the last sectors); ls -ls shows how little it really uses. Drop it as it is: the checker reads only its head and tail. Zipping it would read the whole size.
A disk head alone (the first MiB or more) is enough for MBR, boot code and the first partition's boot record; the tail adds the GPT backup and anything stored at the end of the disk.
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.
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
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.
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.
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.
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.