
Proof-of-concept for CVE-2026-13043: bypasses the Panda/WatchGuard pskmad.sys authentication handshake to reach privileged IOCTLs for MSR reads and arbitrary process memory access.
Panda / WatchGuard pskmad.sys authentication bypass - privileged IOCTL access, MSR disclosure and arbitrary process memory read through a signed kernel driver.
This repository provides an educational breakdown of CVE-2026-13043, a critical missing authentication vulnerability in the Panda Kernel Memory Access Driver (pskmad.sys) shipped with WatchGuard and Panda endpoint security products.
The driver exposes a device interface (\\.\PSMEMDriver) with privileged IOCTL handlers designed to support the antivirus engine's memory inspection operations. In theory, only authorized Panda components should be able to reach those handlers - the driver gates access behind a challenge/response handshake. In practice, every piece of that handshake is reproducible: the named objects are caller-created, the challenge contains only public constants, and the expected response is a single hard-coded value. Any local administrator can forge the exchange, obtain a device handle, and talk directly to the privileged IOCTLs.
The two programs in this repository demonstrate the technique step by step, following a BYOVD (Bring Your Own Vulnerable Driver) approach:
01_HandshakeBypass - Loads the signed driver, forges the PsOpenPacket000 authentication handshake, and verifies the IOCTL dispatch path with a bounded self-read.02_DriverCapabilityExplorer - Reuses the handshake bypass and then exercises the capabilities that the driver exposes: reading Model-Specific Registers (defeating KASLR) and reading memory from any process through the kernel driver.The key insight is that all of this works on fully patched Windows 11 25H2 with VBS, HVCI, and kernel Control-flow Enforcement Technology (kCET) enabled. Unlike g_CiOptions patching techniques, nothing here modifies kernel memory - the reads are performed by the legitimate signed driver itself.
BYOVD is a well-known technique in offensive security: an attacker brings a legitimate, digitally signed driver that happens to contain a vulnerability. Because the driver carries a valid signature - in this case, from the Microsoft Windows Hardware Compatibility Publisher - Windows loads it into the kernel without complaint. Once loaded, the vulnerability gives the attacker a bridge from user mode into kernel mode, bypassing the usual security boundaries.
This technique is not theoretical. It is routinely used by advanced threat actors and red team operators. Microsoft maintains a driver block list to block known vulnerable drivers, and the community-driven LOLDrivers project catalogs drivers that have been observed in real-world attacks.
pskmad.sys is a kernel-mode driver shipped by Panda Security (now part of WatchGuard) as part of their endpoint security products. Its purpose is to give the antivirus engine memory inspection capabilities from kernel mode.
| Property | Value |
|---|---|
| File | pskmad.sys |
| Internal Name | PSKMAD_64 |
| Vendor | Panda Security, S.L.U. / WatchGuard |
| Product | Panda Technologies / WatchGuard Endpoint Security |
| CVE | CVE-2026-13043 |
| CVSS | 9.3 Critical (CVSS v4.0) |
| CWE | CWE-306 (Missing Authentication for Critical Function), CWE-798 (Use of Hard-coded Credentials) |
| Architecture | AMD64 |
| File Version | 1.1.0.23 |
| SHA-256 | 9bf3b737afa4d4f5e7b00ec749d4b75656ad66d9a2b402e1e81934e95ba7df5b |
| Device | \.\PSMEMDriver |
| Kernel Device | \Device\PSMEMDriver |
| Signature | Microsoft Windows Hardware Compatibility Publisher |
| Discovery | Juan Sacco (Exploit Pack) |
| LOLDrivers | b9216fc9-860e-43ae-8db2-e970c7e76b46 |
This is not a memory corruption bug. The vulnerability sits in the design of the authentication boundary itself.
The driver creates a device object (\Device\PSMEMDriver) with the symbolic link \Global??\PSMEMDriver and protects access to it through a handshake mechanism. The idea is that only trusted Panda/WatchGuard components should be able to complete the handshake and reach the IOCTL handlers behind it. The problem is that the handshake relies entirely on things that any process can reproduce: caller-created named objects, publicly visible constants, and a hard-coded success value. The driver never independently verifies that the process on the other end is actually a Panda component.
Once past the handshake, the caller has access to every IOCTL the driver implements. Looking at the import table gives a sense of what that means:
PsLookupProcessByProcessIdKeStackAttachProcess / KeUnstackDetachProcessMmMapIoSpaceAll of these are reachable through the IOCTL interface once the handshake is bypassed.
┌──────────────────────┐
│ User-Mode Client │
│ │
│ Creates named: │
│ - Shared Section │
│ - Signal Event │
│ - Reply Event │
└──────────┬───────────┘
│
│ PsOpenPacket000
▼
┌──────────────────────┐
│ pskmad.sys │
│ │
│ Authentication Gate │
│ ↓ │
│ Privileged IOCTLs │
└──────────┬───────────┘
│
▼
PSMEMDriver
This is classified as conventional BYOVD rather than BYOTC (Bring Your Own Trusted Component): although Panda attempted trusted-client verification, the verifier can be impersonated directly, so an attacker does not need to inject into or otherwise occupy a legitimate Panda process.
When a process opens the PSMEMDriver device, it cannot simply call CreateFileW. The driver requires a specially crafted NtCreateFile call carrying an Extended Attribute (EA) buffer with the packet name PsOpenPacket000. That packet contains the names of three kernel objects that the caller must create beforehand: