Skip to content

Hunting Vulnerable and Malicious Drivers (BYOVD) Offline

Hunt vulnerable (BYOVD) and malicious Windows drivers offline: service keys, driver files and signers, Amcache, LOLDrivers, the blocklist and CodeIntegrity.

Published on 12 min read

TL;DR. A driver, malicious or merely vulnerable, leaves the same four kinds of evidence on disk: a service key in the SYSTEM hive, a .sys file, an inventory entry in Amcache, and events in the System and CodeIntegrity logs. Collect them, list every kernel driver service with its ImagePath, read the signer of each file, compare the hashes with LOLDrivers and Microsoft's vulnerable driver blocklist, and line up the events. Offline evidence shows what was installed, refused or inventoried. It does not prove a driver ran, and it cannot see a driver that never touched the registry or the disk.

Two problems, one set of traces

Bring your own vulnerable driver (BYOVD). An attacker who is already an administrator installs a signed driver with a known flaw and uses it to get kernel access or to stop security tools. Microsoft's driver block rules page describes the trend: because Microsoft has strict requirements for kernel code, attackers exploit "legitimate and signed kernel drivers" instead. FudModule is a documented case: ESET reported a Dell driver, and AhnLab an ENE driver, abused this way in attacks they attribute to Lazarus.

Malicious signed drivers. Some attackers get their own driver signed. Microsoft confirmed in 2021 that the Netfilter rootkit had been signed through its hardware program, and its advisory ADV220005 in 2022 covered drivers such as POORTRY that were attestation-signed from abused developer accounts.

Windows requires kernel drivers to be signed. Microsoft's driver signing policy says that since Windows 10 version 1607, new kernel drivers must be signed through Microsoft's Hardware Dev Center, with exceptions for upgraded systems, for Secure Boot off, and for cross-signed certificates issued before 29 July 2015. Each of those paths is something to check.

Where the evidence is

SourcePathWhat it gives
Driver servicesSYSTEM hive, ControlSet00x\Services\<name>Type 1 (kernel) or 2 (file system), Start, ImagePath, the key's last-write time
Driver filesWherever ImagePath points; by default System32\drivers\<name>.sysSigner, version information, compile time, hashes
AmcacheC:\Windows\AppCompat\Programs\Amcache.hve, Root\InventoryDriverBinaryOne key per driver, named after its SHA-1, with name, company, version and service
System logSystem.evtx7045 service installed, 7000 service failed to start, 7026 boot or system start driver did not load
Security logSecurity.evtx4697 service installed, when that auditing is on
CodeIntegrity logMicrosoft-Windows-CodeIntegrity%4Operational.evtxRefused or audited images, signature details, policy loads
Blocklist and memory integrity stateControl\CI\Config\VulnerableDriverBlocklistEnable; Control\DeviceGuard\Scenarios\HypervisorEnforcedCodeIntegrity\EnabledWhether the protections were on
Sysmon, if deployedMicrosoft-Windows-Sysmon%4Operational.evtxEvent 6, driver loaded, with hashes and signature

The kernel drivers artifact page on Windows Forensics covers each source in more depth, and Windows Persistence explains how driver services load at boot.

Collect

From an elevated PowerShell prompt on the live host:

$case = 'E:\case\FIN-WKS-07'
$logs = "$case\C\Windows\System32\winevt\Logs"
New-Item -ItemType Directory -Force -Path "$case\C\Windows\System32\config", $logs | Out-Null

reg save HKLM\SYSTEM "$case\C\Windows\System32\config\SYSTEM"
wevtutil epl System "$logs\System.evtx"
wevtutil epl Microsoft-Windows-CodeIntegrity/Operational "$logs\Microsoft-Windows-CodeIntegrity%4Operational.evtx"

# Every kernel and file system driver service, and the file it names
$svc = Get-ChildItem HKLM:\SYSTEM\CurrentControlSet\Services |
  Get-ItemProperty | Where-Object { $_.Type -in 1, 2 }
$svc | Select-Object PSChildName, Type, Start, ImagePath |
  Export-Csv "$case\driver-services.csv" -NoTypeInformation
foreach ($s in $svc) {
  $p = if ($s.ImagePath) { $s.ImagePath } else { "System32\drivers\$($s.PSChildName).sys" }
  $p = $p -replace '^\\\?\?\\', '' -replace '^\\SystemRoot\\', "$env:SystemRoot\" -replace '^System32\\', "$env:SystemRoot\System32\"
  if (Test-Path -LiteralPath $p) {
    $dest = Join-Path "$case\C" $p.Substring(3)
    New-Item -ItemType Directory -Force -Path (Split-Path $dest) | Out-Null
    Copy-Item -LiteralPath $p -Destination $dest
  }
}

reg save writes a consistent copy of the loaded hive and wevtutil epl exports a live log. The loop follows the ImagePath forms Windows uses (\SystemRoot\..., System32\..., \??\C:\...) and keeps the original folder structure under C\, so a driver in ProgramData stays visibly out of place. Amcache is locked on a running system: take it with KAPE (kape.exe --tsource C: --tdest E:\case\FIN-WKS-07 --target Amcache) or from a shadow copy. From a disk image, copy the same paths read-only.

Read the service keys

List every service with Type 1 or 2 from the control set that Select\Current names, and look for:

  • an ImagePath outside System32\drivers and System32\DriverStore\FileRepository, especially \??\C:\ProgramData\..., a user profile or Windows\Temp;
  • Start 3 on a driver no device needs, typical of a tool that loads a driver on demand, or Start 0 to 2 on an unknown one, which is persistence;
  • a name and display name that imitate a hardware vendor or a Windows component;
  • a key last-write time inside the intrusion window.

A driver that was installed, used and then deleted with its key leaves no service. Its 7045 event, its Amcache entry and the file's deletion in the USN journal can remain.

Read the driver files

sigcheck -accepteula -nobanner -s -e -a -h -i -c E:\case\FIN-WKS-07\C > E:\case\FIN-WKS-07\sigcheck.csv

Sigcheck with -i shows the signing chain, -h the hashes (including the Authenticode hashes), -a extended version information and -e limits the scan to executable images. Get-AuthenticodeSignature gives the signer certificate in PowerShell. Questions to ask of each file:

  • Who signed it, and how? No signature, a test certificate, a person's or small company's certificate, a certificate known to be leaked or revoked, or a Microsoft signature from the attestation program. Mandiant's attestation hunting post shows how to tell an attestation-signed driver: the signer "Microsoft Windows Hardware Compatibility Publisher" with the attestation EKU 1.3.6.1.4.1.311.10.3.5.1, and a program name that identifies the submitting company. Legitimate drivers carry the same signer, so it is a pivot, not a verdict.
  • Does the name match? A renamed vulnerable driver keeps its original file name in its version information. LOLDrivers records that OriginalFilename for each sample.
  • Does the date fit? A compile time or signing time outside the certificate's validity deserves a closer look. So does a driver signed only through a cross-signed certificate issued after 29 July 2015 on a Secure Boot machine installed with Windows 10 1607 or later: that falls outside Microsoft's exceptions, so ask how it loaded.

One trap: Microsoft's signing policy accepts an embedded signature or a catalog file. Many Windows files are signed through catalogs in System32\CatRoot, so a copy checked on another machine shows as unsigned. Check those files on the host, on a mounted image, or with the catalogs collected.

Compare with LOLDrivers and Microsoft's blocklist

LOLDrivers is an open catalogue of vulnerable and malicious Windows drivers, with file and Authenticode hashes for each known sample, published as drivers.json and drivers.csv. Its README advises using exact file or Authenticode hashes for blocking and treating file names as hunting leads. On the analysis machine:

$lol = Invoke-RestMethod https://www.loldrivers.io/api/drivers.json
$known = @{}
foreach ($d in $lol) { foreach ($s in $d.KnownVulnerableSamples) {
  foreach ($h in @($s.SHA256, $s.Authentihash.SHA256)) {
    if ($h) { $known[$h.ToLower()] = "$($d.Category): $($s.Filename)" } } } }
Get-ChildItem E:\case\FIN-WKS-07\C -Recurse -Filter *.sys | ForEach-Object {
  $h = (Get-FileHash -LiteralPath $_.FullName -Algorithm SHA256).Hash.ToLower()
  if ($known[$h]) { '{0}  {1}' -f $_.FullName, $known[$h] } }

This matches file hashes. Use sigcheck's Authenticode hashes to match samples that differ only in their signature.

Microsoft's vulnerable driver blocklist covers drivers with known vulnerabilities, malicious drivers and certificates used to sign malware. Since the Windows 11 2022 update it is on by default, and it is enforced when memory integrity (HVCI), Smart App Control or S mode is active. Microsoft updates it quarterly and through monthly updates, warns that it "isn't guaranteed to block every driver", and notes that the downloadable version is usually more complete than the one in Windows. Two consequences:

  • A hit on the downloadable list is a strong lead, even if the host's own list would have allowed the driver.
  • Check whether the protection was on. A VulnerableDriverBlocklistEnable value of 0 under HKLM\SYSTEM\CurrentControlSet\Control\CI\Config turns it off; SigmaHQ has a detection rule for that change. Read the memory integrity value next to it.

Amcache

Root\InventoryDriverBinary in Amcache.hve holds one key per driver, named after its SHA-1 preceded by 0000, with the driver name, version, company, product and service name, according to Velociraptor's Amcache artifact. It can keep the hash of a driver whose file is gone. Sources disagree on what an entry proves: Kaspersky's 2025 Amcache study says the key records drivers the system has loaded, while Velociraptor's artifact treats Amcache entries as evidence to corroborate. Treat an entry as proof the driver was on the system, and look elsewhere for proof that it ran. Parse it with AmcacheParser.exe -f Amcache.hve --csv E:\case\out, and see the Amcache artifact page.

Events

LogEventWhat it says
System7045A service was installed; the message gives the type ("kernel mode driver"), the file and the start type
System7000A service failed to start; the message gives the reason, for example a signature Windows could not verify
System7026A boot or system start driver did not load
CodeIntegrity3001An unsigned driver was attempted to load
CodeIntegrity3004A file could not be verified; Microsoft says it typically means a kernel driver with an invalid signature
CodeIntegrity3023A driver did not meet the requirements of the App Control policy
CodeIntegrity3033, 3077A file did not meet the policy (3033 often for a revoked signature); 3077 is the main enforced block event
CodeIntegrity3089Signature details of the blocked file, linked to the block by its Correlation ActivityID
CodeIntegrity3099A policy was loaded, which shows which policies, the blocklist included, were active

The CodeIntegrity descriptions come from Microsoft's App Control event IDs page; exact IDs vary with the build and the policy, so read each message. Offline:

$logs = 'E:\case\FIN-WKS-07\C\Windows\System32\winevt\Logs'
Get-WinEvent -FilterHashtable @{ Path = "$logs\System.evtx"; Id = 7045, 7000, 7026 } |
  Select-Object TimeCreated, Id, Message
Get-WinEvent -Path "$logs\Microsoft-Windows-CodeIntegrity%4Operational.evtx" |
  Where-Object Id -in 3001, 3004, 3023, 3033, 3077, 3089 | Select-Object TimeCreated, Id, Message

The CodeIntegrity log is small and rolls over quickly, so a refusal can be gone within days.

A worked example

The fictional FIN-WKS-07 in the site's sample shows the pattern, on 2026-09-14 (UTC):

TimeTraceSource
10:07:29C:\ProgramData\Intel\iqvw64x.sys written: an unsigned driver whose name is one character away from iqvw64e.sys, Intel's network adapter diagnostic driver, which LOLDrivers lists as vulnerable (CVE-2015-2291)The file's time
10:07:31Kernel driver service IntelNetDiag created: Type 1, Start 3 (demand), ImagePath \??\C:\ProgramData\Intel\iqvw64x.sysThe service key's last write time
10:07:31System 7045, "kernel mode driver", logged with the user SID S-1-5-21-3623811015-3361044348-30300820-1119 (svc_backup)System log
10:07:33CodeIntegrity 3004 for \Device\HarddiskVolume3\ProgramData\Intel\iqvw64x.sys: Windows could not verify the image hashCodeIntegrity log
10:07:33System 7000 for IntelNetDiag with %%577: Windows cannot verify the digital signatureSystem log

Three seconds later, at 10:07:36, tamper protection refuses an attempt to turn off Defender's real-time protection (Defender event 5013), and at 10:08:12 the attacker falls back to a Defender exclusion for C:\ProgramData\Intel. Every trace sits in the service key, the file, the System log and the CodeIntegrity log, and the failure is as informative as a success would have been. The sample walk-through reads the same host with the checker.

What offline checks cannot prove

  • That a driver ran. A key, a file, a 7045 event or an Amcache entry shows installation or presence. Loading needs memory, Sysmon event 6 or the driver's visible effects.
  • Drivers that never touch disk or registry. A signed driver can be abused to map other code straight into kernel memory, as Kaspersky reported for Demodex with Cheat Engine's driver, and FudModule's later versions worked from user mode through kernel zero-days.
  • Completeness of the lists. Absence from LOLDrivers or Microsoft's blocklist does not make a driver benign.
  • Signature state at the time. Revocations, catalogs and trust stores on the analysis machine differ from the host's.
  • A clean listing on a live host. A kernel rootkit can hide its own key and file. Prefer a hive and files taken from an image.

Checking with rootkits.dev

The checker reads a collection in your browser. Its windrivers module reads the driver services in the SYSTEM hive (type, start, ImagePath, key times), every .sys file under C/ (PE header, Authenticode signer, digest, hashes, compile time, imports), Amcache's InventoryDriverBinary, System events 7045, 7000 and 7026, and CodeIntegrity events 3001, 3002, 3004, 3023, 3032, 3033, 3036, 3063, 3076, 3077 and 3112. It flags:

  • driver services whose image sits in a writable folder such as ProgramData, a user profile or Windows\Temp, or outside the driver folders;
  • drivers with no embedded signature, a digest that no longer matches, a broken signature, a self-signed chain or a certificate imitating a Microsoft CA;
  • files whose hashes match the LOLDrivers snapshot it carries, and names one character away from a LOLDrivers or Windows driver name;
  • driver service keys written shortly before the newest activity on the host;
  • the install, failed-start and Code Integrity events above, and memory integrity turned off in the hive.

It checks embedded signatures only, without a trust store or revocation list, and does not read the blocklist setting. On FIN-WKS-07 it raises "A driver service loads its image from C:\ProgramData", "iqvw64x.sys looks like the name of another driver (iqvw64e.sys)", "An unsigned kernel driver", the 7045 and 7000 findings and "Code Integrity refused a file whose signature could not be verified". The file's hash is not in LOLDrivers: it is synthetic. Keep the C/... layout from the collection script so it can tie a service to its file.

FAQ

What is BYOVD?

Bring your own vulnerable driver: an attacker with administrator rights installs a legitimately signed driver that has a known flaw, then uses that flaw to run code in the kernel or to stop security products. Windows loads the driver because its signature is valid, unless the vulnerable driver blocklist or another App Control policy refuses it.

Does event 7045 prove that a driver was loaded?

No. Event 7045 in the System log records that a service, here a kernel driver service, was installed. A 7000 event can follow when it fails to start, and CodeIntegrity events record refused images. Proof of a load comes from memory, from Sysmon event 6 when Sysmon was running, or from what the driver did next.

Is a Microsoft signature proof that a driver is safe?

No. Vulnerable drivers carry valid vendor or Microsoft signatures, and malicious drivers such as Netfilter and POORTRY were signed through Microsoft's own hardware program before the signatures were revoked. Read who signed the file and how, then compare its hashes with LOLDrivers and Microsoft's blocklist.

Why does sigcheck call a Windows driver unsigned on my analysis machine?

Many Windows files are signed through catalog files rather than an embedded signature. Microsoft's driver signing policy accepts either. A copied driver whose signature lives in a catalog on the source host looks unsigned elsewhere. Collect the host's catalog folder or check those files on the host or a mounted image.

Frequently asked questions

What is BYOVD?

Bring your own vulnerable driver: an attacker with administrator rights installs a legitimately signed driver that has a known flaw, then uses that flaw to run code in the kernel or to stop security products. Windows loads the driver because its signature is valid, unless the vulnerable driver blocklist or another App Control policy refuses it.

Does event 7045 prove that a driver was loaded?

No. Event 7045 in the System log records that a service, here a kernel driver service, was installed. A 7000 event can follow when it fails to start, and CodeIntegrity events record refused images. Proof of a load comes from memory, from Sysmon event 6 when Sysmon was running, or from what the driver did next.

Is a Microsoft signature proof that a driver is safe?

No. Vulnerable drivers carry valid vendor or Microsoft signatures, and malicious drivers such as Netfilter and POORTRY were signed through Microsoft's own hardware program before the signatures were revoked. Read who signed the file and how, then compare its hashes with LOLDrivers and Microsoft's blocklist.

Why does sigcheck call a Windows driver unsigned on my analysis machine?

Many Windows files are signed through catalog files rather than an embedded signature. Microsoft's driver signing policy accepts either. A copied driver whose signature lives in a catalog on the source host looks unsigned elsewhere. Collect the host's catalog folder or check those files on the host or a mounted image.

Related articles

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.
How Linux userland rootkits use /etc/ld.so.preload and LD_PRELOAD, why ls, cat and ldd on the host can lie, and how to check a system offline and live.