Windows Exploit Research — Overview

Last updated: 2026-04-10
Related: Architecture, Mitigations, Mitigations, Researchers
Tags: kernel-mode, user-mode

Summary

Windows is the most complex and most heavily defended exploitation target in the world. The attack surface spans user-mode applications and services, the Win32 subsystem (win32k.sys), the NT kernel, device drivers, the hypervisor (Hyper-V), and firmware. Becoming the top Windows security researcher requires deep knowledge of every layer — not just how to exploit bugs, but how the entire OS is architected, why mitigations exist, how they fail, and how to discover novel bug classes.


Attack Surface Map

User-Mode Targets

LayerComponentsPrimary Bug Classes
Win32 applicationsbrowsers, document readers, mediaheap overflow, UAF, type confusion
Windows servicesLSASS, spoolsv, RPC servicesmemory corruption, logic bugs
COM serversOLE, DCOM, WMI, Shell extensionstype confusion, UAF, interface confusion
Scripting enginesJScript, Chakra, VBScripttype confusion, OOB, UAF
Network parsersSMB, RDP, DNS, HTTP.sysOOB, integer overflow, UAF

Kernel-Mode Targets

LayerComponentsPrimary Bug Classes
Win32k subsystemwin32k.sys, win32kfull.sys, win32kbase.sysUAF, type confusion, null-deref
NT kernelntoskrnl.exepool overflow, race conditions, integer overflow
I/O subsystemIOCTL handlers in driversOOB, uninitialized memory, integer overflow
Filesystem driversNTFS, SMB (srv2.sys)OOB read/write, race conditions
CLFS (clfs.sys)Common Log File SystemOOB write, UAF, integer overflow — reachable from low-priv user, dominant LPE surface 2021–present
Network stacktcpip.sys, http.sysOOB, integer overflow
Graphics subsystemdxgkrnl.sys, DirectXUAF, type confusion

Hypervisor / Virtualization

  • Hyper-V: vmswitch.sys, vmbus, VPCI emulation — type confusion, OOB
  • VBS (Virtualization-Based Security): UEFI firmware, secure kernel
  • WSL2 / HyperV VMs: cross-VM boundary escapes

Mitigation Timeline (Windows)

Understanding the arms race is essential for knowing what techniques are viable on which OS versions.

ReleaseCodenameKey Mitigation Additions
Win 7 ASLR, DEP/NX, SEHOP, heap cookies
Win 8 Kernel ASLR (KASLR), Safe Unlinking, SMEP (hardware)
Win 8.1 Low Fragmentation Heap hardening
Win 10 1507TH1Isolated Heap, MemGC, CFG (Control Flow Guard)
Win 10 1511TH2CFG extended to more binaries
Win 10 1607RS1ACG (Arbitrary Code Guard), Code Integrity Guard
Win 10 1703RS2KVA Shadow prep, Segment Heap in kernel (pool)
Win 10 1803RS4Retpoline (Spectre), Win32k syscall filter extended
Win 10 1809RS5Segment Heap enabled in more contexts
Win 10 190319H1Kernel CET shadow stack (opt-in for some)
Win 10 200420H1Hardware-enforced Stack Protection (CET) preview
Win 10 20H2 CET-SS available for user-mode
Win 11 21H2 CET-SS mandatory on supported hardware, HVCI default
Win 11 22H2 Smart App Control, expanded KCFG
Win 11 23H2 Extended HVCI coverage, expanded kernel CET
Win 11 24H2 VBS-by-default on capable hardware

Privilege Escalation Paths

Guest/Low IL ──► Medium IL (user) ──► High IL (admin) ──► SYSTEM ──► Kernel ──► Hypervisor
     │                                        │                │           │
  sandbox escape                         UAC bypass      token steal  kernel EoP   VBS/HVCI bypass

Common EoP Routes (Kernel)

  1. Pool corruption → fake object → controlled kernel dispatch → token steal
  2. UAF in win32k → controlled vtable → arbitrary kernel R/W → token steal
  3. Race condition (TOCTOU) → arbitrary write primitive → SYSTEM token
  4. Null pointer dereference (legacy, pre-SMEP era) → mapped NULL page shellcode
  5. Named pipe impersonation → SYSTEM token (user-mode, no kernel vuln needed)
  6. Write-what-where → EPROCESS token → replace token with SYSTEM token

Key Windows Internal Structures for Exploiters

StructureLocationExploit Use
_EPROCESSntoskrnltoken stealing, process context
_TOKENntoskrnlprivilege manipulation
_KTHREAD / _ETHREADntoskrnlAPC injection, privilege
_OBJECT_HEADERntoskrnlpool feng shui, type confusion
_POOL_HEADERntoskrnlpool exploitation
_SEGMENT_HEAPntoskrnl/userheap exploitation
tagWND / tagTHREADINFOwin32kUAF, type confusion
_HAL_DISPATCH_TABLEntoskrnloverwrite target (legacy)
_SEP_TOKEN_PRIVILEGESntoskrnlprivilege escalation
PreviousMode_KTHREADuser→kernel boundary tricks

Research Methodology

  1. Variant analysis — find one bug in a class → search all similar patterns
  2. Patch diffing — compare binaries before/after Patch Tuesday → find 1-days
  3. Fuzzing — coverage-guided (WTF, kAFL) for attack surface you control
  4. Code auditing — manual review of driver IOCTL handlers, kernel API handlers
  5. Root cause analysis — study public CVEs deeply to internalize bug patterns
  6. Exploitation development — turn PoC crashes into reliable weaponized exploits

References

  • Windows Internals 7th Ed., Russinovich, Solomon, Ionescu
  • “A Year in Review: Windows Kernel Exploitation” — various Project Zero posts
  • Microsoft Security Response Center (MSRC) CVE database
  • NtQuerySystemInformation / WinObj / WinDbg — primary research tools