Skip to main content
Mallory
HighPublic exploitVulnerability

CVE-2025-7771: Arbitrary Physical Memory Access in TechPowerUp ThrottleStop Driver

Published Aug 6, 2025 · Updated today
Trending this weekNot trendingOutside this week’s top 100
Mention activity · 30 days1 mention · peak 1 in a dayToday
CVSS8.7High · v4
EPSS6.8%94th percentile
CISA KEVNoNot listed
In the wildReported7 exploitation records in Mallory
IdentifiersCVE-2025-7771CWE-782 · Exposed IOCTL with Insufficient…

CVE-2025-7771 is an arbitrary physical memory access vulnerability in the signed TechPowerUp ThrottleStop Windows kernel driver. Two exposed IOCTL interfaces use MmMapIoSpace to provide user-mode applications with arbitrary physical memory read and write capabilities. Attackers can abuse these primitives to modify the running Windows kernel and invoke arbitrary kernel functions with ring-0 privileges. Driver version 3.0.0.0 is affected; other versions may also be vulnerable. The flaw has been exploited in bring-your-own-vulnerable-driver attacks to suppress endpoint security before ransomware deployment.

Do you run this?See affected versions in your environment and whether adversaries are exploiting this vulnerability against assets like yours.
Check your exposure
Analyst brief

Impact, mitigation & remediation

What it means and what to do now: patch path, interim mitigations, and the assume-compromise checklist.

Impact

What an attacker gets, and what they’ve been doing with it.

Successful exploitation compromises kernel confidentiality and integrity and enables arbitrary code execution in kernel context. Attackers can elevate privileges, manipulate kernel memory, bypass kernel-level protections, and terminate protected security processes. Observed abuse includes disabling antivirus and EDR protections to facilitate subsequent ransomware execution.

Mitigation

If you can’t patch tonight, do this now.

Use Microsoft's vulnerable-driver blocklist and appropriately configured WDAC or App Control policies to prevent vulnerable driver loading. Enable compatible Core Isolation Memory Integrity protections and the Microsoft Defender ASR rule against abuse of vulnerable signed drivers. Restrict administrative privileges and driver-service installation. Inventory legitimate ThrottleStop deployments and monitor unexpected driver staging, loading, and associated security-process termination.

Remediation

Patch, then assume compromise.

Apply the vendor's security update according to its instructions when available. A verified fixed version is not identified in the available information. Remove or replace vulnerable driver installations where an update is unavailable, and prevent vulnerable copies from being reintroduced.

Public exploits

Exploits

16 exploits validated by Mallory's analysis. Hidden: 1 rejected by Mallory's analysis as not a working exploit; 1 not yet analyzed, such as Exploit-DB entries.

View more in app →
CVE-2025-7771This repository contains a working local privilege escalation exploit for CVE-2025-7771, targeting the ThrottleStop.sys driver (version 3.0.0.0) on Windows 10 and 11 x64 systems. The exploit is implemented in a single C++ file (exploit.cpp) and leverages insecure IOCTLs exposed by the driver to perform arbitrary kernel memory read/write via MmMapIoSpace. The exploit disables security features (ETW, AMSI), attempts to patch the kernel for privilege escalation, steals the SYSTEM token, and spawns a new SYSTEM shell (cmd.exe by default) using process hollowing for stealth. The README provides detailed vulnerability information, compilation instructions, and mitigation advice. The main attack vector is local, requiring code execution on the target system. The only fingerprintable endpoints are the device object (\\Device\\ThrottleStop) and the default SYSTEM shell path (C:\Windows\System32\cmd.exe). The exploit is operational and suitable for use in controlled testing environments.Yuri08loveElaina · Disclosed Aug 18, 2025 · c++ · localOperationalThrottleStopPoCThis standalone Windows C repository implements an exploit demonstration attributed by its README to CVE-2025-7771. It abuses insufficiently validated ThrottleStop driver IOCTLs to expose physical-memory and hardware I/O-port access. The code is not merely a vulnerability detector: it performs kernel-memory reads and includes an optional disruptive reset operation. Its hardcoded demonstration payload supports an OPERATIONAL classification, although the project presents itself as a PoC and execution was not independently validated. The 11 supplied files comprise four C implementation files, three headers, a Meson build definition, README, MIT license, and .gitignore. src/Exploit.c and src/Exploit.h define the device interface and typed memory/port access wrappers. src/vtop.c and src/vtop.h build a virtual-to-physical translation table using undocumented NtQuerySystemInformation Superfetch queries, including memory-range versions 1 and 2 and PFN queries. src/EProcess.c and its header resolve the kernel base and PsInitialSystemProcess, then traverse EPROCESS links using hardcoded offsets. src/Main.c checks elevation, opens the driver, builds the translation map, locates PID 4, reads its UniqueProcessId field, and optionally requests a hardware restart. meson.build produces the ThrottleStopPoC executable. Important limitations include OS-dependent EPROCESS offsets, dependence on privileged Superfetch information, and translation failures returning zero without consistently being checked before physical-memory access. The port-write structures also rely on compiler layout and padding, which warrants validation against the driver's expected request lengths. The README mentions possible MSR read/write IOCTLs, but these are not implemented in the supplied source. It also references a Drivers directory that is absent from the supplied listing. No network connections, remote targets, downloaders, or exfiltration routines appear in the code; README URLs are references rather than runtime destinations. The original repository URL, git reference, and archive size were not supplied; empty strings and zero represent those unavailable metadata values.wqsv · Disclosed Aug 31, 2025 · c · localOperationalThrottleStopThis repository provides a working local privilege escalation exploit for CVE-2025-7771, a vulnerability in the ThrottleStop.sys driver by TechPowerUp. The vulnerability arises from exposed IOCTL interfaces (0x80006498 for reading and 0x8000649C for writing) that allow unprivileged users to map and manipulate arbitrary physical memory via MmMapIoSpace. The exploit is implemented in C++ and consists of a usermode application (Entry.cpp) and a driver communication class (Driver.h). The MemoryDriver class opens a handle to the device (\\.\ThrottleStop), enumerates processes, and performs physical memory operations using DeviceIoControl. The exploit demonstrates reading and writing to physical memory, targeting a process (e.g., notepad.exe), and restoring original values. The repository includes build instructions, usage guidance, and references to advisories and analyses. The exploit requires the vulnerable driver to be installed and running, and administrator privileges to execute. The main attack vector is local, and the primary fingerprintable endpoint is the device file \\.\ThrottleStop. The code is operational and can be used to escalate privileges or execute arbitrary code in kernel context on affected Windows systems.Demoo1337 · Disclosed Sep 7, 2025 · cpp · xml · localOperationalCVE-2025-7771This repository contains a functional exploit for CVE-2025-7771, targeting the ThrottleStop driver on Windows. The exploit leverages the driver's capabilities to read and write physical memory, allowing a user-mode process to invoke arbitrary kernel-mode functions. The main entry point is 'main.cpp', which demonstrates creating a ThrottleStop instance, resolving kernel base addresses, and calling the kernel function 'DbgPrint' from user mode. The core logic is implemented in 'throttlestop/throttlestop.cpp' and 'throttlestop/throttlestop.h', which provide methods for interacting with the driver, resolving kernel exports, and patching kernel memory to redirect execution flow. The exploit requires the ThrottleStop driver to be present and accessible, and it interacts with the driver via the device interface '\\.\ThrottleStop'. The repository is well-structured, with separate components for service management, memory mapping, and kernel interaction. The exploit demonstrates operational maturity, providing a working method for kernel code execution from user mode, which can be leveraged for privilege escalation or further exploitation.Gabriel-Lacorte · Disclosed Oct 3, 2025 · cpp · c++ · localOperationalCVE-2025-7771Repository purpose: a Windows local PoC for CVE-2025-7771 targeting the ThrottleStop.sys kernel driver. The exploit opens the device \\.\ThrottleStop and uses two hardcoded IOCTLs to achieve arbitrary physical memory read (0x80006498) and write (0x8000649C). To make those primitives usable against kernel virtual addresses, it embeds a C++ “Superfetch” helper (compiled via build.rs into a static library) that snapshots the system memory map using NtQuerySystemInformation(SystemSuperfetchInformation=79) and PFN queries, caching translations from virtual page addresses to physical addresses. Main capabilities implemented: - Arbitrary physical memory read/write (8-byte reads; writes chunked/padded to 8 bytes via BreakBuffer). - Kernel symbol resolution: enumerates loaded kernel drivers to get the kernel base VA (EnumDeviceDrivers), then loads ntoskrnl.exe in userland and resolves PsInitialSystemProcess via GetProcAddress to compute its kernel VA. - EPROCESS discovery: reads PsInitialSystemProcess to obtain the System EPROCESS pointer, then walks the ActiveProcessLinks list to find a target process by PID. - Process “protection” toggling: writes a single byte at EPROCESS+Protection (offset 0x87A). The PoC sets 0x61 (PPL-like) for protect and 0x00 for unprotect. - Process hiding/unhiding: DKOM-style unlink/relink by rewriting LIST_ENTRY pointers in ActiveProcessLinks. Unhide requires the caller to provide the hidden process’s EPROCESS address. Repository structure: - Rust core: src/main.rs (CLI entry), src/utils.rs (clap subcommands), src/driver.rs (device open + IOCTL read/write), src/kernel.rs (kernel base + symbol offset), src/eprocess.rs (process enumeration + EPROCESS manipulation), src/superfetch.rs (FFI bindings). - C++ helper: superfetch/superfetch.h + nt.h implement Superfetch PFN/memory range querying and VA->PA translation; superfetch/wrapper.cpp exposes C ABI wrappers used by Rust. Operational notes/assumptions: - This is a local exploit/PoC (not networked). It requires administrative rights to load/start the vulnerable driver service and to perform the Superfetch privilege adjustments. - The EPROCESS offsets are hardcoded and therefore Windows-build dependent; reliability will vary across versions. - No reverse shell or remote payload is included; the delivered effect is kernel memory manipulation enabling stealth (hide) and process protection changes.xM0kht4r · Disclosed Jan 13, 2026 · rust · cpp · local · kernel-driver-ioctlOperationalCVE-2025-7771Repository is a Rust-based local Windows kernel exploit app for CVE-2025-7771. It bundles a vulnerable kernel driver (referenced in README as data.rs; imported as src/data module) and uses it to obtain arbitrary kernel memory read/write. Core flow (src/main.rs): 1) Generate random service/driver name. 2) Drop embedded vulnerable driver bytes to %TEMP%\\<name>.sys (utils::drop_vulnerable_driver). 3) Create and start a kernel-driver service (service.rs wrapper around SCM APIs). 4) Open the device \\??\\<service_name> (exploit.rs) and build a MemoryMap (spf.rs) to translate virtual->physical addresses. 5) Demonstrate primitive by resolving ntoskrnl base (nt.rs via NtQuerySystemInformation(SystemModuleInformation)) and parsing ntoskrnl.exe exports (nt.rs + pe.rs + filemap.rs). It then reads 4 bytes from MmGetSystemRoutineAddress and patches its first 3 bytes with 31 C0 C3. 6) Stop and delete the driver service and exit. Key exploit capability (src/exploit.rs): - Implements arbitrary kernel read/write by translating a target virtual address to a physical address (spf::MemoryMap::translate), then invoking vulnerable driver IOCTLs to map that physical memory into user space (IOCTL 0x8000645C) and unmap it (0x80006460). Data is copied with ptr::copy_nonoverlapping. Supporting modules: - src/spf.rs: Superfetch/PFN-query based VA->PA translation (builds a HashMap of virtual page -> physical page). Attempts to enable SE_PROF_SINGLE_PROCESS_PRIVILEGE and SE_DEBUG_PRIVILEGE. - src/service.rs: Service Control Manager wrapper to create/start/stop/delete the kernel driver service. - src/filemap.rs: Win32 file mapping wrapper used to map ntoskrnl.exe as an image. - src/nt.rs: NT helpers: privilege adjustment declarations, NtQuerySystemInformation usage, kernel base discovery, and export resolution. - src/pe.rs: PE structure/constants for parsing exports. No network IOCs are present; all targeting is local via Windows device handle/IOCTLs and local file paths.lzty · Disclosed Jan 21, 2026 · rust · toml · localOperational0xKern3lCrushThis repository is a small Windows BYOVD-focused project with 11 files: one C source file, one C header, and supporting Markdown documentation. Despite README claims that it is only safe reconnaissance, the actual code in src/0xPoC.c is an operational local exploit for Safetica ProcessMonitorDriver.sys (CVE-2026-0828). The program opens the device \\.\STProcessMonitorDriver, enumerates running processes via Toolhelp32 APIs, compares process names against a hardcoded security-product target list from src/0xtargets.h, and for each match sends DeviceIoControl with IOCTL 0xB822200C and a 64-bit PID. Successful execution results in kernel-assisted termination of targeted AV/EDR processes. Repository structure: src/0xPoC.c is the main exploit entry point; src/0xtargets.h contains the hardcoded kill list (Defender, CrowdStrike, SentinelOne, Carbon Black, Cylance, McAfee, Symantec/Norton, Kaspersky, ESET, Bitdefender, Sophos, Malwarebytes, Safetica, etc.). The remaining files are documentation: README.md describes BYOVD research themes; drivers/0xhashes.md lists hashes, device symlink, and IOCTL details for Safetica; research/0xsafetica-cve-2026-0828.md and research/0xthrottlestop-medusalocker.md summarize two vulnerable-driver cases; docs/0xmitigations.md provides defensive guidance. Main exploit capability: local post-compromise abuse of a vulnerable signed Windows driver to kill protected or security-relevant processes. There is no network communication, persistence, or shell payload. The exploit is dependent on the vulnerable driver already being present and started as a service. The code is straightforward and hardcoded rather than modular, so OPERATIONAL is the best maturity fit rather than WEAPONIZED.DeathShotXD · Disclosed Feb 4, 2026 · c · markdown · localOperational0xKern3lCrush-Foreverday-BYOVD-CVE-2026-0828Repository purpose: BYOVD research focused on Windows vulnerable signed drivers, with documentation plus a working user-mode PoC that abuses Safetica’s ProcessMonitorDriver.sys (CVE-2026-0828) to terminate processes via a vulnerable IOCTL. Structure (11 files): - Documentation-heavy: README.md, SECURITY.md, docs/0xmitigations.md (defensive guidance), research/*.md (case studies/patterns), drivers/0xhashes.md (hashes and sources for ProcessMonitorDriver.sys). - Code: src/0xPoC.c (main program) and src/0xtargets.h (hardcoded list of security product process names). Main exploit capability (src/0xPoC.c): - Opens the device interface `\\.\STProcessMonitorDriver` with read/write access. - Enumerates processes using Toolhelp32 APIs (CreateToolhelp32Snapshot / Process32First/Next). - For each process whose name matches the list in 0xtargets.h (Defender, CrowdStrike, SentinelOne, etc.), sends `DeviceIoControl` with IOCTL `0xB822200C` and an 8-byte PID (UINT64). - Reports per-target success/failure and totals. This is an AV/EDR “kill” primitive implemented through a vulnerable driver (BYOVD), not merely reconnaissance. Targeting notes: - CVE-2026-0828: Safetica ProcessMonitorDriver.sys, versions 10.5.75.0 and 11.11.4.0; unprivileged IOCTL path allows arbitrary process termination. - CVE-2025-7771: ThrottleStop.sys is discussed in research notes only (no code in repo for that chain), including device `\\.\ThrottleStop` and example IOCTLs in narrative. Notable observables for defenders: - Device name: `\\.\STProcessMonitorDriver` (and referenced `\\.\ThrottleStop`). - IOCTL: `0xB822200C` used for termination. - Process target list in src/0xtargets.h can be used as an indicator of intent (EDR/AV neutralization). Sanity: Despite README claims of “zero working exploits,” the included C program does implement an operational IOCTL-based process termination routine against the Safetica driver, contingent on the vulnerable driver being present and loaded.DeathShotXD · Disclosed Feb 4, 2026 · c · markdown · local (Windows user-mode) BYOVD abuse via DeviceIoControl to a vulnerable signed kernel driverOperationalcve-2025-7771This repository is a compact Windows local privilege escalation proof-of-concept for CVE-2025-7771 affecting the ThrottleStop.sys driver. The repo contains only two files: a README describing the vulnerability and exploitation strategy, and a single C++ source file implementing the exploit. The exploit is not part of a larger framework. Core capability: the code abuses two vulnerable device IOCTLs exposed by the driver (0x80006498 read and 0x8000649C write) to perform arbitrary physical memory access from an administrator process. It opens the device \\.\ThrottleStop, verifies read access, then uses NtQuerySystemInformation with the Superfetch information class to build a virtual-to-physical translation map. It also obtains the running kernel base, resolves the PsInitialSystemProcess symbol from ntoskrnl.exe, translates that kernel virtual address to a physical address, and reads the SYSTEM process EPROCESS pointer. From there, the exploit performs classic token stealing: it reads the SYSTEM token from the EPROCESS Token field, walks ActiveProcessLinks to find the current process EPROCESS, preserves the low EX_FAST_REF refcount bits, overwrites the current process token with the SYSTEM token via physical memory write, verifies the write, and finally launches C:\Windows\System32\cmd.exe to obtain a SYSTEM shell. Repository structure is minimal and purpose-built: README.md documents the vulnerability, tested Windows versions, required offsets, and exploitation steps; exploit.cpp contains the full implementation including driver I/O helpers, privilege adjustment, Superfetch query structures, virtual-to-physical mapping logic, kernel symbol resolution, EPROCESS traversal, token overwrite, and shell spawning. This is a real exploit rather than a detector, and its maturity is operational because it contains a complete hardcoded privilege-escalation chain and payload outcome (spawn SYSTEM cmd.exe), but it is not generalized into a reusable framework.mein-0 · Disclosed May 23, 2026 · cpp · markdown · localOperationalCVE-2025-7771This three-file repository contains a C++ Windows local privilege-escalation proof of concept for CVE-2025-7771 in TechPowerUp ThrottleStop.sys 3.0.0.0. The README documents the vulnerable signed driver, its hashes, service-derived device naming behavior, build instructions, and operational prerequisites; it does not distribute the driver. The sole code file, src/ThrottleStop.cpp, opens a candidate driver device and invokes physical-memory read (0x80006498) and write (0x8000649C) IOCTLs. It reads the Physical Memory ResourceMap registry value, scans only reported RAM ranges for the SYSTEM and current-process EPROCESS structures using hard-coded offsets, reads the SYSTEM token, masks EX_FAST_REF low bits, and overwrites the current process token. It then launches cmd.exe to demonstrate SYSTEM execution. This is an administrator-to-SYSTEM/BYOVD technique rather than an unauthenticated or remote exploit; successful operation depends on loading the vulnerable driver and matching the target Windows kernel's EPROCESS layout.yulisec · Disclosed Sep 24, 2026 · cpp · markdown · localOperationalCiGaslightThis standalone Windows BYOVD exploit contains 18 files: seven C implementation files, seven headers, a README, a Visual Studio solution, and two project configuration files. The vulnerable driver, compiled executable, and README-referenced screenshot are not included in the supplied file list. No exploit framework is present. The repository URL, git reference, and archive size were not supplied; their metadata fields are left empty or zero rather than inferred. main.c coordinates privilege enabling, driver loading, symbol resolution, memory mapping, exploitation, verification, and cleanup. core/ntdll.c resolves native APIs; core/pdb.c discovers loaded module bases, extracts PDB identifiers, downloads matching symbols, and resolves addresses with DbgHelp. core/v2p.c builds a virtual-to-physical map using physical resource ranges and Superfetch PFN queries. driver/ts.c manages the ThrottleStop service and exposes physical-memory reads/writes. kernel/kcall.c temporarily overwrites the first 12 bytes of NtAddAtom with an absolute jump, invokes it through the user-mode syscall entry, and attempts to restore the original bytes. This supplies kernel calls for pool allocation and address translation. spoof/spoof.c zeroes g_CiOptions, installs the 49-byte response stub, searches the first 0x200 bytes of SeCiCallbacks for CiQueryInformation, replaces that pointer, and checks that the normal integrity query returns 0x4001. The behavior is a substantive local exploitation attempt, not merely detection or an obvious fake. Its payload is fixed and basic, supporting an OPERATIONAL classification, although execution was not validated. The stated CVE association and test results come from the supplied README. Windows 11 support is only claimed, and modern driver blocking or kernel protections may prevent operation. A visible source issue is that v2p.c uses g_NtQSI without including ntdll.h, where it is declared. Although Win32 configurations exist, the trampoline, pointer handling, and shellcode are x64-specific. Cleanup attempts to unload the driver and delete its service, but successful exploitation deliberately leaves g_CiOptions zeroed, the callback redirected, and the allocated kernel page resident. Several intermediate failures restore g_CiOptions, but final verification failure does not restore either modified integrity state or callback. The temporary kernel patch is unsynchronized, restoration success is not checked, and kernel modification may cause crashes or integrity-protection responses. There is no reverse shell, exfiltration, autonomous propagation, direct antivirus termination, or subsequent unsigned-driver loader in the supplied code. Its only explicit outbound network activity downloads Microsoft symbols; advisory and sample links in the README are references, not runtime destinations.datcathuh · Disclosed Oct 21, 2026 · c · localOperationalThrottleStopPoCThis repository is a proof-of-concept (PoC) exploit for CVE-2025-7771, targeting the ThrottleStop driver on Windows systems. The exploit leverages several unprotected IOCTLs exposed by the driver to perform arbitrary physical memory and I/O port read/write operations from user mode. The main entry point is 'src/Main.c', which checks for administrative privileges, opens a handle to the ThrottleStop device (\\.\ThrottleStop), and demonstrates reading the UniqueProcessId from the EPROCESS structure of the System process. It also offers the option to force a system restart by writing to I/O port 0xCF9. The exploit includes code for translating virtual to physical addresses using undocumented Superfetch APIs (src/vtop.c), and for resolving EPROCESS structures (src/EProcess.c). The IOCTL codes and their purposes are well documented in the README and headers. The exploit is intended for research and demonstration purposes, and requires the vulnerable driver to be loaded and accessible. No network endpoints are involved; the attack vector is local privilege escalation via direct device access.fxrstor · Disclosed Aug 31, 2025 · c · localPoCthrottlestop-exploit-rwThis repository is a proof-of-concept (POC) exploit for CVE-2025-7771, a local privilege escalation vulnerability in the ThrottleStop.sys driver (version 3.0.0.0) on Windows. The exploit demonstrates how to leverage the driver's exposed IOCTLs to perform arbitrary physical memory reads and writes from user mode, without any access control. The codebase consists of C++ source and header files, with the main logic in 'Entry.cpp' and driver interaction in 'Driver/Driver.h'. The exploit uses the Superfetch technique (implemented in 'Superfetch/Superfetch.h' and 'Superfetch/nt.h') to translate kernel virtual addresses to physical addresses, which are then accessed via DeviceIoControl calls to the driver. The main attack vector is local: an attacker must execute code on the target system with sufficient privileges to open a handle to the driver. The only fingerprintable endpoint is the device file '\\.\ThrottleStop'. The exploit can be used to read or modify any physical memory, enabling kernel code modification, disabling security features, or escalating privileges. The repository is structured as a Visual Studio C++ project, with clear separation between driver communication, memory translation, and the main exploit logic.AmrHuss · Disclosed Nov 13, 2025 · cpp · c++ · localPoCThrottleStopPPLThis repository is a proof-of-concept (PoC) exploit for CVE-2025-7771, targeting a vulnerability in the ThrottleStop driver on Windows Server 2022. The exploit leverages the driver's arbitrary physical memory read/write IOCTLs to manipulate kernel memory, specifically the EPROCESS structure of any process, in order to change its Protected Process Light (PPL) protection level. The codebase is written in C and structured as a Visual Studio project, with main logic in 'main.c', memory manipulation in 'exploit.c', process structure handling in 'eprocess.c' and 'ppl.c', and virtual-to-physical address translation in 'vtop.c'. The exploit requires the vulnerable driver to be loaded and administrator privileges. The main entry point is 'main.c', which parses command-line arguments, opens the driver, builds a memory map, and invokes the core exploit functionality. The exploit is operational as a PoC and demonstrates local privilege escalation by allowing arbitrary modification of process protection levels, effectively bypassing Windows process security boundaries.v31l0x1 · Disclosed Dec 31, 2025 · c · localPoCCVE-2025-7771This repository is a compact Windows local privilege escalation exploit for CVE-2025-7771 in TechPowerUp ThrottleStop.sys. It contains one substantive code file, src/ThrottleStop.cpp, plus a README documenting the vulnerability, affected driver hashes/certificate, exploitation flow, and operational caveats. The exploit is not part of a larger framework. The code implements a full exploit chain rather than mere vulnerability detection. It abuses two driver IOCTLs (0x80006498 read and 0x8000649C write) that expose unvalidated physical memory access from user mode. The program first queries the physical memory map from the registry ResourceMap, then scans populated RAM ranges for EPROCESS structures corresponding to the SYSTEM process (ImageFileName "System", PID 4) and the current process. Using hardcoded _EPROCESS offsets, it reads the SYSTEM token, masks low EX_FAST_REF bits, overwrites the current process token, and finally launches cmd.exe to obtain a SYSTEM shell. Notable exploit capabilities include: opening multiple possible device names for the vulnerable driver, bounded physical memory scanning based on firmware-reported RAM ranges, arbitrary 8-byte physical reads/writes through the driver, token theft for admin-to-SYSTEM escalation, and post-exploitation verification via whoami. The README also highlights an important detection-evasion characteristic: the device object name is derived from the service name, so path- or filename-based detections are unreliable. Repository structure is minimal: .gitattributes, README.md, and src/ThrottleStop.cpp. The code is C++ targeting Windows user mode and links against advapi32 for registry access. Overall, this is an operational BYOVD-style local exploit demonstrating how a signed but vulnerable kernel driver can be used by an administrator to bypass higher-trust protections and elevate to NT AUTHORITY\SYSTEM.enessakircolak · Disclosed Aug 10, 2026 · cpp · markdown · localPoCdriver-mapperThis standalone Windows bring-your-own-vulnerable-driver exploit targets CVE-2025-7771 in TechPowerUp's ThrottleStop.sys. It uses the signed helper driver's unrestricted physical-memory interfaces to support arbitrary kernel-memory operations and manually execute a user-supplied driver. It is not a scanner or a framework module, and no shell, persistence mechanism, or application-specific malicious driver payload is supplied. The 12 supplied files comprise a README, three Visual Studio solution/project files, four C implementations, and four headers. main.c orchestrates privilege adjustment, helper-driver loading, kernel-symbol resolution, address-map construction, payload reading, mapping, and cleanup. kernel.c implements service/device access and exposes physical-memory, kernel-memory, kernel-call, export-resolution, and virtual-to-physical mapping functionality. mapper.c implements PE staging, relocation, named-import resolution, contiguous kernel allocation, and DriverEntry invocation. symbols.c extracts the kernel PDB GUID and age, downloads matching symbols from Microsoft, and resolves three kernel functions using DbgHelp. The headers provide shared types, IOCTL constants, and interfaces. The documented kernel-call mechanism temporarily replaces the first 12 bytes of NtAddAtom with a mov-rax/jmp-rax trampoline. A Superfetch PFN query supplies virtual-to-physical mappings, with MmGetPhysicalAddress described as a fallback. The supplied kernel.c is explicitly truncated, so those implementation details cannot all be independently verified from the visible source. Important constraints include unsupported ordinal imports, dependence on already-loaded import modules, a zeroed rather than normally initialized DRIVER_OBJECT, a NULL registry path, and no mapped-driver unload or allocation reclamation. The temporary kernel patch is race-prone and may crash the system. The code does not implement the separate DSE-disabling or integrity-report spoofing behavior discussed in the README's reference to another project. Although normal post-load paths remove the helper service, an early helper-load failure can bypass that cleanup. The README identifies the intended helper sample by SHA-256 16f83f056177c4ec24c7e99d01ca9d9d6713bd0497eeedb777a3ffefa99c97f0. However, generated/ts_bytes.h, which should contain that embedded driver, is absent from the supplied inventory despite being referenced by the project and main.c. The documented sys2h.py conversion utility is also absent. Consequently, this snapshot is not demonstrably buildable as supplied, and the embedded binary's identity cannot be checked. Maturity is classified as POC because the actual target driver payload is external and absent. No original repository URL, Git reference, or archive size was provided; the corresponding empty strings and zero are unknown-value placeholders.datcathuh · Disclosed Oct 23, 2026 · c · localPoC
FAQ

Frequently asked questions

Is CVE-2025-7771 exploited in the wild?
Yes. As of Nov 16, 2026, Mallory has reports of exploitation in the wild.
Is there a public exploit for CVE-2025-7771?
Yes. Mallory tracks 16 public exploits or proofs of concept for CVE-2025-7771, the earliest disclosed Aug 18, 2025.
Is there a patch for CVE-2025-7771?
Apply the vendor's security update according to its instructions when available. A verified fixed version is not identified in the available information.
How severe is CVE-2025-7771?
CVE-2025-7771 has a CVSS v4 score of 8.7 (High) and an EPSS score of 6.8% (94th percentile) as of Nov 16, 2026.
Activity feed

Recent activity

31 sources tracked across advisories, community write-ups, and news. New activity surfaces here as Mallory finds it.

View more in app →
+6 more in the timeline. Sign up to see them
Do you run this?See affected versions in your environment and whether adversaries are exploiting this vulnerability against assets like yours.
Check your exposure
Mallory platform

The version that knows your environment.

This page is what’s public. Mallory adds the parts that aren’t: which of your assets are affected, which adversaries are exploiting it right now, and which detections to deploy tonight.
Exposure mappingQuery your assets running an affected version, and investigate the blast radius.
Threat actor evidence4Every report linking this CVE to a named adversary.
Associated malware11Malware families linked to this CVE, with evidence and IOCs.
Detection signaturesYARA, Sigma, Snort, and vendor rules, auto-deployed to your SIEM.
Vendor-by-vendor mappingCross-references every affected SKU, including bundled OEM variants.
Social activity21Community discussion across Reddit, Mastodon, and other social sources.