I. Introduction
Nous allons voir un calcule de hash que vous rencontrerez
indirectement lors d'analyse
Ce hash est basé sur SHL avec comme valeur 1 et moins
utilisé que les familles ROL ou ROR
Mais comme elle apparaît de plus en plus dans des
échantillons sur les sous éléments d'un malware. Il est utile de repasser
dessus et refaire un petit tour sur celui-ci.
II. Référence des Hashs Api et Module
Nous mettons un petit tableau de hash classique en
SHL1AdditiveLowercase pour trouver d'autre exemple ou d'article sur cette
algorithme de hash.
|
Hash
|
String
|
|
0x000D4E88
|
Kernel32.dll
|
|
0x0003AB08
|
WS2_32.dll
|
|
0x000CA608
|
ADVAPI.dll
|
|
0x00037908
|
MSVCRT.dll
|
|
0x000D5786
|
LoadLibraryA
|
|
0x00348BFA
|
GetProcAddress
|
|
0x0038D13C
|
VirtualProtect
|
|
0x0000677C
|
Connect
|
|
0x069BB2E6
|
GetSystemDirectoryA
|
|
0x0006BC6A
|
ExitProcess
|
|
0x00000C4E
|
Free
|
|
0x000DCDB4
|
RevertToSelf
|
|
0x00067746
|
CreateFileA
|
|
0x00000CD8
|
Send
|
|
0x00000CC0
|
recv
|
|
0x000D269A
|
GetStdHandle
|
|
0x00000CD8
|
Send
|
|
0x0001CA42
|
WriteFile
|
|
0x00039314
|
WSAStartup
|
|
0x000036A4
|
Socket
|
|
0x0000D562
|
ReadFile
|
III. Algorithme de création des hashs
Nous avons implémenté une fonction en C effectuant ce
calcule de hash gérant les deux mode de chaîne ANSI ou UNICODE. Car vous
trouverez beaucoup de model de cette fonction dans différent shellcode à base
de cette algorithme de hash gérant cela comme ceci.
|
DWORD
GetHashShl1AdditiveLowercaseWithSelectorTypeString(char*
pName,DWORD dwMod)
{
int idx
= 0;
DWORD dwHash=0x0;
do
{
char
c =(DWORD)pName[idx];
c = c|0x60;
dwHash = dwHash+ c;
dwHash = dwHash << 1;
idx +=dwMod;
}while(pName[idx]!=0x00);
return
dwHash;
}
|
Nous avons intégré cela dans un petit programme pour le
calcule de hash sous le bouton "Hash1 Asm" et effectué la capture
avec comme string "LoadLibraryA" qui nous renvoi la valeur 0x000D5786
Nous avons également intégré une version assembleur de la
fonction
|
DWORD
__declspec(naked) __stdcall
AsmHashShl1AdditiveLowercaseWithSelectorTypeStringV2(char* pName,DWORD
dwType)
{
__asm
{
push ebp
mov ebp, esp
push ecx
push ebx
push edx
xor ecx, ecx
xor ebx, ebx
xor edx, edx
mov eax,
[ebp+0x8] ; target string
hashloop:
mov dl,
[eax]
or dl, 0x60
add ebx,
edx ; Add hash to value carac
shl ebx, 1
add eax,
[ebp+0xc] ; Add address to eax ASCII of UNICODE flag
mov cl,
[eax]
test cl, cl
jnz
hashloop
mov eax, ebx
pop edx
pop ebx
pop ecx
mov esp, ebp
pop ebp
ret 8 ; ret and cleanup stack
argument
}
}
|
Attention
Traditionnellement, les appels de fonction C sont effectués
avec l'appelant qui pousse certains paramètres sur la pile, En appelant la
fonction, lors du retour de la fonction l'appelant et en charge de nettoyer ces
arguments poussés ou plus simplement que la pile revient à l'état initial.
D'autre convention existe dont __stdcall. Dans celui-ci, les
paramètres sont à nouveau définis par l'appelant et passé par la pile, mais la
pile est nettoyée directement par la fonction appelé. Il s'agit de la
convention standard pour les fonctions de l'API Win32
(telle que définie par la macro WINAPI dans
<windows.h>). Elle est parfois appelée convention d'appel
"Pascal" lié au passé.
Nous pouvons également utiliser l'option de compilation / Gz
pour spécifier __stdcall pour toutes les fonctions non explicitement déclarées
avec une autre convention d'appel.
Il est assez simple de repérer cela au niveau de
l'assembleur via le code instruction "ret" quand elle est écrit 0xC2
0xXX 0xYY
ou le nombre qui suit l'opcode C2 correspond on décalage de
pile avant retour ( Esp = Esp + YYXXh )
nous avons utiliser cette convention dans notre fonction
incluant également le fait que le souhaite pas de Prolog et d'Epilog via __declspec(naked).
Dans notre outil cette fonction correspond au bouton
"Hash2 Asm", et vous pouvez voir qu'elle renvoi également le hash
souhaité pour notre chaîne "LoadLibraryA".
IV. Cas pratique dans un échantillon
Maintenant que vous avez les bases, on va rentrer plus dans
le détaille sur un exemple pris d'un bloc d'échantillon d'un malware ( le bloc
est une partie du sous élément du packer )
Dont voici le listing dumper du bloc extrait
|
0000 E8 14 02 00
00 33 C0 C3 8B 54 24 0C 8B 4C 24 04
.....3...T$..L$.
0010 8B C2 4A 57 8B F9 85 C0 74 12 56 8D 72 01
8B 54 ..JW....t.V.r..T
0020 24 10 8A 02 88 01 41 42 4E 75 F7 5E 8B C7
5F C3 $.....ABNu.^.._.
0030 55 8B EC 51 51 53 56 57 90 90 90 90 68 86
57 0D U..QQSVW....h.W.
0040 00 68 88 4E 0D 00 E8 1A 00 00 00 89 45 FC
68 FA .h.N........E.h.
0050 8B 34 00 68 88 4E 0D 00 E8 08 00 00 00 89
45 F8 .4.h.N........E.
0060 E9 B9 00 00 00 55 8B EC 53 56 57 51 64 FF
35 30 .....U..SVWQd.50
0070 00 00 00 58 8B 40 0C 8B 48 0C 8B 11 8B 41
30 6A ...X.@..H....A0j
0080 02 8B 70 08
57 50 E8 5B 00 00 00 85 C0 74 04 8B
..p.WP.[.....t..
0090 CA EB E7 8B
41 18 50 8B 58 3C 03 C3 8B 58 78 58
....A.P.X<...XxX
00A0 50 03 D8 8B 4B 1C 8B 53 20 8B 5B 24 03 C8
03 D0 P...K..S .[$....
00B0 03 D8 8B 32 58 50 03 F0 6A 01 FF 75 0C 56
E8 23 ...2XP..j..u.V.#
00C0 00 00 00 85 C0 74 08 83 C2 04 83 C3 02 EB
E3 58 .....t.........X
00D0 33 D2 66 8B 13 C1 E2 02 03 CA 03 01 59 5F
5E 5B 3.f.........Y_^[
00E0 8B E5 5D C2 08 00 55 8B EC 51 53 52 33 C9
33 DB ..]...U..QSR3.3.
00F0 33 D2 8B 45 08 8A 10 80 CA 60 03 DA D1 E3
03 45 3..E.....`.....E
0100 10 8A 08 84 C9 E0 EE 33 C0 8B 4D 0C 3B D9
74 05 .......3..M.;.t.
0110 90 90 90 90 40 5A 5B 59 8B E5 5D C2 0C 00
8B 45 ....@Z[Y..]....E
0120 08 8B 4D FC 5F 5E 89 08 8B 45 0C 8B 4D F8
5B 89 ..M._^...E..M.[.
0130 08 C9 C3 55 8B EC 81 EC 08 04 00 00 53 56
33 DB ...U........SV3.
0140 57 33 D2 8D 85 F8 FB FF FF B9 00 01 00 00
89 10 W3..............
0150 42 83 C0 04 3B D1 7C F6 33 FF 8D B5 F8 FB
FF FF B...;.|.3.......
0160 8B C7 33 D2 F7 75 14 8B 45 0C 0F B6 04 02
03 06 ..3..u..E.......
0170 03 C3 8B D9 99 F7 FB 8A 06 47 88 45 FF 8B
DA 8B .........G.E....
0180 94 9D E8 EB FF FF 89 16 83 C6 04 0F B6 55
FF 8D .............U..
|
Nous avons passer dans outil pour effectuer une
transformation en un format shellcode de ce dump ( bloc binary )
Nous avons remis en
dessous le shellcode obtenu
|
\xE8\x14\x02\x00\x00\x33\xC0\xC3\x8B\x54\x24\x0C\x8B\x4C\x24\x04
\x8B\xC2\x4A\x57\x8B\xF9\x85\xC0\x74\x12\x56\x8D\x72\x01\x8B\x54
\x24\x10\x8A\x02\x88\x01\x41\x42\x4E\x75\xF7\x5E\x8B\xC7\x5F\xC3
\x55\x8B\xEC\x51\x51\x53\x56\x57\x90\x90\x90\x90\x68\x86\x57\x0D
\x00\x68\x88\x4E\x0D\x00\xE8\x1A\x00\x00\x00\x89\x45\xFC\x68\xFA
\x8B\x34\x00\x68\x88\x4E\x0D\x00\xE8\x08\x00\x00\x00\x89\x45\xF8
\xE9\xB9\x00\x00\x00\x55\x8B\xEC\x53\x56\x57\x51\x64\xFF\x35\x30
\x00\x00\x00\x58\x8B\x40\x0C\x8B\x48\x0C\x8B\x11\x8B\x41\x30\x6A
\x02\x8B\x70\x08\x57\x50\xE8\x5B\x00\x00\x00\x85\xC0\x74\x04\x8B
\xCA\xEB\xE7\x8B\x41\x18\x50\x8B\x58\x3C\x03\xC3\x8B\x58\x78\x58
\x50\x03\xD8\x8B\x4B\x1C\x8B\x53\x20\x8B\x5B\x24\x03\xC8\x03\xD0
\x03\xD8\x8B\x32\x58\x50\x03\xF0\x6A\x01\xFF\x75\x0C\x56\xE8\x23
\x00\x00\x00\x85\xC0\x74\x08\x83\xC2\x04\x83\xC3\x02\xEB\xE3\x58
\x33\xD2\x66\x8B\x13\xC1\xE2\x02\x03\xCA\x03\x01\x59\x5F\x5E\x5B
\x8B\xE5\x5D\xC2\x08\x00\x55\x8B\xEC\x51\x53\x52\x33\xC9\x33\xDB
\x33\xD2\x8B\x45\x08\x8A\x10\x80\xCA\x60\x03\xDA\xD1\xE3\x03\x45
\x10\x8A\x08\x84\xC9\xE0\xEE\x33\xC0\x8B\x4D\x0C\x3B\xD9\x74\x05
\x90\x90\x90\x90\x40\x5A\x5B\x59\x8B\xE5\x5D\xC2\x0C\x00\x8B\x45
\x08\x8B\x4D\xFC\x5F\x5E\x89\x08\x8B\x45\x0C\x8B\x4D\xF8\x5B\x89
\x08\xC9\xC3\x55\x8B\xEC\x81\xEC\x08\x04\x00\x00\x53\x56\x33\xDB
\x57\x33\xD2\x8D\x85\xF8\xFB\xFF\xFF\xB9\x00\x01\x00\x00\x89\x10
\x42\x83\xC0\x04\x3B\xD1\x7C\xF6\x33\xFF\x8D\xB5\xF8\xFB\xFF\xFF
\x8B\xC7\x33\xD2\xF7\x75\x14\x8B\x45\x0C\x0F\xB6\x04\x02\x03\x06
\x03\xC3\x8B\xD9\x99\xF7\xFB\x8A\x06\x47\x88\x45\xFF\x8B\xDA\x8B
\x94\x9D\xE8\xEB\xFF\xFF\x89\x16\x83\xC6\x04\x0F\xB6\x55\xFF\x8D
|
Nous le passons au travers de notre désassembleur de
Shellcode X32
Nous avons remis le listing obtenu
|
00000000: E8 14 02 00 00 CALL 00000214h (+214h ->:00000219)
00000005: 33 C0 XOR EAX,EAX
00000007: C3 RET
00000008: 8B 54 24 0C MOV EDX,DWORD PTR [ESP+0Ch]
0000000C: 8B 4C 24 04 MOV ECX,DWORD PTR[ESP+0x04]
00000010: 8B C2 MOV
EAX,EDX
00000012: 4A DEC
EDX
00000013: 57 PUSH
EDI
00000014: 8B F9 MOV
EDI,ECX
00000016: 85 C0 TEST
EAX,EAX
00000018: 74 12 JZ
0x12 (+12h ->:0000002C)
0000001A: 56 PUSH
ESI
0000001B: 8D 72 01 LEA
ESI,[EDX+0x01]
0000001E: 8B 54 24 10 MOV EDX,DWORD PTR [ESP+10h]
00000022: 8A 02 MOV
AL , BYTE PTR [EDX]
00000024: 88 01 MOV
BYTE PTR[ECX],AL
00000026: 41 INC ECX
00000027: 42 INC EDX
00000028: 4E DEC
ESI
00000029: 75 F7 JNZ
F7h (rel8)(-09h ->:00000022)
0000002B: 5E POP
ESI
0000002C: 8B C7 MOV
EAX,EDI
0000002E: 5F POP
EDI
0000002F: C3 RET
00000030: 55 PUSH
EBP
00000031: 8B EC MOV
EBP,ESP
00000033: 51 PUSH
ECX
00000034: 51 PUSH
ECX
00000035: 53 PUSH
EBX
00000036: 56 PUSH
ESI
00000037: 57 PUSH
EDI
00000038: 90 NOP
00000039: 90 NOP
0000003A: 90 NOP
0000003B: 90 NOP
0000003C: 68 86 57 0D 00 PUSH 000D5786h "†W " dw:874374 / {134
87 13 0} / < w:3328 | w:34391 >
00000041: 68 88 4E 0D 00 PUSH 000D4E88h "ˆN " dw:872072 / {136
78 13 0} / < w:3328 | w:34894 >
00000046: E8 1A 00 00 00 CALL 0000001Ah (+1Ah ->:00000065)
db
"‰Eühú‹4"
0000004B: 89 45 FC 68 FA 8B 34 00
00000053: 68 88 4E 0D 00 PUSH 000D4E88h "ˆN " dw:872072 / {136
78 13 0} / < w:3328 | w:34894 >
00000058: E8 08 00 00 00 CALL 00000008h (+08h ->:00000065)
db
"‰Eøé¹"
0000005D: 89 45 F8 E9 B9 00
00000063: 00 00 ADD
BYTE PTR[EAX],AL
00000065: 55 PUSH
EBP
00000066: 8B EC MOV
EBP,ESP
00000068: 53 PUSH
EBX
00000069: 56 PUSH
ESI
0000006A: 57 PUSH
EDI
0000006B: 51 PUSH
ECX
0000006C: 64 FF 35 30 00 00 00 PUSH DWORD PTR FS:[00000030h]
00000073: 58 POP
EAX
00000074: 8B 40 0C MOV
EAX,DWORD PTR[EAX+0x0C]
00000077: 8B 48 0C MOV
ECX,DWORD PTR[EAX+0Ch]
0000007A: 8B 11 MOV
EDX,DWORD PTR [ECX]
0000007C: 8B 41 30 MOV
EAX,DWORD PTR[ECX+0x30]
0000007F: 6A 02 PUSH
02h (2) '[1]'
00000081: 8B 70 08 MOV
ESI,DWORD PTR[EAX+08h]
00000084: 57 PUSH
EDI
00000085: 50 PUSH
EAX
00000086: E8 5B 00 00 00 CALL 0000005Bh (+5Bh ->:000000E6)
0000008B: 85 C0 TEST
EAX,EAX
0000008D: 74 04 JZ
0x04 (+04h ->:00000093)
0000008F: 8B CA MOV
ECX,EDX
00000091: EB E7 JMP
E7h (-19h ->:0000007A)
00000093: 8B 41 18 MOV
EAX,DWORD PTR[ECX+0x18]
00000096: 50 PUSH
EAX
00000097: 8B 58 3C MOV
EBX,DWORD PTR [EAX+3Ch]
0000009A: 03 C3 ADD
EAX,EBX
0000009C: 8B 58 78 MOV
EBX,DWORD PTR [EAX+78h]
0000009F: 58 POP
EAX
000000A0: 50 PUSH
EAX
000000A1: 03 D8 ADD
EBX,EAX
000000A3: 8B 4B 1C MOV
ECX,DWORD PTR [EBX+1Ch]
000000A6: 8B 53 20 MOV
EDX,DWORD PTR[EBX+0x20]
000000A9: 8B 5B 24 MOV
EBX,DWORD PTR [EBX+24h]
000000AC: 03 C8 ADD
ECX,EAX
000000AE: 03 D0 ADD
EDX,EAX
000000B0: 03 D8 ADD
EBX,EAX
000000B2: 8B 32 MOV
ESI,DWORD PTR[EDX]
000000B4: 58 POP
EAX
000000B5: 50 PUSH
EAX
000000B6: 03 F0 ADD
ESI,EAX
000000B8: 6A 01 PUSH
01h (1) ''
000000BA: FF 75 0C PUSH
DWORD PTR [EBP+0Ch]
000000BD: 56 PUSH
ESI
000000BE: E8 23 00 00 00 CALL 00000023h (+23h ->:000000E6)
000000C3: 85 C0 TEST
EAX,EAX
000000C5: 74 08 JZ
0x08 (+08h ->:000000CF)
000000C7: 83 C2 04 ADD
EDX,04h (ADD(r/m16,imm8))
000000CA: 83 C3 02 ADD
EBX,02h (ADD(r/m16,imm8))
000000CD: EB E3 JMP
E3h (-1Dh ->:000000B2)
000000CF: 58 POP
EAX
000000D0: 33 D2 XOR
EDX,EDX
000000D2: 66 8B 13 MOV
DX,WORD PTR[EBX]
000000D5: C1 E2 02 SHL
EDX,02h
000000D8: 03 CA ADD
ECX,EDX
000000DA: 03 01 ADD
EAX,DWORD PTR[ECX]
000000DC: 59 POP
ECX
000000DD: 5F POP
EDI
000000DE: 5E POP ESI
000000DF: 5B POP
EBX
000000E0: 8B E5 MOV
ESP,EBP
000000E2: 5D POP EBP
000000E3: C2 08 00 RET(imm16)
0008h
000000E6: 55 PUSH
EBP
000000E7: 8B EC MOV
EBP,ESP
000000E9: 51 PUSH
ECX
000000EA: 53 PUSH
EBX
000000EB: 52 PUSH
EDX
000000EC: 33 C9 XOR
ECX,ECX
000000EE: 33 DB XOR
EBX,EBX
000000F0: 33 D2 XOR
EDX,EDX
000000F2: 8B 45 08 MOV
EAX,DWORD PTR [EBP+08h]
000000F5: 8A 10 MOV
DL, BYTE PTR[EAX]
000000F7: 80 CA 60 OR
DL,0x60
000000FA: 03 DA ADD
EBX,EDX
000000FC: D1 E3 SHL
EBX,1
000000FE: 03 45 10 ADD
EAX,DWORD PTR [EBP+10h]
00000101: 8A 08 MOV
CL, BYTE PTR [EAX]
00000103: 84 C9 TEST
CL,CL
00000105: E0 EE LOOPNE
EEh (-FFFFFFEEh=>:000000F5)
00000107: 33 C0 XOR
EAX,EAX
00000109: 8B 4D 0C MOV
ECX,DWORD PTR [EBP+0Ch]
0000010C: 3B D9 CMP
EBX,ECX
0000010E: 74 05 JZ
0x05 (+05h ->:00000115)
00000110: 90 NOP
00000111: 90 NOP
00000112: 90 NOP
00000113: 90 NOP
00000114: 40 INC
EAX
00000115: 5A POP
EDX
00000116: 5B POP
EBX
00000117: 59 POP
ECX
00000118: 8B E5 MOV
ESP,EBP
0000011A: 5D POP
EBP
0000011B: C2 0C 00 RET(imm16)
000Ch
0000011E: 8B 45 08 MOV
EAX,DWORD PTR [EBP+08h]
00000121: 8B 4D FC MOV
ECX,DWORD PTR [EBP-04h]
00000124: 5F POP
EDI
00000125: 5E POP
ESI
00000126: 89 08 MOV
DWORD PTR[EAX],ECX
00000128: 8B 45 0C MOV
EAX,DWORD PTR [EBP+0Ch]
0000012B: 8B 4D F8 MOV
ECX,DWORD PTR [EBP-08h]
0000012E: 5B POP
EBX
0000012F: 89 08 MOV
DWORD PTR[EAX],ECX
00000131: C9 LEAVE
( equivaut MOV ESP,EBP / POP EBP) en X86
00000132: C3 RET
00000133: 55 PUSH
EBP
00000134: 8B EC MOV
EBP,ESP
00000136: 81 EC 08 04 00 00 SUB ESP,0x00000408
0000013C: 53 PUSH
EBX
0000013D: 56 PUSH
ESI
0000013E: 33 DB XOR
EBX,EBX
00000140: 57 PUSH EDI
00000141: 33 D2 XOR
EDX,EDX
00000143: 8D 85 F8 FB FF FF LEA EAX,DWORD PTR[EBP - 00000408h]
00000149: B9 00 01 00 00 MOV ECX, 00000100h ""
0000014E: 89 10 MOV
DWORD PTR[EAX],EDX
00000150: 42 INC EDX
00000151: 83 C0 04 ADD
EAX,04h
00000154: 3B D1 CMP
EDX,ECX
00000156: 7C F6 JL
F6h (rel8)(-0Ah ->:0000014E)
00000158: 33 FF XOR
EDI,EDI
0000015A: 8D B5 F8 FB FF FF LEA ESI,[EBP-0x00000408]
00000160: 8B C7 MOV
EAX,EDI
00000162: 33 D2 XOR
EDX,EDX
00000164: F7 75 14 DIV
DWORD PTR[EBP+0x14]
00000167: 8B 45 0C MOV
EAX,DWORD PTR [EBP+0Ch]
0000016A: 0F B6 04 02 MOVZX EAX,BYTE PTR[EDX+EAX*1]
0000016E: 03 06 ADD
EAX,DWORD PTR[ESI]
00000170: 03 C3 ADD
EAX,EBX
00000172: 8B D9 MOV
EBX,ECX
00000174: 99 CDQ
(convert Doubleword to Quadword)
00000175: F7 FB IDIV
EBX
00000177: 8A 06 MOV
AL, BYTE PTR [ESI]
00000179: 47 INC
EDI
0000017A: 88 45 FF MOV
BYTE PTR[EBP-01h],AL
0000017D: 8B DA MOV
EBX,EDX
0000017F: 8B 94 9D E8 EB FF FF MOV EDX,DWORD PTR[EBP+EBX*4-00001418h]
00000186: 89 16 MOV
DWORD PTR[ESI],EDX
00000188: 83 C6 04 ADD
ESI,04h
0000018B: 0F B6 55 FF MOVZX EDX,BYTE PTR[EBP-0x01]
0000018F: 8D
|
Nous avons mis en rouge la partie qui nous intéresse au
dessus et en bleu comment on a ciblé ce
bloc.
En dessous nous avons mis la partie bleu ( en neutralisant
la détection de data , qui mauvaise )
|
0000003C: 68 86 57 0D 00 PUSH 000D5786h "†W " dw:874374 / {134
87 13 0} / < w:3328 | w:34391 >
00000041: 68 88 4E 0D 00 PUSH 000D4E88h "ˆN " dw:872072 / {136
78 13 0} / < w:3328 | w:34894 >
00000046: E8 1A 00 00 00 CALL 0000001Ah (+1Ah ->:00000065)
0000004B: 89 45 FC MOV
DWORD PTR[EBP-04h],EAX
0000004E: 68 FA 8B 34 00 PUSH 00348BFAh "ú‹4" dw:3443706 / {250
139 52 0} / < w:13312 | w:64139 >
00000053: 68 88 4E 0D 00 PUSH 000D4E88h "ˆN " dw:872072 / {136
78 13 0} / < w:3328 | w:34894 >
00000058: E8 08 00 00 00 CALL 00000008h (+08h ->:00000065)
|
Vous pouvez voir les
hashs de
|
0x000D5786
|
LoadLibraryA
|
|
0x00348BFA
|
GetProcAddress
|
|
0x000D4E88
|
Kernel32.dll
|
maintenant allons regarde la fonction que pointé en
0x00000065 en la regardant, nous arrivons à un appel
000000BE: E8 23 00 00 00 CALL 00000023h
(+23h ->:000000E6)
ou l'on voit le passage d'un des hashs via qui correspond à
l'api rechercher dans le module passer également au travers d'un hash
000000BA: FF 75 0C PUSH DWORD PTR [EBP+0Ch]
Si on regarde de plus en détail cette fonction que l'on va
nommé Fn2( X, Y , Z ,.. )
|
000000E6: 55 PUSH
EBP
000000E7: 8B EC MOV
EBP,ESP
000000E9: 51 PUSH
ECX
000000EA: 53 PUSH
EBX
000000EB: 52 PUSH
EDX
000000EC: 33 C9 XOR
ECX,ECX
000000EE: 33 DB XOR
EBX,EBX
000000F0: 33 D2 XOR
EDX,EDX
000000F2: 8B 45 08 MOV
EAX,DWORD PTR [EBP+08h]
000000F5: 8A 10 MOV
DL, BYTE PTR[EAX]
000000F7: 80 CA 60 OR
DL,0x60
000000FA: 03 DA ADD
EBX,EDX
000000FC: D1 E3 SHL
EBX,1
000000FE: 03 45 10 ADD
EAX,DWORD PTR [EBP+10h]
00000101: 8A 08 MOV
CL, BYTE PTR [EAX]
00000103: 84 C9 TEST
CL,CL
00000105: E0 EE LOOPNE
EEh (-FFFFFFEEh=>:000000F5)
00000107: 33 C0 XOR
EAX,EAX
00000109: 8B 4D 0C MOV
ECX,DWORD PTR [EBP+0Ch]
0000010C: 3B D9 CMP
EBX,ECX
0000010E: 74 05 JZ
0x05 (+05h ->:00000115)
00000110: 90 NOP
00000111: 90 NOP
00000112: 90 NOP
00000113: 90 NOP
00000114: 40 INC
EAX
00000115: 5A POP
EDX
00000116: 5B POP
EBX
00000117: 59 POP
ECX
00000118: 8B E5 MOV
ESP,EBP
0000011A: 5D POP
EBP
0000011B: C2 0C 00 RET(imm16)
000Ch
|
en rouge on retrouve un bloc de calcule de hash
SHL1AdditiveLowercase caractérisé par le OR ? , 0x60
comme on peut le voir dans l'appel en ligne 0x000000BE , la
fonction prend 3 paramètre
|
000000B8: 6A 01 PUSH
01h (1) ''
000000BA: FF 75 0C PUSH
DWORD PTR [EBP+0Ch]
000000BD: 56 PUSH
ESI
|
comme EBP+0x0C, correspond au hash de l'Api et le dernier paramêtre le mode
il est assez simple d'écrire le prototype de la fonction et
même ce qu'elle fait via la comparaison inclus dans celle-ci.
DWORD
__stdcall AsmCalculateHashAndCompareToRef(char* pName,DWORD dwHashRef,DWORD
dwMod)
Nous avons implément la dit fonction dans notre testeur
comme ceci.
|
DWORD
__declspec(naked) __stdcall AsmCalculateHashAndCompareToRef(char* pName,DWORD
dwHashRef,DWORD dwMod)
{
__asm
{
PUSH EBP
MOV EBP,ESP
PUSH ECX
PUSH EBX
PUSH EDX
XOR ECX,ECX
XOR EBX,EBX
XOR EDX,EDX
MOV EAX,DWORD PTR [EBP+0x08] ; target string
hashloop:
MOV DL, BYTE PTR[EAX]
OR DL,0x60
ADD EBX,EDX ;
accumulate
SHL EBX,1
ADD EAX,DWORD PTR
[EBP+0x10] ; add to eax ASCII of UNICODE flag
MOV CL, BYTE PTR [EAX]
TEST CL,CL
LOOPNE hashloop ;jnz hashloop
XOR EAX,EAX
MOV ECX,DWORD PTR
[EBP+0x0C]
CMP EBX,ECX
JZ notSearchHash
NOP
NOP
NOP
NOP
INC EAX
notSearchHash:
POP EDX
POP EBX
POP ECX
MOV ESP,EBP
POP EBP
RET 0x000C ; ret and
cleanup stack argument
}
}
|
vous pouvez voir que en passant la chaine correspondant au
hash , la fonction renvoi 0 si le hash calculé à partir de la chaîne est
identique au hash fournit en référence.
Nous avons intégrer la signature de cette fonction dans
notre outil d'analyse de shellcode X32 comme vous pouvez le voir dans la
capture en dessous:
V. Conclusions
L'intérêt si on identifie la méthode
de génération des hashs d'api, on peut lister les Apis utiliser par le
programme malveillant et aussi faire des rapprochement entre des échantillons
différents. Souvent le générateur
peut être aussi une signature de l'auteur. l'auteur de ce programme ou
schellcode utilise des sous-routines ou bloc de shellcode qui on déjà fait
leurs preuve dans d'autre projet et testé
Il faut pas oublier que cela peu
prendre du temps de crée ses tools comme tous développeurs
Il ne réécrit pas tous mais
assembles des blocs comme des classes métier ou dédier à des opérations.
De plus cela permet aussi ciblé des
recherche sur ses hash pour trouvé d'autre code moins visible.
Nous espérons que ses quelque ligne,
vous apporterons d'autre voix à explorer.
