Пишем упаковщик по шагам. Шаг третий. Распаковываем.

//Структура, хранящая информацию об упакованном файлеstruct packed_file_info
{
  BYTE number_of_sections;//Количество секций в оригинальном файле
  DWORD size_of_packed_data;//Размер упакованных данных
  DWORD size_of_unpacked_data;//Размер оригинальных данных
 
  DWORD load_library_a;//Адрес процедуры LoadLibraryA из kernel32.dll
  DWORD get_proc_address;//Адрес процедуры GetProcAddress из kernel32.dll
  DWORD end_of_import_address_table;//Конец IAT};

//....//Устанавливаем для нее необходимый виртуальный размер
      image.set_section_virtual_size(added_section, total_virtual_size);//....
 
      std::cout<<"Creating imports..."<< std::endl;
 
      //Создаем импорты из библиотеки kernel32.dll
      pe_base::import_library kernel32;
      kernel32.set_name("kernel32.dll");//Выставили имя библиотеки
 
      //Создаем импортируемую функцию
      pe_base::imported_function func;
      func.set_name("LoadLibraryA");//Ее имя
      kernel32.add_import(func);//Добавляем ее к библиотеке
 
      //И вторую функцию
      func.set_name("GetProcAddress");
      kernel32.add_import(func);//Тоже добавляем
 
      //Получаем относительный адрес (RVA) поля load_library_a//нашей структуры packed_file_info, которую мы расположили в самом//начале добавленной секции, помните?
      DWORD load_library_address_rva = pe_base::rva_from_section_offset(added_section,
        offsetof(packed_file_info, load_library_a));
 
      //Устанавливаем этот адрес как адрес//таблицы адресов импорта (import address table)
      kernel32.set_rva_to_iat(load_library_address_rva);
 
      //Создаем список импортируемых библиотек
      pe_base::imported_functions_list imports;//Добавляем к списку нашу библиотеку
      imports.push_back(kernel32);
 
      //Настроим пересборщик импортов
      pe_base::import_rebuilder_settings settings;//Original import address table нам не нужна (пояснения ниже)
      settings.build_original_iat(false);//Будем переписывать IAT именно по тому адресу,//который указали (load_library_address_rva)
      settings.save_iat_and_original_iat_rvas(true, true);//Расположим импорты прямо за концом упакованных данных
      settings.set_offset_from_section_start(added_section.get_raw_data().size());//Пересоберем импорты
      image.rebuild_imports(imports, added_section, settings);

#pragma once#include <Windows.h>#pragma pack(push, 1)//Структура, хранящая информацию об упакованной секцииstruct packed_section
{char name[8];//Имя секции
  DWORD virtual_size;//Виртуальный размер
  DWORD virtual_address;//Виртуальный адрес (RVA)
  DWORD size_of_raw_data;//Размер "сырых" данных
  DWORD pointer_to_raw_data;//Файловое смещение сырых данных
  DWORD characteristics;//Характеристики секции};
 
//Структура, хранящая информацию об упакованном файлеstruct packed_file_info
{
  BYTE number_of_sections;//Количество секций в оригинальном файле
  DWORD size_of_packed_data;//Размер упакованных данных
  DWORD size_of_unpacked_data;//Размер оригинальных данных
 
  DWORD load_library_a;//Адрес процедуры LoadLibraryA из kernel32.dll
  DWORD get_proc_address;//Адрес процедуры GetProcAddress из kernel32.dll
  DWORD end_of_import_address_table;//Конец IAT};#pragma pack(pop)

//Заголовочный файл с нашими структурами#include "structs.h"

//Заголовочный файл с параметрами распаковщика#include "../unpacker/parameters.h"

//Подключаем файл со структурами из проекта упаковщика#include "../simple_pe_packer/structs.h"//Создадим функцию без пролога и эпилогаvoid __declspec(naked) unpacker_main(){//Пролог вручную
  __asm
  {
    push ebp;
    mov ebp, esp;
    sub esp, 128;}
 
  //... описано далее ...//
 
  //Эпилог вручную
  _asm
  {
    leave;
    ret;}}

//Адрес загрузки образаunsignedint original_image_base;//Относительный адрес первой секции,//в которую упаковщик кладет информацию для//распаковщика и сами упакованные данныеunsignedint rva_of_first_section;
 
  //Эти инструкции нужны только для того, чтобы//заменить в билдере распаковщика адреса на реальные
  __asm
  {
    mov original_image_base, 0x11111111;
    mov rva_of_first_section, 0x22222222;}

//Получаем указатель на структуру с информацией,//которую для нас заботливо приготовил упаковщикconst packed_file_info* info;//Она находится в самом начале//первой секции упакованного файла
  info =reinterpret_cast<const packed_file_info*>(original_image_base + rva_of_first_section);
 
  //Два тайпдефа прототипов функций LoadLibraryA и GetProcAddresstypedef HMODULE (__stdcall* load_library_a_func)(constchar* library_name);typedef INT_PTR (__stdcall* get_proc_address_func)(HMODULE dll, constchar* func_name);
 
  //Считаем их адреса из структуры packed_file_info//Их нам туда подложил загрузчик
  load_library_a_func load_library_a;
  get_proc_address_func get_proc_address;
  load_library_a =reinterpret_cast<load_library_a_func>(info->load_library_a);
  get_proc_address =reinterpret_cast<get_proc_address_func>(info->get_proc_address);

//Создаем буфер на стекеchar buf[32];//user32.dll*reinterpret_cast<DWORD*>(&buf[0])='resu';*reinterpret_cast<DWORD*>(&buf[4])='d.23';*reinterpret_cast<DWORD*>(&buf[8])='ll';
 
  //Загружаем библиотеку user32.dll
  HMODULE user32_dll;
  user32_dll = load_library_a(buf);
 
  //Тайпдеф прототипа функции MessageBoxAtypedefint(__stdcall* message_box_a_func)(HWND owner, constchar* text, constchar* caption, DWORD type);
 
  //MessageBoxA*reinterpret_cast<DWORD*>(&buf[0])='sseM';*reinterpret_cast<DWORD*>(&buf[4])='Bega';*reinterpret_cast<DWORD*>(&buf[8])='Axo';
 
  //Получаем адрес функции MessageBoxA
  message_box_a_func message_box_a;
  message_box_a =reinterpret_cast<message_box_a_func>(get_proc_address(user32_dll, buf));
 
  //Hello!*reinterpret_cast<DWORD*>(&buf[0])='lleH';*reinterpret_cast<DWORD*>(&buf[4])='!!o';
 
  //Выводим месадж бокс
  message_box_a(0, buf, buf, MB_ICONINFORMATION);

#include <iostream>#include <fstream>#include <vector>#include <string>#include <iomanip>//Заголовочный файл библиотеки для работы с PE-файлами#include <pe_32_64.h>
 
//Директивы для линкования с собранной библиотекой PE#ifndef _M_X64#ifdef _DEBUG#pragma comment(lib, "../../Debug/pe_lib.lib")#else#pragma comment(lib, "../../Release/pe_lib.lib")#endif#else#ifdef _DEBUG#pragma comment(lib, "../../x64/Debug/pe_lib.lib")#else#pragma comment(lib, "../../x64/Release/pe_lib.lib")#endif#endif
 
int main(int argc, char* argv[]){//Подсказка по использованиюif(argc !=3){
    std::cout<<"Usage: unpacker_converter.exe unpacker.exe output.h"<< std::endl;return0;}
 
  //Открываем файл unpacker.exe - его имя//и путь к нему хранятся в массиве argv по индексу 1
  std::ifstream file(argv[1], std::ios::in| std::ios::binary);if(!file){//Если открыть файл не удалось - сообщим и выйдем с ошибкой
    std::cout<<"Cannot open "<< argv[1]<< std::endl;return-1;}
 
  try{
    std::cout<<"Creating unpacker source file..."<< std::endl;
 
    //Пытаемся открыть файл как 32-битный PE-файл//Последние два аргумента false, потому что нам не нужны//"сырые" данные привязанных импортов файла и //"сырые" данные отладочной информации//При упаковке они не используются, поэтому не загружаем эти данные
    pe32 image(file, false, false);
 
    //Получаем список секций распаковщика
    pe_base::section_list& unpacker_sections = image.get_image_sections();//Убедимся, что она одна (так как в нем нет импортов, релокаций)if(unpacker_sections.size()!=1){
      std::cout<<"Incorrect unpacker"<< std::endl;return-1;}
 
    //Получаем ссылку на данные этой секции
    std::string& unpacker_section_data = unpacker_sections.at(0).get_raw_data();//Удаляем нулевые байты в конце этой секции,//которые компилятор добавил для выравнивания
    pe_base::strip_nullbytes(unpacker_section_data);
 
    //Открываем выходной файл для записи h-файла//Его имя хранится в argv[2]
    std::ofstream output_source(argv[2], std::ios::out| std::ios::trunc);
 
    //Начинаем формировать исходный код
    output_source << std::hex<<"#pragma once"<< std::endl<<"unsigned char unpacker_data[] = {";//Текущая длина считанных данныхunsignedlong len =0;//Общая длина данных секции
    std::string::size_type total_len = unpacker_section_data.length();
 
    //Для каждого байта данных...for(std::string::const_iterator it = unpacker_section_data.begin(); it != unpacker_section_data.end();++it, ++len){//Добавляем необходимые переносы, чтобы//получившийся код был читаемымif((len %16)==0)
        output_source << std::endl;
 
      //Записываем значение байта
      output_source
        <<"0x"<< std::setw(2)<< std::setfill('0')<<static_cast<unsignedlong>(static_cast<unsignedchar>(*it));
 
      //И, если необходимо, запятуюif(len != total_len -1)
        output_source <<", ";}
 
    //Конец кода
    output_source <<" };"<< std::endl;}catch(const pe_exception& e){//Если по какой-то причине открыть его не удалось//Выведем текст ошибки и выйдем
    std::cout<< e.what()<< std::endl;return-1;}
 
  return0;}

#pragma onceunsignedchar unpacker_data[]={0x55, 0x8b, 0xec, 0x81, 0xec, 0x80, 0x00, 0x00, 0x00, 0xc7, 0x45, 0xfc, 0x11, 0x11, 0x11, 0x11, 
0xc7, 0x45, 0xf8, 0x22, 0x22, 0x22, 0x22, 0x8b, 0x45, 0xfc, 0x03, 0x45, 0xf8, 0x8b, 0x48, 0x09, 
0x8b, 0x70, 0x0d, 0x8d, 0x45, 0xd8, 0x50, 0xc7, 0x45, 0xd8, 0x75, 0x73, 0x65, 0x72, 0xc7, 0x45, 
0xdc, 0x33, 0x32, 0x2e, 0x64, 0xc7, 0x45, 0xe0, 0x6c, 0x6c, 0x00, 0x00, 0xff, 0xd1, 0x8d, 0x4d, 
0xd8, 0x51, 0x50, 0xc7, 0x45, 0xd8, 0x4d, 0x65, 0x73, 0x73, 0xc7, 0x45, 0xdc, 0x61, 0x67, 0x65, 
0x42, 0xc7, 0x45, 0xe0, 0x6f, 0x78, 0x41, 0x00, 0xff, 0xd6, 0x6a, 0x40, 0x8d, 0x4d, 0xd8, 0x51, 
0x51, 0x6a, 0x00, 0xc7, 0x45, 0xd8, 0x48, 0x65, 0x6c, 0x6c, 0xc7, 0x45, 0xdc, 0x6f, 0x21, 0x00, 
0x00, 0xff, 0xd0, 0xc9, 0xc3};

"..\unpacker_converter.exe" "..\Release\unpacker.exe" "..\simple_pe_packer\unpacker.h"

copy /Y "..\$(Configuration)\unpacker_converter.exe" "..\unpacker_converter.exe"

#pragma once
 
staticconstunsignedint original_image_base_offset =0x0C;staticconstunsignedint rva_of_first_section_offset =0x13;

//Тело распаковщика (автогенеренное)#include "unpacker.h"

//В будущем тут будет код распаковщика и что-то еще
      unpacker_section.get_raw_data()="Nothing interesting here...";

//...{//Получаем ссылку на данные секции распаковщика
        std::string& unpacker_section_data = unpacker_section.get_raw_data();//Записываем туда код распаковщика//Этот код хранится в автогенеренном файле//unpacker.h, который мы подключили в main.cpp
        unpacker_section_data = std::string(reinterpret_cast<constchar*>(unpacker_data), sizeof(unpacker_data));//Записываем по нужным смещениям адрес//загрузки образа*reinterpret_cast<DWORD*>(&unpacker_section_data[original_image_base_offset])= image.get_image_base_32();//и виртуальный адрес самой первой секции упакованного файла,//в которой лежат данные для распаковки и информация о них//В самом начале это секции, как вы помните, лежит//структура packed_file_info*reinterpret_cast<DWORD*>(&unpacker_section_data[rva_of_first_section_offset])= image.get_image_sections().at(0).get_virtual_address();}
 
      //Добавляем и эту секциюconst pe_base::section& unpacker_added_section = image.add_section(unpacker_section);//Выставляем новую точку входа - теперь она указывает//на распаковщик, на самое его начало
      image.set_ep(image.rva_from_section_offset(unpacker_added_section, 0));//...