Dokumentacja Techniczna API Silnika Polimorficznego Poly

unsigned int __stdcall _poly(
  void *             lpDecryptor,
  void *             lpOutput,
  void *             lpInput,
  unsigned int       iSize,
  unsigned int       lpVA,
  unsigned int       cMaxInstr,
  unsigned int       cMinInstr,
  unsigned int       iGarbage,
  unsigned int       iForceSize,
  unsigned int       lpRelativeAddr,
  struct POLY_REGS * lpPolyOutRegs,
  unsigned int       iOptions,
  void *             lpWorkMem,
  unsigned int       iRandomSeed
);

#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

#include "poly.h"

// makro pomocnicze
#define RND_RANGE(min,max) (min + (rand() % (int)(max - min + 1)))

// liczba testowych iteracji
const int POLY_TEST_ITERATIONS = 10000;

// bezpieczny rozmiar bufora pamięci
const int POLY_DECRYPTOR_SIZE = 1024 * 2048 * 10;

// przykładowe dane wejściowe do zaszyfrowania
unsigned char cInputBuffer[] = { 0x11, 0x22, 0x33, 0x44 } ;

// bufor wyjściowy
unsigned char cOutputBuffer[sizeof(cInputBuffer)] = { 0 };

int main(int argc, char* argv[])
{
  // zaalokuj bufor pamięci dla zaszyfrowanego bloku (pamięć musi mieć ustawioną flagę pozwalającą na wykonywanie kodu)
  PVOID lpDecryptor = VirtualAlloc(nullptr, POLY_DECRYPTOR_SIZE, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);

  // roboczy bufor pamięci (ten sam rozmiar i flagi wykonywalne)
  PVOID lpWorkMem = VirtualAlloc(nullptr, POLY_DECRYPTOR_SIZE, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);

  for (int i = 0; i < POLY_TEST_ITERATIONS; i++)
  {
    //
    // przygotuj parametry silnika Poly
    //

    // ustaw losowe wartości parametrom (pamiętaj, że im więcej np. instrukcji szyfrujących, tym
    // większe muszą być rozmiary buforów pamięci lpDecryptor i lpWorkMem)

    // minimalna liczba instrukcji szyfrujących
    unsigned int iMinEncryptionCommands = RND_RANGE(10, 50);

    // maksymalna liczba instrukcji szyfrujących
    unsigned int iMaxEncryptionCommands = RND_RANGE(iMinEncryptionCommands, iMinEncryptionCommands + 10);

    // liczba instrukcji zaciemniających (garbage / junks) przypadająca na instrukcję w kodzie deszyfrującym
    unsigned int iGarbage = RND_RANGE(10, 50);

    // wymuś rozmiar kodu deszyfrującego - jeśli ten parametr jest ustawiony, silnik Poly
    // będzie tak długo generował kod deszyfrujący aż osiągnie ten rozmiar, jeśli wygenerowany
    // kod będzie zbyt mały lub zbyt duży to w locie zmodyfikuje parametry iMinEncryptionCommands,
    // iMaxEncryptionCommands oraz iGarbage i będzie do skutku próbował wygenerować kod, który
    // spełni to kryterium (proszę upewnij się, że bufory lpDecryptor i lpWorkMem są większe niż
    // ta wartość)
    unsigned int iForceDecryptorSize = 0;

    // jeśli ten parametr jest ustawiony, polimorficzny kod deszyfrujący użyje go do obliczenia
    // adresu zaszyfrowanych danych w pamięci relatywnie do bieżącego położenia kodu
    // deszyfrującego w pamięci (wartość ta może mieć negatywną wartość)
    unsigned int iRelativeDataOutputOffset = 0;

    // flagi
    unsigned int iOptions = 0;

    // POLY_SAVE_REGS - zachowaj stan wszystkich rejestrów i przywróć je po zakończeniu deszyfrowania
    iOptions |= POLY_SAVE_REGS;

    // POLY_SAVE_FLAGS - zachowaj stan wszystkich flag procesora i przywróć je po zakończeniu deszyfrowania
    iOptions |= POLY_SAVE_FLAGS;

    // POLY_ATTACH_DATA - dołącz zaszyfrowane dane do kodu dekryptora, kod deszyfrujący nadpisze
    // własny bufor pomięci odszyfrowanymi danymi, co oznacza, że wskaźnik kodu deszyfrującego
    // będzie jednocześnie wskazywał na odszyfrowane dane
    //
    // jeśli ta flaga nie jest ustawiona, zaszyfrowane dane będą musiały znajdować się pod
    // ustalonym i statycznym adresem wirtualnym określonym przez parametr lpVA lub
    // relatywnym adresem określonym przez parametr iRelativeDataOutputOffset
    iOptions |= POLY_ATTACH_DATA;

    // POLY_RETURN - umieść instrukcję powrotu (RET) na końcu funkcji deszyfrującej,
    // tak, że dekryptor wróci do kodu, który go wywołał, polimorficzny dekryptor może
    // być umieszczony również bezpośrednio pomiędzy innym kodem lub dowolny kod może być
    // dodany po nim, dlatego nie zawsze musi wracać do kodu, który go wywołał
    iOptions |= POLY_RETURN;

    // POLY_SET_REGS - zwróć określone wartości w rejestrach procesora po deszyfrowaniu
    // (muszą być one zdefiniowane w strukturze POLY_REGS)
    iOptions |= POLY_SET_REGS;

    // flaga oznacza, że rejestr EAX po deszyfrowaniu ma być ustawiony
    iOptions |= POLY_SET_EAX;

    // i przykładowo zwróćmy inną wartość w rejestrze EDX po deszyfrowaniu
    iOptions |= POLY_SET_EDX;

    // wartości wyjściowych rejestrów (wypełnij tylko te, które mają być ustawione)
    POLY_REGS prPolyRegs = { 0 };

    // ustaw wartość rejestru EAX jaka ma być ustawione po deszyfrowaniu, w tym
    // przykładzie ustawmy tą wartość na rozmiar odszyfrowanego bufora danych
    // (można tu ustawić wszystko)
    prPolyRegs.regEax = sizeof(cInputBuffer);

    // przykładowa wartość jaka ma być zwrócona w rejestrze EDX po deszyfrowaniu
    // (można to podejrzeć za pomocą debuggera)
    prPolyRegs.regEdx = 0xDEADBEEF;

    // zaszyfruj dane i wygeneruj polimorficzny kod deszyfrujący
    unsigned int dwOutputSize = _poly(

      lpDecryptor,                   // bufor wyjściowy na polimorficzny kod / dane
      cOutputBuffer,                 // bufor na zaszyfrowane dane (może być taki sam jak lpInput) (opcjonalnie)
      cInputBuffer,                  // bufor z danymi wejściowymi do zaszyfrowania
      sizeof(cInputBuffer),          // rozmiar danych do zaszyfrowania
      (unsigned int)&cOutputBuffer,  // wirtualny adres gdzie znajdą się dane do odszyfrowania (opcjonalnie)
      iMaxEncryptionCommands,        // max. liczba instrukcji szyfrujących
      iMinEncryptionCommands,        // min. liczba instrukcji szyfrujących
      iGarbage,                      // liczba instrukcji zaśmiecających na instrukcję dekryptora
      iForceDecryptorSize,           // wymuś rozmiar dekryptora (opcjonalnie)
      iRelativeDataOutputOffset,     // relatywny adres zaszyfrowanych danych (opcjonalnie)
      &prPolyRegs,                   // rejestry wyjściowe (opcjonalnie)
      iOptions,                      // dodatkowe opcje
      lpWorkMem,                     // pamięć robocza
      GetTickCount()                 // inicjalizator dla wewnętrznego generatora losowego

    );

    // sprawdź rozmiar wyjściowych danych (rozmiar dekryptora w bajtach)
    if (dwOutputSize != 0)
    {
      PolyDecryptorFunction DecryptorFunction = reinterpret_cast<PolyDecryptorFunction>(lpDecryptor);

      // wywołaj kod dekryptora i odszyfruj dane
      unsigned int dwResult = DecryptorFunction();

      // inny sposób na wywołanie kodu dekryptora (w assemblerze)
      /*
      __asm
      {
        int  3

        mov  eax, lpDecryptor;
        call  eax

        int 3
      }
      */

      // zweryfikuj odszyfrowane dane (jeśli parametr POLY_ATTACH_DATA być ustawiony, wskaźnik
      // lpDecryptor wskazuje jednocześnie na dekryptor a po jego uruchomieniu na odszyfrowane dane)
      if (memcmp(reinterpret_cast<PVOID>(lpDecryptor), cInputBuffer, sizeof(cInputBuffer) != 0))
      {
        printf("Odszyfrowane dane są inne niż powinny być!\n");
        _getch();

        return 2;
      }
    }
    else
    {
      printf("Nie udało się zaszyfrować danych!\n");
      _getch();

      return 1;
    }
  }

  printf("Test Silnika Polimorficznego Poly Polymorphic udał się (%lu iteracji testowych)\n", POLY_TEST_ITERATIONS);

  // zwolnij pamięć
  VirtualFree(lpDecryptor, 0, MEM_RELEASE);
  VirtualFree(lpWorkMem, 0, MEM_RELEASE);

  _getch();

  return 0;
}

Wymagania

// exclude rarely-used stuff from Windows headers
#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <fstream>
#include <iostream>
#include <vector>

#include "poly.h"

// load library from the DLL file (by default .LIB file is used)
#define USE_POLY_DLL

// helper macro
#define RND_RANGE(min,max) (min + (rand() % (int)(max - min + 1)))

// safe memory buffer size
const int POLY_DECRYPTOR_SIZE = 1024 * 2048 * 10;

// input file to be encrypted
#define INPUT_FILE "file.bin"

// output file with the attached x86 polymorphic decryptor and the encrypted data
#define OUTPUT_FILE "file_encrypted.bin"

int main(int argc, char* argv[])
{
    // open file to encrypt its content
    std::ifstream inputFile(INPUT_FILE, std::ios::binary);

    if (!inputFile.is_open())
    {
        printf("Cannot open %s input file!\n", INPUT_FILE);
        _getch();
        return 1;
    }

    // get file size
    inputFile.seekg(0, std::ios::end);
    std::streamsize fileSize = inputFile.tellg();
    inputFile.seekg(0, std::ios::beg);

    // allocate memory for cInputBuffer based on the file size
    std::vector<unsigned char> cInputBuffer(fileSize);

    // read the content of the file into cInputBuffer
    inputFile.read(reinterpret_cast<char*>(cInputBuffer.data()), fileSize);
    inputFile.close();

    // load Poly engine from the DLL library
    #ifdef USE_POLY_DLL

    HINSTANCE hDll = LoadLibrary("poly.dll");

    if (hDll == nullptr)
    {
        printf("Cannot load poly.dll library!\n");
        _getch();

        return 1;
    }

    POLY_PROC _poly_proc = (POLY_PROC)GetProcAddress(hDll, "_poly");

    if (hDll == nullptr)
    {
        printf("Cannot find '_poly' function in poly.dll library!\n");
        _getch();

        return 1;
    }

    #endif

    // allocate memory buffer for the encrypted block (it has to be executable)
    PVOID lpDecryptor = VirtualAlloc(nullptr, POLY_DECRYPTOR_SIZE + fileSize, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);

    // work memory buffer (same size, also it has to be executable)
    PVOID lpWorkMem = VirtualAlloc(nullptr, POLY_DECRYPTOR_SIZE + fileSize, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);

    //
    // setup Poly engine parameters
    //

    // randomize parameters (remember, more means you need to increase
    // the size of the lpDecryptor & lpWorkMem buffers)

    // minimal number of encryption commands
    unsigned int iMinEncryptionCommands = RND_RANGE(10, 50);

    // maximal number of encryption commands
    unsigned int iMaxEncryptionCommands = RND_RANGE(iMinEncryptionCommands, iMinEncryptionCommands + 10);

    // number of junks per decryptor single command
    unsigned int iGarbage = 0; RND_RANGE(10, 50);

    // force decryptor size - if this value is set, Poly engine will try to generate
    // decryptor body that is exactly this size, it will modify other parameters on
    // the fly if the generated code is too small or too big and re-generate the code
    // again to meet your exact criteria (please make sure the working buffers
    // lpDecryptor and lpWorkMem are bigger than this value)
    unsigned int iForceDecryptorSize = 0;

    // if this parameter is set, polymorphic decryption code will use it to calculate
    // the address of the encrypted data in memory, this pointer is relative to the
    // current position of the decryptor code in the memory (it can be positive or
    // negative)
    unsigned int iRelativeDataOutputOffset = 0;

    // flags
    unsigned int iOptions = 0;

    // POLY_SAVE_REGS - save all registers before the call and restore them after the call
    iOptions |= POLY_SAVE_REGS;

    // POLY_SAVE_FLAGS - save all CPU flags before the call and restore them after the call
    iOptions |= POLY_SAVE_FLAGS;

    // POLY_ATTACH_DATA - attach data to the decryptor body, decryption will overwrite
    // decryptor body and after decryption lpDecryptor will also be a pointer to the
    // decrypted buffer
    //
    // if this flag is not used, encrypted data has to be located on static VA address
    // declared in lpVA parameter or declared via relative address in iRelativeDataOutputOffset
    // parameter
    iOptions |= POLY_ATTACH_DATA;

    // POLY_RETURN - put a return instruction (RET) at the end of the decryption function,
    // so the decryptor returns to the caller, polymorphic decryptor can be inlined
    // between other code or some other code can be added after its body so it may or
    // may not return to the caller
    iOptions |= POLY_RETURN;

    // POLY_SET_REGS - return exact values in CPU registers after decryption (it must be
    // defined in POLY_REGS structure)
    iOptions |= POLY_SET_REGS;

    // return value in EAX register
    iOptions |= POLY_SET_EAX;

    // and lets say it should return some other value in EDX register after the call
    iOptions |= POLY_SET_EDX;

    // output registers values (fill out only those marked to be returned)
    POLY_REGS prPolyRegs = { 0 };

    // fill out the EAX register with a value that should be returned after
    // the decryption, in this example lets set it to the size of the decrypted
    // buffer (you can set anything)
    prPolyRegs.regEax = sizeof(cInputBuffer);

    // sample value to be returned in EDX register after the call (view it
    // with a debugger)
    prPolyRegs.regEdx = 0xDEADBEEF;

    // encrypt data & generate polymorphic decryptor
    #ifdef USE_POLY_DLL
    unsigned int dwOutputSize = _poly_proc(
    #else
    unsigned int dwOutputSize = _poly(
    #endif
        lpDecryptor,              // output buffer for polymorphic code
        cInputBuffer.data(),      // output data buffer (can be the same as lpInput)
        cInputBuffer.data(),      // input data buffer
        fileSize,                 // input data size
        0,                        // virtual address of a data to be decrypted (optional)
        iMaxEncryptionCommands,   // max. number of real encryption instructions
        iMinEncryptionCommands,   // min. number of real encryption instructions
        iGarbage,                 // number of junks per instruction
        iForceDecryptorSize,      // force decryptor size (optional)
        iRelativeDataOutputOffset,// relative output data offset (optional)
        &prPolyRegs,              // output registers (optional)
        iOptions,                 // additional options
        lpWorkMem,                // work memory
        GetTickCount()            // random seed for the internal randomizer
    );

    // validate output size (decryptor size in bytes)
    if (dwOutputSize != 0)
    {
        std::ofstream outputFile(OUTPUT_FILE, std::ios::binary | std::ios::trunc);
        if (!outputFile.is_open())
        {
            printf("Error saving polymorphic loader with encrypted data to a file %s\n", OUTPUT_FILE);
            _getch();
            return 1;
        }

        outputFile.write((const char *)lpDecryptor, dwOutputSize);
        outputFile.close();
    }
    else
    {
        printf("Polymorphic engine failed!\n");
        _getch();

        return 1;
    }

    // relese the memory
    VirtualFree(lpDecryptor, 0, MEM_RELEASE);
    VirtualFree(lpWorkMem, 0, MEM_RELEASE);

    printf("File %s successfully encrypted to %s\n", INPUT_FILE, OUTPUT_FILE);

    _getch();

    return 0;
}

Wymagania