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
bootkits.dev · local analysisRead 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.
or
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.
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.
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, 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.
The collect script copies the EFI system partition, the TPM event log and the boot regions of the disks that hold the ESP and / (each disk's first 4 MiB and last MiB) into one .tar.gz named after the host. It only reads the system and the disks, writes nothing but that archive in the folder you name, and uses no network. Read it before you run it.
#!/bin/sh
# bootkits-collect-linux.sh: collect what bootkits.dev's offline checker
# reads on a Linux host: the EFI system partition, the TPM event log
# (binary_bios_measurements), and the boot regions of the disks that hold the
# EFI system partition and the root file system: each disk's first 4 MiB as
# diskN.img and its last MiB as diskN.tail-<byte offset>.img.
#
# Read-only: it changes nothing on the host and never writes to a disk. dd
# only reads the disks; everything is written into the script's own staging
# folder inside the output directory, archived as one .tar.gz, and the
# staging folder is removed when the script exits. No network access.
#
# Usage: sudo sh bootkits-collect-linux.sh -o /media/usb
# -o DIR where to write the archive (required)
# -h this help
# Testing: ROOT=/path/to/fake/root sh bootkits-collect-linux.sh -o DIR
# reads every file, every /proc and /sys value and the disks under ROOT
# (a disk is then ROOT/dev/<name>, a regular file) instead of /.
#
# Caveat: this runs on the suspect system. A running bootkit can filter disk
# reads and hide files, so the sectors and files read here are what it lets
# through. Prefer images of the disks taken offline (powered off, or booted
# from trusted media), 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=""
ROOT="${ROOT:-/}"
# 512-byte sectors read from each disk: its first 4 MiB and its last MiB.
HEAD_SECTORS=8192
TAIL_SECTORS=2048
MAX_DISKS=8
MAX_ESP_FILES=20000
# Larger files on the EFI system partition are counted, not copied.
MAX_ESP_FILE=268435456
usage() {
# The header comment, up to the licence.
sed -n '2,/^# MIT License/p' "$0" | sed '$d' | sed 's/^# \{0,1\}//'
}
while getopts "o:h" opt; do
case "$opt" in
o) OUT="$OPTARG" ;;
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: the disks and the TPM event log will 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)
NAME="bootkits-$HOST-$STAMP.tar.gz"
ARCHIVE="$OUT/$NAME"
if [ -e "$ARCHIVE" ]; then
say "error: $ARCHIVE already exists" >&2
exit 2
fi
# Everything the script writes goes into this private folder (mode 700, a
# name no one can guess), the archive included; only the finished archive is
# then renamed into the output folder. Interrupted, it leaves nothing.
STAGE=$(mktemp -d "$OUT/.bootkits-collect.XXXXXX") || { say "error: cannot create a temporary folder in $OUT" >&2; exit 1; }
cleanup() {
rm -rf "${STAGE:?}"
}
trap cleanup EXIT
trap 'exit 130' INT TERM HUP
H="$STAGE/$HOST"
mkdir "$H"
# The script's own files start with a dot: no host folder does.
NOTES="$STAGE/.notes"
DISKLOG="$STAGE/.disks"
: > "$NOTES"
: > "$DISKLOG"
note() {
printf '%s\n' "$*" >> "$NOTES"
warn "$*"
}
NL='
'
# ------------------------------------------------- EFI system partition ---
# The first of /boot/efi, /efi and /boot that holds an EFI folder, copied as
# ESP/. No part of its path may be a symbolic link, and only regular files on
# its own file system are listed: a planted link never brings another tree
# into the archive. Names holding a line break are left out (the list is read
# one name per line).
ESP_MP=""
for mp in boot/efi efi boot; do
[ -d "$R/$mp/EFI" ] || continue
if [ -L "$R/$mp" ] || [ -L "$R/$mp/EFI" ] || { [ "$mp" = boot/efi ] && [ -L "$R/boot" ]; }; then
note "/$mp goes through a symbolic link: not collected"
continue
fi
ESP_MP=$mp
break
done
nesp=0
nbig=0
if [ -n "$ESP_MP" ]; then
(cd "$R/" && find "$ESP_MP" -xdev -type f -size -$((MAX_ESP_FILE + 1))c ! -path "*$NL*" -print 2>/dev/null) | head -n "$MAX_ESP_FILES" > "$STAGE/.esp"
nbig=$( (cd "$R/" && find "$ESP_MP" -xdev -type f -size +${MAX_ESP_FILE}c -print 2>/dev/null) | wc -l | tr -d ' ')
mkdir "$H/ESP"
while IFS= read -r f; do
rel=${f#"$ESP_MP"/}
case "$rel" in
*/*) dir=${rel%/*} ;;
*) dir=. ;;
esac
[ -f "$R/$f" ] && [ ! -L "$R/$f" ] || continue
mkdir -p "$H/ESP/$dir" && cp -p "$R/$f" "$H/ESP/$rel" 2>/dev/null && nesp=$((nesp + 1))
done < "$STAGE/.esp"
[ "$nbig" = 0 ] || note "$nbig file(s) larger than $((MAX_ESP_FILE >> 20)) MiB on /$ESP_MP were not copied"
else
note "no EFI system partition at /boot/efi, /efi or /boot (is it mounted?)"
fi
# ------------------------------------------------------- TPM event log ---
# A sysfs file whose size reads as 0: copy its content.
TPM="sys/kernel/security/tpm0/binary_bios_measurements"
TPM_STATE="not readable: no TPM, securityfs not mounted, or not root"
if [ -r "$R/$TPM" ]; then
mkdir -p "$H/sys/kernel/security/tpm0"
if cat "$R/$TPM" > "$H/$TPM" 2>/dev/null && [ -s "$H/$TPM" ]; then
TPM_STATE="copied"
else
rm -f "${H:?}/$TPM"
TPM_STATE="empty or unreadable"
fi
fi
# --------------------------------------------------------------- disks ---
# The whole disks under the block devices that hold / and the EFI system
# partition, found from /proc/self/mountinfo and /sys: through partitions,
# and through device-mapper and RAID devices (LVM, LUKS, md) by their slaves.
valid_name() {
case "$1" in
"" | .* | *[!A-Za-z0-9._-]*) return 1 ;;
esac
return 0
}
# "major:minor source" of the mount at $1 (the last one stacked there).
mount_of() {
awk -v mp="$1" '{ for (i = 7; i <= NF && $i != "-"; i++) ; if ($5 == mp && i + 2 <= NF) found = $3 " " $(i + 2) } END { if (found != "") print found }' "$R/proc/self/mountinfo" 2>/dev/null
}
# The block device name of a mount: by its major:minor in /sys/dev/block, or
# by its /dev source (btrfs and others report an anonymous major:minor).
device_of() { # major:minor, source
case "$1" in
*[!0-9:]* | "") ;;
*)
if [ -e "$R/sys/dev/block/$1" ]; then
p=$(cd -P "$R/sys/dev/block/$1" 2>/dev/null && pwd -P) && { printf '%s\n' "${p##*/}"; return 0; }
fi
;;
esac
case "${2:-}" in
/dev/mapper/*)
# Called in a command substitution while globbing is off: on here only.
set +f
for m in "$R"/sys/class/block/dm-*; do
[ "$(cat "$m/dm/name" 2>/dev/null)" = "${2#/dev/mapper/}" ] && { printf '%s\n' "${m##*/}"; return 0; }
done
;;
/dev/*) printf '%s\n' "${2##*/}" ;;
esac
return 0
}
# The whole disks under a block device, at most 8 levels down, at most 256
# devices looked at. Level by level, each device once: LVM volumes share
# their physical volumes, so a walk per path would grow exponentially.
# Called in a command substitution while globbing is off.
disks_of() { # name
level=$1
seen=" "
looked=0
depth=0
while [ -n "$level" ] && [ "$depth" -le 8 ]; do
next=""
for x in $level; do
valid_name "$x" || continue
case "$seen" in *" $x "*) continue ;; esac
seen="$seen$x "
looked=$((looked + 1))
[ "$looked" -le 256 ] || return 0
d="$R/sys/class/block/$x"
[ -d "$d" ] || continue
if [ -f "$d/partition" ]; then
p=$(cd -P "$d/.." 2>/dev/null && pwd -P) && next="$next ${p##*/}"
continue
fi
s=$(ls -1 "$d/slaves" 2>/dev/null)
if [ -n "$s" ]; then
next="$next $s"
continue
fi
case "$x" in
loop* | ram* | zram* | nbd* | sr*) ;;
*) printf '%s\n' "$x" ;;
esac
done
level=$next
depth=$((depth + 1))
done
}
DISKS=""
set -f
for target in / ${ESP_MP:+"/$ESP_MP"}; do
info=$(mount_of "$target")
if [ -z "$info" ]; then
note "$target is not a mount point in /proc/self/mountinfo: its disk was not looked for"
continue
fi
# shellcheck disable=SC2086
name=$(device_of $info)
found=no
for disk in $(disks_of "$name"); do
found=yes
case " $DISKS " in
*" $disk "*) ;;
*) DISKS="${DISKS:+$DISKS }$disk" ;;
esac
done
# The mount's source as the kernel shows it: only space, tab, line feed and backslash are escaped.
[ "$found" = yes ] || note "the disk holding $target could not be found (mounted from $(printf '%s' "${info#* }" | tr -c 'A-Za-z0-9/._:+=,@-' '_' | cut -c1-128))"
done
n=0
for disk in $DISKS; do
if [ "$n" -ge "$MAX_DISKS" ]; then
note "more than $MAX_DISKS disks: $disk and the next ones were not read"
break
fi
size=$(cat "$R/sys/class/block/$disk/size" 2>/dev/null)
case "$size" in
"" | *[!0-9]* | 0) note "the size of $disk is unknown: not read"; continue ;;
esac
if [ ${#size} -gt 15 ]; then
note "the size of $disk is not plausible: not read"
continue
fi
if [ "$R" = "" ]; then
dev="/dev/$disk"
[ -b "$dev" ] || { note "$dev is not a block device: not read"; continue; }
else
dev="$R/dev/$disk"
[ -f "$dev" ] || [ -b "$dev" ] || { note "$dev is missing: not read"; continue; }
fi
# dd only reads the disk (if=); what it writes (of=) is in the staging folder.
if [ "$size" -le $((HEAD_SECTORS + TAIL_SECTORS)) ]; then
dd if="$dev" of="$H/disk$n.img" bs=512 count="$size" 2>/dev/null || { rm -f "${H:?}/disk$n.img"; note "reading $dev failed"; continue; }
ends="the whole disk"
else
dd if="$dev" of="$H/disk$n.img" bs=512 count="$HEAD_SECTORS" 2>/dev/null || { rm -f "${H:?}/disk$n.img"; note "reading $dev failed"; continue; }
at=$((size - TAIL_SECTORS))
if dd if="$dev" of="$H/disk$n.tail-$((at * 512)).img" bs=512 skip="$at" count="$TAIL_SECTORS" 2>/dev/null; then
ends="its first 4 MiB, and its last MiB from byte $((at * 512))"
else
rm -f "${H:?}/disk$n.tail-$((at * 512)).img"
note "the end of $dev could not be read: only its first 4 MiB were kept"
ends="its first 4 MiB"
fi
fi
model=$(head -n 1 "$R/sys/class/block/$disk/device/model" 2>/dev/null | tr -cd 'A-Za-z0-9 ._-' | cut -c1-64)
say "disk$n: $dev, $size sectors of 512 bytes${model:+, $model}: $ends" >> "$DISKLOG"
n=$((n + 1))
done
set +f
[ "$n" -gt 0 ] || note "no disk was read: the boot regions are not in this collection"
{
say "bootkits-collect-linux.sh $VERSION"
say "host: $HOST"
say "started: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
say "uid: $(id -u)"
say "root: $ROOT"
if [ -n "$ESP_MP" ]; then say "EFI system partition: /$ESP_MP, $nesp files, as ESP/"; else say "EFI system partition: not found"; fi
say "TPM event log: $TPM_STATE"
cat "$DISKLOG"
sed 's/^/note: /' "$NOTES"
} > "$H/collect.txt"
# ---------------------------------------------------------------- archive ---
# Written in the staging folder, hashed there, then renamed into the output
# folder: a rename replaces whatever another account may have planted at that
# predictable name (a link to a file or to a disk) instead of writing through it.
if ! tar -czf "$STAGE/$NAME" -C "$STAGE" "$HOST"; then
say "error: tar failed" >&2
exit 1
fi
if command -v sha256sum >/dev/null 2>&1; then
SUM=$(sha256sum "$STAGE/$NAME" | cut -d' ' -f1)
elif command -v shasum >/dev/null 2>&1; then
SUM=$(shasum -a 256 "$STAGE/$NAME" | cut -d' ' -f1)
else
SUM=$(openssl dgst -sha256 "$STAGE/$NAME" 2>/dev/null | sed 's/.*= //')
fi
if ! mv -f "$STAGE/$NAME" "$OUT/"; then
say "error: cannot move the archive into $OUT" >&2
exit 1
fi
if [ -n "$ESP_MP" ]; then say "EFI system partition: /$ESP_MP, $nesp files"; else say "EFI system partition: not found"; fi
say "TPM event log: $TPM_STATE"
say "Disks read: $n"
say "Archive: $ARCHIVE"
say "SHA-256: $SUM"
say "Open it at https://www.bootkits.dev/ (nothing is uploaded)."
-o is the folder for the archive: a USB drive or a mounted share rather than the suspect disk. In the commands by hand, /media/usb plays that part.
The script prints the archive's name (bootkits-<host>-<UTC time>.tar.gz) and its SHA-256: note both, then drop the archive here. collect.txt in the archive lists the disks it read and anything it left out.
It finds the disks through partitions, LVM, LUKS and software RAID. When it cannot (ZFS, a network root), it says so in collect.txt: copy that disk's boot regions by hand, with lsblk to find it.
dd only reads the disk (if=); what it writes (of=) is a file in the case folder. Keep the byte offset in the name of the disk's last MiB: the checker places the end of the disk by it.
If the EFI system partition is mounted at /efi or /boot rather than /boot/efi, the script finds it there; by hand, copy that folder instead (findmnt -t vfat shows it).
Open a disk image in Disk Image Parser and use “Open in bootkits.dev” to hand over its EFI system partition or a Windows volume's Measured Boot logs, browser to browser. For the boot sectors, drop the raw image here: the checker reads its first 4 MiB and last MiB only. Or copy the boot regions of an attached disk:
macOS: the first 4 MiB and the last MiB of an attached disk
Replace disk4 with the disk to check; diskutil list shows them. dd only reads the disk; attach it through a write blocker, since macOS mounts the volumes it recognises.
disk0.img holds the first 4 MiB: the MBR, the GPT, the sectors before the first partition and the first partitions' boot records. disk0.tail-<offset>.img holds the last MiB from that byte offset, with the GPT backup: drop both together.
On a disk with 4096-byte sectors, macOS reads only whole sectors: use bs=4096 and divide count and skip by 8.
A disk head alone is enough for the MBR, the boot code and the first partition's boot record; the end adds the GPT backup and anything stored after the last partition.
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.
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.
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.
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.
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.
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
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.
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.
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.
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.