// Шифровщик исполняемых файлов
// Crypter v3.1 (C) SLESH 2007
// E-MAIL: SLESH-2000@mail.ru
// ICQ: 266-334-734
// WMZ: Z671833489051
// WMR: R156568501269

program Crypt;

{$APPTYPE CONSOLE}

uses
 windows,sysutils;
type
pe_head=record // структура PE заголовка без первого элемента
//Signature:dword;
CPU_Type:word;
Num_of_Objects:word;
Time_Date_Stamp:dword;
Pointer_to_COFF_table:dword;
COFF_table_size:dword;
NT_Header_Size:word;
Flags:word;
Magic:word;
Link_Major:byte;
Link_Minor:byte;
Size_of_Code:dword;
Size_of_Init_Data:dword;
Size_of_UnInit_Data:dword;
Entry_point_RVA:dword;
Base_of_Code:dword;
Base_of_Data:dword;
Image_Base:dword;
Object_Align:dword;
File_Align:dword;
OS_Major:word;
OS_Minor:word;
USER_Major:word;
USER_Minor:word;
SubSys_Major:word;
SubSys_Minor:word;
Reserved:dword;
Image_Size:dword;
Header_Size:dword;
File_CheckSum:dword;
SubSytem:word;
DLL_Flags:word;
Stack_Reserve_Size:dword;
Stack_Commit_Size:dword;
Heap_Reserve_Size:dword;
Heap_Comit_Size:dword;
Loader_Flags:dword;
Num_of_RVA_and_Sizes:dword;
Export_Table_RVA:dword;
Export_Data_Size:dword;
Import_Table_RVA:dword;
Import_Data_Size:dword;
Resource_Table_RVA:dword;
Resource_Data_Size:dword;
Exception_Table_RVA:dword;
Exception_Data_Size:dword;
Security_Table_RVA:dword;
Security_Data_Size:dword;
Fix_Ups_Table_RVA:dword;
Fix_Ups_Data_Size:dword;
Debug_Table_RVA:dword;
Debug_Data_Size:dword;
Image_Description_RVA:dword;
Description_Data_Size:dword;
Machine_Specific_RVA:dword;
Machnine_Data_Size:dword;
TLS_RVA:dword;
TLS_Data_Size:dword;
Load_Config_RVA:dword;
Load_Config_Data_Size:dword;
Reserved1:array[1..8] of byte;
IAT_RVA:dword;
IAT_Data_Size:dword;
Reserved2:array[1..24] of byte;
end;

Section_table=record // структура таблица секции
Object_Name:array[1..8] of char;
Virtual_Size:dword;
Section_RVA:dword;
Physical_Size:dword;
Physical_Offset:dword;
Reserved:array[1..12] of byte;
Object_Flags:dword;
end;

var
CryptCode_start:packed record // Начало расшифровщика
c0:byte; // случайное число
c1:array[1..28] of char; // массив для ASM инструкций
ret_adr:dword; // адресс старой точки входа
end;

CryptCode_decoder:packed record // расшифровщик секции
c1:byte; // ASM инструкция
start_adr:dword; // адрес начала расшировки
c2:byte; // ASM инструкция
decrypt_size:dword; // Адресс конца расшифровки
c3:array[1..8] of byte; // Массив ASM иструкций
end;

CryptCode_end:packed record // Конец расшифровщика
c1:array[1..6] of char; // массив ASM инструкций
end;

f:thandle;// дискриптор файла
c:byte; // временная переменная
he:pe_head; // заголовок PE
st:array[1..20] of Section_table; // массив стаблиц секций
MPO:dword; // номер физически последней секции
PE_ofs:dword; // смещение PE заголовка относительно начала файла
newstart:dword; // новый адрес точки входа
maxz:dword; // максимальное смещение для вставляемой секции
file_in,file_out:string; // имя сходного и выходного файла
crypt_byte:byte; // байт для шифрования
x,y:dword; // для организации цикла
number_of_crypt_section:byte=0; // кол-вл закриптованных секций
name:string; // имя секции
no_crypt:array[1..10] of boolean;  // массим запретов на криптование секции
fils:dword;
label m1,m2;  // метки :) 
begin
file_in:=paramstr(1);  // получить имя входного файла
file_out:=paramstr(2);  // получить имя выходного файла

for x:=1 to 10 do no_crypt[x]:=false;  // первоначально можно криптовать все секции
x:=3;  // начальный параметр
while paramstr(x)<>'' do  // перебирать параметры пока они есть
 begin
  no_crypt[strtoint(paramstr(x))]:=true;  // запись запрешения криптования
  inc(x);  // следующий параметр
 end;

if (file_in='') or (file_out='') then  // если входной или выходной файл не указан
 begin  // вывести справку
  writeln('Crypter v3.1 (C) SLESH 2007');
  writeln('E-MAIL: SLESH-2000@mail.ru');
  writeln('ICQ: 266-334-734');
  writeln('WMZ: Z671833489051');
  writeln('WMR: R156568501269');
  writeln;
  writeln('Usage: Crypter.exe file_in file_out [non_crypt] [non_crypt] ...');
  writeln('file_in - program for crypting');
  writeln('file_out - output file');
  writeln('non_crypt - section no will be crypted');
  exit;
 end;
 
if not fileexists(file_in) then  // если входной файл не найден
 begin
  write('[-] Input file not found');
  exit;
 end;
deletefile(file_out);  // удалить выходной файл. На всякий случай :)

if fileexists(file_out) then  // Если выходной файл не удалился
 begin
  writeln('[-] Can not create output file');
  exit;
 end;

copyfile(Pansichar(file_in),Pansichar(file_out),true);  // копирование программы

if not fileexists(file_out) then  // если ну удалось скопировать
 begin
  writeln('[-] Can not create output file');
  exit;
 end;

writeln('[+] Output file is created');

f:=fileopen(file_out,fmOpenReadWrite);  // открытие скопированного файла на чтение\запись
if f=INVALID_HANDLE_VALUE then  // если не удалось открыть
 begin
   writeln('[-] Can not open output file for crypting');
   exit;
 end;
fils:=Windows.GetFileSize(f,nil);
writeln('[+] Output file open for crypting');

pe_ofs:=0;  // счеткик смещения

// проверка программы на MZ сигнатуру 
fileread(f,c,1);  // считать один байт
if c<>ord('M') then  // если это не M
 begin
  writeln('[-] Input file is not correct');
  exit;
 end;
fileread(f,c,1);  // считать один байт
if c<>ord('Z') then  // если это не Z
 begin
  writeln('[-] Input file is not correct');
  exit;
 end;

 // поиск PE заголовка
m1:
repeat
fileread(f,c,1);
inc(pe_ofs);
until c=ord('P');
fileread(f,c,1);
inc(pe_ofs);
if c<>ord('E') then goto m1;
writeln('[+] PE head is found');
writeln('    PE head offset = ',pe_ofs);

fileread(f,c,1);  // считать оставшиеся 2 байт асигнатуры PE заголовка
fileread(f,c,1);

fileread(f,he,sizeof(he));  // считать PE заголовок

writeln('[+] PE head read OK');
writeln('    Section count = ',he.Num_of_Objects);

for x:=1 to he.Num_of_Objects do fileread(f,st[x],sizeof(st[x]));  // считать все таблицы секций
writeln('[+] Read sections OK');

 // поиск физически последней секции
MPO:=1;
for x:=1 to he.Num_of_Objects do  // перебрать все секции
if st[x].Physical_Offset>st[MPO].Physical_Offset then MPO:=x;  // если физической смещение больше

writeln('    Old Entry_point_RVA = '+inttohex(he.Entry_point_RVA+he.Image_Base,8));

randomize;
 // формирование начального кода расшифровщика
CryptCode_start.c0:=random(256);
CryptCode_start.c1:=#$68#$FF#$64#$24#$F0#$68#$58#$58#$58#$58#$FF#$D4#$50#$8B#$40#$F2#$05#$B0#$95#$F6#$95#$0F#$85#$01#$81#$BB#$FF#$68;
CryptCode_start.ret_adr:=he.Entry_point_RVA+he.Image_Base;
CryptCode_decoder.c1:=$BF; // mov edi,
CryptCode_decoder.c2:=$B9; // mov ecx,
CryptCode_decoder.c3[1]:=$80; //--
CryptCode_decoder.c3[2]:=$37; //m1: xor [edi],byte 99h
CryptCode_decoder.c3[3]:=255;
CryptCode_decoder.c3[4]:=$47; // inc edi
CryptCode_decoder.c3[5]:=$39; // --
CryptCode_decoder.c3[6]:=$CF; // cmp edi,ecx
CryptCode_decoder.c3[7]:=$75; // --
CryptCode_decoder.c3[8]:=$F8; // jne m1
CryptCode_end.c1:=#$E8#$00#$00#$00#$00#$C3;

fileseek(f,0,2);  // переместиться в конец файла
filewrite(f,CryptCode_start,sizeof(CryptCode_start));  //записать начальный код расшифровщика
writeln('[+] Decrypt code write OK');
writeln('    Crypting...');

for y:=1 to he.Num_of_Objects do  // перебрать все секции
 begin
  name:=st[y].Object_Name;  // получить имя секции
  repeat
  delete(name,pos(#0,name),1);  // удаление символа #0 из имени
  until (pos(#0,name)=0) or (length(name)=0);  // удалить все символы #0
  write('    Found section: '+name+'.......');
  if no_crypt[y]=true then  // если указано в параметрах запрещение шифрование это секции
    begin
    writeln('skipped: no crypt');
    goto m2; // переход на следующую секцию
   end;
  if st[y].Physical_Size=0 then  // если физический размер секции = 0 
   begin
    writeln('skipped: zero size');
    goto m2;
   end;
    // проверка на секции которые нельзя шифровать
  if (name='.idata') then
   begin
    writeln('skipped: import data');
    goto m2;
   end;
  if (name='.rsrc') then
   begin
    writeln('skipped: resource data');
    goto m2;
   end;
  if (name='.edata') then
   begin
    writeln('skipped: export data');
    goto m2;
   end;
  if (name='.reloc') then
   begin
    writeln('skipped: config table');
    goto m2;
   end;
  if (name='.rdata') then
   begin
    writeln('skipped: debug information');
    goto m2;
   end;
  if (pos('UPX',name)<>0) then
   begin
    writeln('skipped: UPX packet');
    goto m2;
   end;
 // если программа дошла до этой точки, то значит секцию можно шифровать
  inc(number_of_crypt_section);  // увеличить счетчик зашифрованных секций
  randomize;
  crypt_byte:=random(255)+1;  // генерация байта для шифрования
  CryptCode_decoder.c3[3]:=crypt_byte;  // запись в расшифровщик байта шифрования
   for x:=0 to st[y].Physical_Size-1 do  // перебрать все символы шифрумой секции
    begin
     fileseek(f,st[y].Physical_Offset+x,0);  // переход на символ
     fileread(f,c,1);  // чтение символа
     c:=c xor crypt_byte;  // шифрование
     fileseek(f,st[y].Physical_Offset+x,0);  // переход обратно
     filewrite(f,c,1);  // записаь символа
   end;
  st[y].Object_Flags:=st[y].Object_Flags or $80000000;  // Установка флага разрешения записисекцию
  fileseek(f,pe_ofs+sizeof(he)+sizeof(st[1])*(y-1)+$28,0);  // переход на смещение флагов секции
  filewrite(f,st[y].Object_Flags,4);  // запись флага
  fileseek(f,0,2);  // переход к конец файла
  CryptCode_decoder.start_adr:=he.Image_Base+st[y].Section_RVA;  // запись начального адреса расшифровки
  CryptCode_decoder.decrypt_size:=he.Image_Base+st[y].Section_RVA+st[y].Physical_Size;  // записаь конечного адреса расшифровки
  CryptCode_decoder.c3[3]:=crypt_byte;  // запись байта шифрования
  filewrite(f,cryptcode_decoder,sizeof(cryptcode_decoder));  // запись расшифровщика в файл
  writeln('crypted');
m2:
end;

filewrite(f,cryptcode_end,sizeof(cryptcode_end));  // запись конца расшифровщика

writeln('[+] Crypting OK');
writeln('    ',number_of_crypt_section,' sections is crypted');

maxz:=st[MPO].Physical_Size;  // поиск максимального смещения
if st[MPO].Virtual_Size>maxz then maxz:=st[MPO].Virtual_Size;

newstart:=st[MPO].Section_RVA+maxz;  // вычисление адреса новой точки входа
if newstart mod he.Object_Align <>0 then newstart:=newstart - (newstart mod he.Object_Align)+he.Object_Align;  // выравнение

 // создание новой секции
st[20].Object_Name:='SCRYPT'+#0#0;  // имя
st[20].Virtual_Size:=he.Object_Align;  // виртуальный размер
st[20].Section_RVA:=newstart;  // виртуально смещение
st[20].Physical_Size:=sizeof(CryptCode_start)+sizeof(cryptcode_decoder)*number_of_crypt_section+sizeof(cryptcode_end);  //физический размер
//st[20].Physical_Offset:=st[MPO].Physical_Size+st[MPO].Physical_Offset;  // физической смещение
st[20].Physical_Offset:=fils;  // физической смещение
st[20].Object_Flags:=$60000020;  // флаг разрешения исполнения кода

inc(newstart);  // т.к. код расшифровщика находится по смещение 1 

fileseek(f,pe_ofs+$28,0);  //
filewrite(f,newstart,4);  // запись новой точки входа
writeln('    New Entry_point_RVA = '+inttohex(newstart+he.Image_Base,8));

he.Image_Size:=he.Image_Size+he.Object_Align;  // выравнений виртуального размера
fileseek(f,pe_ofs+$50,0);      //
filewrite(f,he.Image_Size,4); // запись ногово виртуального размера

fileseek(f,pe_ofs+sizeof(he)+4+sizeof(st[1])*he.Num_of_Objects,0);  //
filewrite(f,st[20],sizeof(st[20]));                                // запись новой секции 

inc(he.Num_of_Objects);  // увеличение числа объектов
fileseek(f,pe_ofs+6,0);             //
filewrite(f,he.Num_of_Objects,2);  // запись нового числа объектов
fileclose(f);  // закрытие файла
writeln('[+] Done');
end.

use32
push 0f02464ffh
push 58585858h
call esp
push eax
mov eax,[eax-$0e]
add eax,$95f695b0
jnz $-00447ef9h
push 11111111h
mov edi,22222222h
mov ecx,33333333h
m1:
xor [edi],byte 99h
inc edi
cmp edi,ecx
jne m1
call +$00000000
ret