.pagein (bring the page into the RAM)
Description of the '.pagein' command in HyperDbg.
Command
.pagein
Syntax
.pagein [Mode (string)] [VirtualAddress (hex)]
.pagein [Mode (string)] [VirtualAddress (hex)] [l Length (hex)]
Description
Injects a page-fault and brings the target page (or a range of pages) 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 or the start address of a range of addresses where we want to bring its entry into the RAM.
[l Length (hex)] (optional)
The length of the memory (range) in bytes.
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.
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:
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 zero and starting from the a range where its CR2 register is configured to 00007ff8349f2224. and the last address is 00007ff8349f2224+(4*0x1000) which means it brings 5 pages into the memory or the length is 0x4000 bytes.
0: kHyperDbg> .pagein 00007ff8349f2224 l 4000
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 VirtualAddressFrom to your target virtual address that you want to put a breakpoint on and VirtualAddressTo to the end of the range of addresses, and fill PageFaultErrorCode to your target page-fault error code. Note that, if you want to bring only one page, then you can set both VirtualAddressFrom and VirtualAddressTo to the same value.
typedef struct _DEBUGGER_PAGE_IN_REQUEST
{
UINT64 VirtualAddressFrom;
UINT64 VirtualAddressTo;
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_INIn 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 and starting from v0.7 it supports a range of addresses.
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.
Please note that technically, you could use this command on a large range of memory. However, in large memory ranges, there are often page entries that are already valid (paged in or never paged out by the OS). In those cases, if you bring them into memory (force the OS to page them in) using this command, it will disrupt the OS semantics. This command injects a #PF (page fault) into the OS, and if the address is already valid, the operating system does not expect to receive a page fault for an available page, which might or will cause a triple fault and consequently a system restart or crash.
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
Related
Last updated