---
license: cc-by-4.0
language:
  - en
tags:
  - security
  - binary-analysis
  - windows
  - drivers
  - ioctl
  - reverse-engineering
  - attack-surface
pretty_name: The IOCTL Census (Structural Tier)
size_categories:
  - 10M<n<100M
configs:
  - config_name: binaries
    data_files: data/binaries.parquet
  - config_name: ioctl_codes
    data_files: data/ioctl_codes.parquet
  - config_name: dispatchers
    data_files: data/dispatchers.parquet
  - config_name: handlers
    data_files: data/handlers.parquet
  - config_name: functions
    data_files: data/functions.parquet
  - config_name: call_edges
    data_files: data/call_edges.parquet
  - config_name: imports
    data_files: data/imports.parquet
  - config_name: exports
    data_files: data/exports.parquet
  - config_name: cross_build
    data_files: data/v_cross_build.parquet
  - config_name: driver_features
    data_files: data/v_driver_features.parquet
---

# The IOCTL Census (Structural Tier)

A corpus-scale, multi-architecture map of the Windows driver I/O-control
(IOCTL) dispatch surface, recovered deterministically across x86 and x64 from
27,087 signed drivers. This is the **structural tier** of the census described
in the companion paper: the recovered surface itself, everything derivable from
the already-public driver binary. It is a substrate for binary-analysis,
attack-surface, and vulnerability-research work, not a list of vulnerabilities.

## What this is

For each driver the deterministic pass recovers, with no symbolic execution and
no kernel or device, the control-code dispatch surface and program structure:
the `IRP_MJ_DEVICE_CONTROL` dispatch routine, every decoded control code split
into device type, transfer method, required access, and function number, the
handler functions and their reachability from the dispatcher, the
inter-procedural call graph, imports/exports, and PE/signing provenance. One
architecture-neutral recovery covers both x86 and x64, including the 32-bit half
that x64-only symbolic scanners abort on.

| | |
|---|---|
| Signed drivers | 27,087 |
| Drivers with a recovered surface | 21,708 (80%) |
| Decoded control codes | 3,089,633 |
| Dispatch routines | 927,542 |
| Handler functions | 848,094 |
| Functions (x64 deep lane) | 8,184,655 |
| Call edges (x64 deep lane) | 15,950,899 |
| Cross-driver code cohorts | 23,602 |

Corpus: Microsoft Update Catalog (`ms-update-catalog`) plus the inbox driver
sets of three live Windows builds (`live-*`). All drivers are Authenticode-signed
binaries that are themselves publicly retrievable.

## Tables

All files are zstd-compressed Parquet under `data/`, keyed by
`(sha256, function_va)` where applicable.

- `binaries` -- one row per driver: hashes, name, corpus/build, architecture,
  driver type, device names and embedded security descriptor, the
  permissive-descriptor flag, decoded-surface counts, PE version/signing
  provenance.
- `ioctl_codes` -- every decoded control code: `device_type`, `method`,
  `access`, `function_code`, linked to its handler.
- `dispatchers` -- recovered dispatch routines with the recovery backend.
- `handlers` -- handler functions, reachability, and IOCTL distance.
- `functions` / `call_edges` -- the per-function layer and inter-procedural call
  graph (x64 deep lane).
- `imports` / `exports` -- the import/export feature vectors.
- `v_cross_build` -- the cross-driver view: a shared decoded
  `(device_type, function_code)` grouped across builds, architectures, vendors.
- `v_driver_features` -- a one-row-per-driver feature summary.

See `MANIFEST.json` for exact row counts and column lists.

## What is deliberately withheld

This release is **structural only**. To avoid publishing a targeting map of
candidate unprivileged-reachable kernel primitives on shipping drivers, the
following are **not** included: the buffered-input taint sinks, the
language-model risk verdicts, the structural bug-class lead set, the
symbolic-execution (ioctlance) results, and the authors' own findings linkage.
The structural tier localizes no exploitable primitive: it records that a device
is reachable and which control codes it decodes, both derivable from the public
binary, but not where an unchecked write lives.

## Intended use and limits

For defensive and authorized vulnerability-research, binary-analysis, and
measurement work. The `user_reachable` flag is a static read of an embedded
device descriptor and is a prefilter, not a runtime fact. The x86 lane is
surface-only (dispatch and codes, validated against independent disassembly; no
per-function layer). NDIS miniport drivers contribute OID request codes, which
are control codes the dispatcher compares against but arrive via the NDIS path,
not `DeviceIoControl`; filter on driver model if you want IOCTL specifically.

## Provenance and reproducibility

The deterministic recovery runs on the open-source binary-analysis engine
[`glaurung`](https://github.com/mjbommar/glaurung), which supplies the lifting,
disassembly, and architecture-neutral intermediate representation. The method is
described in the companion paper, *The IOCTL Census: A Corpus-Scale,
Multi-Architecture Database of the Windows Driver Control-Code Surface*.

## Citation

```bibtex
@misc{ioctlcensus2026,
  title  = {The IOCTL Census: A Corpus-Scale, Multi-Architecture Database of the
            Windows Driver Control-Code Surface},
  author = {Bommarito II, Michael J.},
  year   = {2026},
  note   = {Structural-tier dataset.}
}
```