Links

.pagein (bring the page into the RAM)

Description of the '.pagein' command in HyperDbg.

Command

.pagein

Syntax

.pagein [Mode (string)] [VirtualAddress (hex)]

Description

Injects a page-fault and brings the target page into the memory.

Parameters

[Mode (string)] (optional)
The page-fault error code that needs to be injected. The error code can be one of these values, or a combination of these values:
p: present
w: write
u: user
f: fetch
k: protection key
s: shadow stack
h: hlat
g: sgx
[VirtualAddress (hex)]
The virtual address of where we want to bring its entry into the RAM.
Currently, this command is only supported in the Debugger Mode.

Page-Fault Error Codes

The following table is derived from Exceptions with some modifications, which explains the meaning of each bit in the Mode string.
Bit
Mode
Length
Name
Description
P
p
1 bit
Present
When set, the page fault was caused by a page-protection violation. When not set, it was caused by a non-present page.
W
w
1 bit
Write
When set, the page fault was caused by a write access. When not set, it was caused by a read access.
U
u
1 bit
User
When set, the page fault was caused while CPL = 3. This does not necessarily mean that the page fault was a privilege violation.
RSVD
1 bit
Reserved write
When set, one or more page directory entries contain reserved bits which are set to 1. This only applies when the PSE or PAE flags in CR4 are set to 1.
I
f
1 bit
Instruction Fetch
When set, the page fault was caused by an instruction fetch. This only applies when the No-Execute bit is supported and enabled.
PK
k
1 bit
Protection key
When set, the page fault was caused by a protection-key violation. The PKRU register (for user-mode accesses) or PKRS MSR (for supervisor-mode accesses) specifies the protection key rights.
SS
s
1 bit
Shadow stack
When set, the page fault was caused by a shadow stack access.
HLAT
h
1 bit
HLAT
When set, there is no translation for the linear address using HLAT paging.
SGX
g
1 bit
Software Guard Extensions
When set, the fault was due to an SGX violation. The fault is unrelated to ordinary paging.
This is a list of common page-fault error codes:
Error Code
Mode
Description
0x0
(default)
page not-found
0x2
w
write access fault
0x3
pw
present, write access fault
0x4
u
user access fault
0x6
wu
write, user access fault
0x7
pwu
present, write, user access fault
0x10
f
fetch instruction fault
0x11
pf
present, fetch instruction fault
0x14
uf
user, fetch instruction fault
In most cases, using a value of 0x0 (default page-fault error code) is the safest option.
Using this command with incorrect mode strings or virtual addresses that are not meant to be accessible is like delivering an exception to the target process. In the case of a thread operating in kernel-mode, the exception is directed towards the kernel. If the target process handles these exceptions appropriately, the Structured Exception Handling (SEH) handlers will be invoked. However, if the target fails to handle the exceptions properly, it may result in a crash of the target process. In the case of a kernel-mode thread, it can lead to a Blue Screen of Death (BSOD) for the entire system. Therefore, it is crucial to ensure that the necessary pages are brought in for the addresses intended to be accessible, and that the appropriate access page-fault error code is chosen.

Examples

The following command injects a page-fault with the error code equal to zero and the CR2 register is configured to 00007ff8349f2224.
0: kHyperDbg> .pagein 00007ff8349f2224
the page-fault is delivered to the target thread
press 'g' to continue debuggee (the current thread will execute ONLY one instruction and will be halted again)...
The following command injects a page-fault with the error code equal to 0x4 and the CR2 register is configured to 00007ff8349f2224.
0: kHyperDbg> .pagein u 00007ff8349f2224
the page-fault is delivered to the target thread
press 'g' to continue debuggee (the current thread will execute ONLY one instruction and will be halted again)...

IOCTL

This command works over serial by sending the serial packets to the remote computer.
First of all, you should fill in the following structure, set the VirtualAddress to your target virtual address that you want to put a breakpoint on it, and fill PageFaultErrorCode to your target page-fault error code.
typedef struct _DEBUGGER_PAGE_IN_REQUEST
{
UINT64 VirtualAddress;
UINT32 ProcessId;
UINT32 PageFaultErrorCode;
UINT32 KernelStatus;
} DEBUGGER_PAGE_IN_REQUEST, *PDEBUGGER_PAGE_IN_REQUEST;
The next step is sending the above structure to the debuggee when debuggee is paused and waiting for new command on vmx-root mode.
You should send the above structure with DEBUGGER_REMOTE_PACKET_REQUESTED_ACTION_ON_VMX_ROOT_INJECT_PAGE_FAULT as RequestedAction and DEBUGGER_REMOTE_PACKET_TYPE_DEBUGGER_TO_DEBUGGEE_EXECUTE_ON_VMX_ROOT as PacketType.
In return, the debuggee sends the above structure with the following type.
DEBUGGER_REMOTE_PACKET_REQUESTED_ACTION_DEBUGGEE_RESULT_OF_BRINGING_PAGES_IN
In the returned structure, the KernelStatus is filled by the kernel.
If the KernelStatus is DEBUGEER_OPERATION_WAS_SUCCESSFULL, then the operation was successful. Otherwise, the returned result is an error.
The following function is responsible for sending page-in requests to the debugger.
BOOLEAN KdSendPageinPacketToDebuggee(PDEBUGGER_PAGE_IN_REQUEST PageinPacket);

Remarks

Starting from v0.4, this command was added to the HyperDbg debugger.
This command is mainly designed to be used with the '.start' command. Certain pages (virtual addresses) may have been paged-out or are not currently present in the memory (RAM). Without these pages being stored in the physical RAM, it is not possible to utilize EPT hooks, such as the '!monitor' command, on those particular addresses. Therefore, executing this command will tell the operating system to retrieve the page and ensure the availability of the virtual address. Consequently, you will be able to utilize EPT hooks commands on those addresses.
This command is guaranteed to keep debuggee in a halt state (in Debugger Mode); thus, nothing will change during its execution. But after, running it, HyperDbg asks to continue the debuggee using the 'g' command. Subsequently, all processes will resume their execution, while the specific target (current) thread will execute a single instruction due to the Trap Flag being set. However, it will once again pause after handling the page fault and executing that one instruction.

Requirements

None