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.
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
| Source | Path | What it gives |
|---|---|---|
| Driver services | SYSTEM hive, ControlSet00x\Services\<name> | Type 1 (kernel) or 2 (file system), Start, ImagePath, the key's last-write time |
| Driver files | Wherever ImagePath points; by default System32\drivers\<name>.sys | Signer, version information, compile time, hashes |
| Amcache | C:\Windows\AppCompat\Programs\Amcache.hve, Root\InventoryDriverBinary | One key per driver, named after its SHA-1, with name, company, version and service |
| System log | System.evtx | 7045 service installed, 7000 service failed to start, 7026 boot or system start driver did not load |
| Security log | Security.evtx | 4697 service installed, when that auditing is on |
| CodeIntegrity log | Microsoft-Windows-CodeIntegrity%4Operational.evtx | Refused or audited images, signature details, policy loads |
| Blocklist and memory integrity state | Control\CI\Config\VulnerableDriverBlocklistEnable; Control\DeviceGuard\Scenarios\HypervisorEnforcedCodeIntegrity\Enabled | Whether the protections were on |
| Sysmon, if deployed | Microsoft-Windows-Sysmon%4Operational.evtx | Event 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
ImagePathoutsideSystem32\driversandSystem32\DriverStore\FileRepository, especially\??\C:\ProgramData\..., a user profile orWindows\Temp; Start3 on a driver no device needs, typical of a tool that loads a driver on demand, orStart0 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
OriginalFilenamefor 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
VulnerableDriverBlocklistEnablevalue of 0 underHKLM\SYSTEM\CurrentControlSet\Control\CI\Configturns 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
| Log | Event | What it says |
|---|---|---|
| System | 7045 | A service was installed; the message gives the type ("kernel mode driver"), the file and the start type |
| System | 7000 | A service failed to start; the message gives the reason, for example a signature Windows could not verify |
| System | 7026 | A boot or system start driver did not load |
| CodeIntegrity | 3001 | An unsigned driver was attempted to load |
| CodeIntegrity | 3004 | A file could not be verified; Microsoft says it typically means a kernel driver with an invalid signature |
| CodeIntegrity | 3023 | A driver did not meet the requirements of the App Control policy |
| CodeIntegrity | 3033, 3077 | A file did not meet the policy (3033 often for a revoked signature); 3077 is the main enforced block event |
| CodeIntegrity | 3089 | Signature details of the blocked file, linked to the block by its Correlation ActivityID |
| CodeIntegrity | 3099 | A 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):
| Time | Trace | Source |
|---|---|---|
| 10:07:29 | C:\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:31 | Kernel driver service IntelNetDiag created: Type 1, Start 3 (demand), ImagePath \??\C:\ProgramData\Intel\iqvw64x.sys | The service key's last write time |
| 10:07:31 | System 7045, "kernel mode driver", logged with the user SID S-1-5-21-3623811015-3361044348-30300820-1119 (svc_backup) | System log |
| 10:07:33 | CodeIntegrity 3004 for \Device\HarddiskVolume3\ProgramData\Intel\iqvw64x.sys: Windows could not verify the image hash | CodeIntegrity log |
| 10:07:33 | System 7000 for IntelNetDiag with %%577: Windows cannot verify the digital signature | System 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 orWindows\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.
Related articles
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.