Skip to content

Security1 publisher2 min readPublished Updated

Open-source DeepZero hands an LLM the signed Windows drivers missing from loldrivers.io

DeepZero automates the hunt for exploitable Windows kernel drivers, discarding everything already on loldrivers.io before a language model rates what survives. Its maintainer reports multiple verified bugs in a driver installer corpus.

The Watch · Security desk

Illustration accompanying Open-source DeepZero hands an LLM the signed Windows drivers missing from loldrivers.io

What happened

  • DeepZero is an open-source engine that takes a folder of Windows binaries, parses and decompiles them, discards most, and ends by asking a language model whether the survivors can be attacked.
  • The bundled pipeline is aimed at BYOVD, the technique where an attacker loads a legitimately signed driver that contains a flaw and uses it to reach the kernel.
  • The third of seven stages excludes drivers already cataloged on loldrivers.io, so the only drivers the model ever rates are ones that got past that filter.
  • Maintainer Rehman Ahmadzai says the tool has found multiple verified vulnerabilities in a subset of the Snappy Driver Installer corpus, with some still in the disclosure process.
  • The decompile stage records whether IoCreateDevice is reached from DriverEntry, separating findings anyone can confirm from those that need the physical device present.

Compiled by The WatchSomething wrong?How this is made

Why it matters

  • capability Screening a whole driver bundle for kernel footholds is now a YAML pipeline, a Ghidra pass and a model bill, available to anyone who clones the repository.
  • constraint A deny list names only the drivers someone already reported, and a pipeline that subtracts that list at the outset produces candidates that reach the list only once a disclosure closes.
  • exposure Vendors whose signed drivers sit inside third-party installer corpora are now screened at corpus scale by researchers they have no relationship with, and they hear about it on a disclosure clock.
  • decision Teams whose kernel-driver control is a block list have to decide what they intend to do about signed drivers that are still waiting on someone's first report.

The loldrivers exclusion at stage three is there for pipeline economics [7]. Headless Ghidra runs and model calls cost time and tokens, and a driver already published as vulnerable has already been researched. It has a second effect. Every driver that reaches the model is one missing from the public blocklist at the time of the run [15]. Defenders who gate kernel drivers by deny list work from the set of drivers someone already reported [8]; this pipeline begins by subtracting that set [9].

Six of the seven stages run before the model is asked anything [14]. They are PE header parsing, a filter that keeps only kernel-mode drivers exposing IOCTL surfaces, the loldrivers exclusion, headless Ghidra, Semgrep rules over the exported C source, and a reduce step called pick_top_10 [7]. "The AI evaluation step is placed at the end so that the earlier stages can gather context (such as binary decompilation, filtering out pre-known vulnerable drivers or unsupported/32-bit binaries from the pipeline) which will be evaluated by the AI step in the end," Ahmadzai told Help Net Security [10].

Some findings take more than a spare VM to check. Many drivers create their device object only once their hardware is enumerated. On a machine without that device the path never opens, and from the report alone that looks identical to a driver with nothing wrong with it [11]. The decompile stage separates the two by recording which function calls IoCreateDevice and whether that function is DriverEntry or something DriverEntry calls [12]. A true value means the device appears on any machine that will load the driver, so the finding can be confirmed; false usually means a plug-and-play callback creates it, and confirming takes the hardware [12]. When IoCreateDevice is not found at all, the stage records neither value [12].

The code is Python 3.11 and up with pipelines written in YAML, and it is free on GitHub [2][3]. So the cost of a pass over a driver bundle is compute plus a model bill. The report does not say how many drivers the Snappy Driver Installer run covered or how many bugs were verified [16]. The engine is public, while the findings stay held back: Ahmadzai says some are still in disclosure [5].

The bundled pipeline is aimed at Windows kernel drivers, but the maintainer describes the layer underneath it as reusable. "DeepZero's underlying engine is already built as a target-agnostic pipeline orchestrator. While the included loldrivers research pipeline is specifically tailored for Windows kernel drivers, the framework itself is not restricted to a single architecture or binary type," Ahmadzai said [13].

What to watch

  • Whether the Snappy Driver Installer findings get CVEs and land on loldrivers.io, and how long the gap runs between disclosure and listing.
  • Whether third parties publish DeepZero pipelines for non-Windows binaries, given the maintainer's description of the engine as target-agnostic.
  • Whether anyone inverts stage three and runs the pipeline over the drivers already installed across their own fleet.
Loading claim ledger
Loading source directory links
Loading share composer
Loading topic controls
Loading related stories