I. Introduction

Shifu est un cheval de Troie bancaire découvert pour la première fois en 2015. Shifu est basé sur le code source Shiz qui incorporait les techniques utilisées par Zeus. Les attaquants utilisent Shifu pour voler les informations d'identification des sites Web de banque en ligne du monde entier.

Nous allons dans cette article parlé surtout des hashs utilisés dans ce malware pour la détection s'il est entraîne d'être analysé utilisé dans l'une de ses technique d'évasion.

Il utilise une technique courante pour rapidement détecter "Sandboxie" et "Avast"

Shifu vérifie si le module snxhk.dll (Avast) ou sbiedll.dll (Sandboxie) est présent dans son propre espace de processus en appelant GetModuleHandleA(...) et exécute une boucle Sleep(...) infinie si un handle est retourné.

Il utilise également la détection par nom de processus en cours d'exécution au sein de l'hôte.

Pour cela, Il énumère les noms de processus en cours d'exécution sur l'hôte, les convertit en minuscules et calcule les hachages CRC32 de ces noms et les compare à une liste fixe qu'il embarque dans son code.

Toutes les astuces anti-analyse suivantes ne sont utilisées que si Shifu est exécuté sur une machine Windows 32 bits (pas de processus Wow64).

II. Référence des Hashs Api

A partir d'information disparate existant sur le web, nous avons regroupé des hachs utilisés par le ransomware.

Pour la partie recherche de processus en cours d'exécution pour effectuer l'évasion

Nous avons mis en Gras, les hash que nous avons pu déterminer en plus.

Hash	Nom des processus possibles
0x99DD4432	? => recherche par croisement => vmwareuser.exe
0x1F413C1F	vmwaretray.exe
0x6D3323D9	vmusrvc.exe
0x3BFFF885	vmsrvc.exe
0x64340DCE	? => comparaison avec les process de Emotet => vboxservice.exe
0x63C54474	vboxtray.exe
0x2B05B17D	? => test des process du monde VDI d'évasion => xenservice.exe
0xF725433E	?
0x77AE10F7	? => recherche par croisement => wireshark.exe
0xCE7D304E	dumpcap.exe
0xAF2015F2	ollydbg.exe
0x31FD677C	importrec.exe
0x6E9AD238	petools.exe
0xE90ACC42	idag.exe
0x4231F0AD	sysanalyzer.exe
0xD20981E0	sniff_hit.exe
0xCCEA165E	scktool.exe
0xFCA978AC	proc_analyzer.exe
0x46FA37FB	hookexplorer.exe
0xEEBF618A	multi_pot.exe
0x06AAAE60	idaq.exe
0x5BA9B1FE	procmon.exe
0x3CE2BEF3	regmon.exe
0xA945E459	procexp.exe
0x877A154B	peid.exe
0x33495995	autoruns.exe
0x68684B33	autorunsc.exe
0xB4364A7A	?
0x9305F80D	imul.exe
0xC4AAED42	emul.exe
0x14078D5B	apispy.exe
0x7E3DF4F6	?
0xD3B48D5B	hookanaapp.exe
0x332FD095	fortitracer.exe
0x2D6A6921	?
0x2AAA273B	joeboxserver.exe
0x777BE06C	joeboxcontrol.exe
0x954B35E8	?
0x870E13A2	? => Suite au brut force via le tools ce hash CRC32 correspond à "tshark.exe"
0xD2EFC6C4	python.exe

Nous avons croisé les noms de processus avec ce du malware Emotet d'un précédent article

Nous regardons les processus qui ne sont pas référencés et listés dont "vboxservice.exe" , nous les avons passés dans notre outil de calcule de hash pour l'algorithme Hash CRC32.

Attention dans le cas de Shifu, il utilise les lowcases sensitive pour les noms de processus

Nous trouvons donc l'un des hashs de la liste 0x6434DCE

Hash	Nom des processus possibles
0x64340DCE	? => Suite au croisement avec Emotet et ses noms des processus ce hash CRC32 correspond à "vboxservice.exe"

Nous avons donc mis à jour l'un de nos calculateurs de hash pour shifu et intégré la partie recherche de hash par force brut sur le nom de programme utilisé pour définir l'évasion lorsque l'un de ses process tourne sur le poste. comme cela fait pour trouvé les hashs du malware Emotet.

Dont voici la capture écran de l'outil de l'époque mise à jour.

Cela pour essayer de trouver les différents autres hashs , mais la méthode est consommatrice de temps. Nous avons laissé tourné quelque heures. Mais n'a pas donnée de bon résultat

Hash	Nom des processus possibles
0x2B05B17D	gfftjbl.exe
0xF725433E	?
0x77AE10F7	?
0xB4364A7A	ocxqsxb.exe slkttbt.exe
0x7E3DF4F6	pjzbhz.exe ecmmtgu.exe upxdrse.exe
0x2D6A6921	gvhqjub.exe
0x954B35E8	bisfdad.exe nuujeob.exe rzfobut.exe
0x870E13A2	? => Suite au brut force via le tools ce hash CRC32 correspond à "tshark.exe"

Nous n'avons pas poussé, plus l'investigation, il reste donc 4 hashs sans résultat.

III. Algorithme de création des hashs

Nous mettons l'algorithme un algorithme de hash CRC32 (lowercase) en C++ en dessous:

DWORD CalcHash_CRC32_lowercase_C_V5(char *data)

{

unsigned __int32 r = 0xFFFFFFFFUL;

int i, b;

i = 0;

while(data[i] != 0)

{

char currentChar = data[i];

// Partie si on souhaite convertir A..Z en a..z LowCase

if(currentChar >= 0x41 && currentChar <=0x5A)currentChar += 0x20;

r ^= currentChar;

for (b = 0; b < 8; ++b)

{

if ((unsigned __int8) r & 1)

r = (r >> 1) ^ 0xEDB88320UL;

else

r >>= 1;

}

i++;

}

return r ^ 0xFFFFFFFFUL;

}

IV. Aller plus loin dans ses hashs CRC32

Nous mettons quelque autre hash référence de base pour pouvoir rapidement arrivé sur des articles. Les deux derniers son bien des hashs CRC32, mais sont sur un calcule de hash avec "DWORD CalcHash_CRC32_ sensitivecase _C_V6(char *data)". Nous les avons mis sur un fond gris.

Hash	Description
0x6AE69F02	kernel32.dll
0x02489AAB	user32.dll
0xF734E815	ws2_32.dll
0xC82D5F77	getsockname
0x4AED5DAF	messageboxa
0x1C9E46BD	loadLibrarya
0x572D5D8E	MessageBoxA
0x3FC1BD8D	LoadLibraryA

Nous avons cherché quelques sites parlant ou en référant le hash 0xC82D5F77 au travers d'internet.

Nous arrivons sur "Ngioweb proxy Malware" qui utilise des hashs sur ce même algorithme CRC32

Il résout l'adresse des Api par leurs hachages évitant qu'elle soit visibible

ce malware Ngioweb utilise plusieurs méthodes d'obfuscation, dont l'appelle d'API par obfuscation. Chaque fois que le malware doit appeler une fonction API, il résout d'abord l'adresse de l'Api cible à l'aide de deux paire de hachages. L'une pour la librairie et l'autre pour l'Api ciblè , puis appelle la fonction de résolution pour enfin effectuer l'appel API elle-même en utilisant l'adresse résolue obtenu.

Nous mettons un exemple extrait d'un article sur "Ngioweb"

Appel de la fonction de résolution d'adresse d'une API ,"getsockname" dans le malware Ngioweb

Nous avons la fonction de "resolve" dans l'article. Mais il assez simple dans reconstruire une zéro.

DWORD GetProcAddressByHashCRC32LowerCase(DWORD dwModuleHashCrc32, DWORD dwProcNameHashCrc32)

Voici la fonction reconstruite

DWORD GetProcAddressByHashCRC32LowerCase(DWORD dwModuleHashCrc32, DWORD dwProcNameHashCrc32)

{

PPEB_LDR_DATA pebLdrData;

__asm

{

mov eax, fs:[0x30] // Get PEB ADDR en X32 à partir TEB offset champs structure 0x30

add eax, 0x0C // Get PEB_LDR_DATA en X32 à partir du PEB offset champs structure 0x0C

mov eax, [eax] // Get LoaderData ADDR

mov pebLdrData, eax

}

LDR_DATA_TABLE_ENTRY LoaderTable;

PLIST_ENTRY pCurrentList = 0, pStart = 0,ptr=0;

pStart = pebLdrData->InLoadOrderModuleList.Blink;

ptr = pebLdrData->InLoadOrderModuleList.Flink;

do { // for each module

PLDR_DATA_TABLE_ENTRY dte = (PLDR_DATA_TABLE_ENTRY)ptr;

ptr = ptr->Flink;

BYTE *baseAddress = (BYTE *)dte->ModuleBase;

if (!baseAddress)continue; // invalid module(???)

IMAGE_DOS_HEADER *dosHeader = (IMAGE_DOS_HEADER *)baseAddress;

IMAGE_NT_HEADERS *ntHeaders = (IMAGE_NT_HEADERS *)(baseAddress + dosHeader->e_lfanew);

DWORD iedRVA = ntHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;

if (!iedRVA)continue; // Export Directory not present

IMAGE_EXPORT_DIRECTORY *ied = (IMAGE_EXPORT_DIRECTORY *)(baseAddress + iedRVA);

char *moduleName = (char *)(baseAddress + ied->Name);

// Calculate Hash CRC32 LowerCase du module

unsigned __int32 r = 0xFFFFFFFFUL;

int i=0, b;

while(moduleName[i] != 0)

{

char currentChar = moduleName[i];

if(currentChar >= 0x41 && currentChar <=0x5A)currentChar += 0x20;

r ^= currentChar;

for (b = 0; b < 8; ++b)

{

if ((unsigned __int8) r & 1)

r = (r >> 1) ^ 0xEDB88320UL;

else

r >>= 1;

}

i++;

}

DWORD moduleHash = (r ^ 0xFFFFFFFFUL);

if(dwModuleHashCrc32 == moduleHash)

{

// The arrays pointed to by AddressOfNames and AddressOfNameOrdinals run in parallel, i.e. the i-th

// element of both arrays refer to the same function. The first array specifies the name whereas

// the second the ordinal. This ordinal can then be used as an index in the array pointed to by

// AddressOfFunctions to find the entry point of the function.

DWORD *nameRVAs = (DWORD *)(baseAddress + ied->AddressOfNames);

for (DWORD i = 0; i < ied->NumberOfNames; ++i)

{

char *functionName = (char *)(baseAddress + nameRVAs[i]);

// Calculate Hash CRC32 LowerCase

unsigned __int32 r = 0xFFFFFFFFUL;

int e=0, b;

while(functionName[e] != 0)

{

char currentChar = functionName[e];

if(currentChar >= 0x41 && currentChar <=0x5A)currentChar += 0x20;

r ^= currentChar;

for (b = 0; b < 8; ++b)

{

if ((unsigned __int8) r & 1)

r = (r >> 1) ^ 0xEDB88320UL;

else

r >>= 1;

}

e++;

}

DWORD dwHashApi = (r ^ 0xFFFFFFFFUL);

if (dwProcNameHashCrc32 == dwHashApi)

{

WORD ordinal = ((WORD *)(baseAddress + ied->AddressOfNameOrdinals))[i];

DWORD functionRVA = ((DWORD *)(baseAddress + ied->AddressOfFunctions))[ordinal];

return (DWORD)(baseAddress + functionRVA);

}

} while (ptr != pStart);

return 0x0; // address not found

}

Nous avons intégré cela dans un testeurs existant de formation sur le hash CRC32

Nous disposons également de l'extraction en Shellcode de la fonction décrite au dessus

Nous le remettons en dessous le listing :

\x83\xEC\x14\x64\xA1\x30\x00\x00\x00\x83\xC0\x0C\x8B\x00\x89\x44

\x24\x04\x8B\x44\x24\x04\x8B\x48\x10\x8B\x40\x0C\x53\x55\x56\x89

\x4C\x24\x1C\x57\x8B\x58\x18\x85\xDB\x8B\x10\x89\x54\x24\x18\x0F

\x84\xBA\x01\x00\x00\x8B\x43\x3C\x8B\x74\x18\x78\x85\xF6\x89\x74

\x24\x10\x0F\x84\xA7\x01\x00\x00\x8B\x4C\x1E\x0C\x8A\x14\x19\x03

\xCB\x83\xC8\xFF\x84\xD2\x0F\x84\xA0\x00\x00\x00\x8B\xF1\x8B\xFF

\x8A\xCA\x80\xE9\x41\x80\xF9\x19\x77\x03\x80\xC2\x20\x0F\xBE\xD2

\x33\xC2\xA8\x01\x74\x09\xD1\xE8\x35\x20\x83\xB8\xED\xEB\x02\xD1

\xE8\xA8\x01\x74\x09\xD1\xE8\x35\x20\x83\xB8\xED\xEB\x02\xD1\xE8

\xA8\x01\x74\x09\xD1\xE8\x35\x20\x83\xB8\xED\xEB\x02\xD1\xE8\xA8

\x01\x74\x09\xD1\xE8\x35\x20\x83\xB8\xED\xEB\x02\xD1\xE8\xA8\x01

\x74\x09\xD1\xE8\x35\x20\x83\xB8\xED\xEB\x02\xD1\xE8\xA8\x01\x74

\x09\xD1\xE8\x35\x20\x83\xB8\xED\xEB\x02\xD1\xE8\xA8\x01\x74\x09

\xD1\xE8\x35\x20\x83\xB8\xED\xEB\x02\xD1\xE8\xA8\x01\x74\x09\xD1

\xE8\x35\x20\x83\xB8\xED\xEB\x02\xD1\xE8\x8A\x56\x01\x83\xC6\x01

\x84\xD2\x0F\x85\x68\xFF\xFF\xFF\x8B\x74\x24\x10\xF7\xD0\x39\x44

\x24\x28\x0F\x85\xE7\x00\x00\x00\x8B\x6C\x1E\x20\x8B\x44\x24\x10

\x8B\x74\x18\x18\x03\xEB\x33\xFF\x85\xF6\x89\x74\x24\x1C\x0F\x86

\xCB\x00\x00\x00\x8B\x4C\xBD\x00\x8A\x14\x19\x03\xCB\x83\xC8\xFF

\x84\xD2\x0F\x84\xA4\x00\x00\x00\x8B\xF1\x8D\x9B\x00\x00\x00\x00