V předchozích dílech jsme prošli cestu od TEB přes PEB až po export directory a dynamické získávání adres API funkcí. Dnes se zaměříme na část, která je na první pohled jasná a zřejmá, ale v reálné praxi je největším zdrojem záhadných pádů: volací konvence, shadow space a zarovnání zásobníku.

Předpoklady

Protože tento díl přímo navazuje na díly předchozí, je nezbytné si tyto díly pročíst. Zároveň je velmi vhodné mít alespoň základní představu, co je virtuální paměť a co je ukazatel (pointer).

Každou strukturu, kterou v článku popíšeme, si zároveň ukážeme naživo ve WinDbg v reálném procesu.


Volací konvence

Volací konvence je dohoda mezi volajícím a volaným. Říká, kdo připraví parametry, v jakých registrech se budou předávat, případně, zda bude pro tyto účely využit zásobník, dále kdo uklidí zásobník po volání nebo které registry musí volané funkci přežít beze změny.

Na x86 existovalo několik konkurenčních konvencí. Nejznámější jsou cdecl, stdcall, fastcall, thiscall, ale programátoři si mohli vytvořit i vlastní. Důsledkem této benevolence byl chaos, který za programátora řešil kompilátor, avšak v assembleru tento problém přešel pod správu programátora.

Na x64 Windows se Microsoft snažil tuto situaci aktivně vyřešit již při návrhu. Existuje jediná konvence, Microsoft x64 calling convention[4], a platí pro veškerý kód v uživatelském prostoru.

Pravidla jsou následující: První čtyři celočíselné nebo ukazatelové parametry jdou do registrů RCX, RDX, R8, R9 přesně v tomto pořadí. Pátý a každý další parametr jde na zásobník. Návratová hodnota je v RAX. Pokud funkce vrací 128bitovou hodnotu, jde do dvojice registrů RDX:RAX.

Pro srovnání, Linux a macOS používají volací konvenci System V AMD64 ABI[6], kde prvních šest parametrů jde do registrů RDI, RSI, RDX, RCX, R8, R9. Je tedy zřejmé, že shellcode napsaný pro Windows nelze čistě přenést na Linux přímým překladem, aniž by se v rámci kódu neprovedly odpovídající úpravy. Registry jsou jiné, pořadí je jiné, a jak zjistíme níže, něco jako je shadow space Linux vůbec nezná.

Microsoft x64 (Windows) System V AMD64 (Linux/macOS)
1. parametr RCX RDI
2. parametr RDX RSI
3. parametr R8 RDX
4. parametr R9 RCX
5. parametr zásobník R8
6. parametr zásobník R9
Návratová hodnota RAX RAX
Shadow space 32 bajtů (caller) -

Shadow Space

Shadow space je 32-bajtový blok paměti, který caller musí alokovat na zásobníku před každým voláním funkce. Vždy a bez výjimky.

Důvod? Volaná funkce dostane první čtyři parametry v registrech RCX, RDX, R8, R9. Jenže tyto registry jsou volatilní prostředek. To znamená, že pokud volaná funkce chce zavolat další funkci, musí si hodnoty parametrů někam uložit. A právě shadow space je pro tento účel rezervované místo přímo na zásobníku, hned nad návratovou adresou. Caller ho sice alokuje, ale faktickým vlastníkem je callee, který ho může libovolně používat.

    ...
    sub  rsp, 20h       ; alokace shadow space (32 bajtů = 4 × 8)
    call WinExec        ; volání - shadow space je připraveno
    add  rsp, 20h       ; uvolnění shadow space
    ...

Ještě jednou: Shadow space patří volanému. Jakmile zavoláme funkci, obsah těchto 32 bajtů se v ten okamžik stává nedefinovaným. Volaná funkce ho již přepsala nebo přepsat může. Není tedy možné do ní ukládat vlastní data s očekáváním, že po návratu zůstanou zachována. To se stává zdrojem nahodilých a záludných chyb.


Zarovnání zásobníku

Aby byla situace ještě komplikovanější, musíme při práci se zásobníkem hlídat jeho zarovnání[5]. V éře x86 tato povinnost sice také existovala, ale procesory ji běžně nevymáhaly. Na x64 je situace striktnější. Některé SSE instrukce pracující s 128bitovými XMM registry vyžadují, aby byl operand v paměti zarovnán na 16 bajtů. Pokud však toto zarovnání nesedí, procesor vyvolá výjimku #GP a program okamžitě padne.

Pravidlo je tady jednoduché: Těsně před voláním instrukce CALL musí být RSP zarovnán na 16 bajtů. Instrukce CALL sama na zásobník uloží návratovou adresu, to je 8 bajtů, takže volaná funkce vstupuje do situace, kdy zbytek po dělení RSP % 16 je rovno 8.

Každé použití instrukce PUSH posune RSP o 8 bajtů. Sudý počet instrukcí PUSH v prologu zarovnání zásobníku zachová, lichý počet ho ale poruší. A to je třeba opravit ručně.

; Sudý počet pushů == zarovnání zachováno:
MojeFunc:
    push rbp            ; 1. push
    push rbx            ; 2. push - sudý počet, zarovnání OK
    mov  rbp, rsp
    sub  rsp, 20h       ; shadow space

    ; ...

    add  rsp, 20h
    pop  rbx
    pop  rbp
    ret

; Lichý počet pushů == zarovnání musí být opraveno:
MojeFunc:
    push rbp            ; 1. push
    push rbx            ; 2. push
    push rdi            ; 3. push - lichý počet, zarovnání narušeno
    mov  rbp, rsp
    sub  rsp, 28h       ; 40 bajtů: 32 shadow space + 8 pro opravu zarovnání

    ; ...

    add  rsp, 28h
    pop  rdi
    pop  rbx
    pop  rbp
    ret

Zarovnání zásobníku v shellcodu

Existuje ještě jedna situace, o které se v kontextu běžných PE kódů nemluví, ale pro shellcode je zcela stěžejní. Když totiž shellcode dostane řízení, nemáme žádnou záruku o stavu registru RSP. Loader, exploit, nebo injektor, který shellcode spustil, nám zásobník předal v nějakém stavu. A my nevíme, jestli je správně zarovnán na 16 bajtů, nebo ne.

Řešení je v tomto případě přímočaré. Na samém začátku shellcodu RSP zarovnáme ručně:

and  rsp, 0xFFFFFFFFFFFFFFF0

Tento řádek kódu vynuluje poslední čtyři bity registru RSP, to znamená, že zaokrouhlí adresu dolů na nejbližší násobek čísla 16. Pokud by byl RSP již zarovnán, instrukce nic nezmění. Pokud by nebyl, opraví ho.

Zde ale nastává zásadní problém, protože pokud byl RSP zarovnán na 8, ale ne na 16, instrukce and rsp, ... ho posune dolů o 8 bajtů. Alokuje tedy 8 bajtů navíc, které nikdo nevyužije. Při volání instrukce ret se do registru RIP načte hodnota na vrcholu zásobníku, ale tam leží těchto 8 bajtů nul místo návratové adresy. To způsobí, že proces okamžitě spadne na Access Violation. To tedy znamená, že pokud shellcode potřebuje po dokončení vrátit řízení zpět, ať už proto, že byl injektován do cizího vlákna, nebo proto, že ho chceme otestovat voláním jako funkci, instrukce ret v epilogu nenajde správnou adresu a proces spadne.

Máme dvě jednoduché cesty, jak tento problém řešit.

Varianta 1: Záloha RSP přes RBP

Tento přístup je asi nejjednodušší a nejlogičtější. Je založen na fungování prologu, který má za cíl nastavit registr RBP na hodnotu uloženou v RSP, čímž se vytváří frame zásobníku dané funkce. Využívá se nejen pro adresaci dat na stacku, ale také pro snadné obnovení původního stack framu nadřazené funkce. Před zarovnáním tedy uložíme původní hodnotu registru RSP do registru RBP. Epilog pak registr RSP obnoví přes RBP, nezávisle na tom, zda ho instrukce and posunula o 8 bajtů či nikoliv.

shellcode_start:
    push rbp
    mov  rbp, rsp                   ; zachování původního RSP
    and  rsp, 0xFFFFFFFFFFFFFFF0    ; zarovnání - RSP se může posunout dolů

    ; ... tělo shellcodu ...

    mov  rsp, rbp                   ; obnova původního RSP
    pop  rbp
    ret                             ; ret najde správnou návratovou adresu

Toto je standardní přístup. Přesně pro tyto účely existuje frame pointer. Výhodou je, že v epilogu nemusíme přesně vědět, o kolik bajtů zarovnání RSP posunulo.

Varianta 2: Shellcode bez návratu

Pokud shellcode není určen k návratu, například spustí payload a proces záměrně ukončí voláním WinAPI funkce ExitProcess, lze instrukci ret v epilogu vynechat. Zarovnání pak nemusí zachraňovat původní RSP, protože to jednoduše není potřeba.

shellcode_start:
    and  rsp, 0xFFFFFFFFFFFFFFF0    ; zarovnání

    ; ... tělo shellcodu ...

    ; žádný ret - shellcode ukončí proces sám
    xor  ecx, ecx
    call ExitProcess

V našem příkladu použijeme první variantu. Shellcode se vrátí do volající funkce, takže bude nutné správně obnovit registr RSP.


Non-volatile registry

Registry v x64 ABI se dělí do dvou kategorií podle toho, kdo zodpovídá za jejich zachování. Volatile registry, RCX, RDX, R8, R9, R10, R11 a RAX, může volaná funkce libovolně přepsat. Volající s tím musí počítat.

Non-volatile registry jsou jiná věc. RBX, RBP, RDI, RSI, R12, R13, R14 a R15 musí volaná funkce po návratu předat v původním stavu. Pokud je funkce použije, je nezbytné, aby je na začátku zazálohovala na zásobník a před voláním instrukce RET obnovila.

MojeFunc:
    push rbp
    push rbx
    push rdi
    mov  rbp, rsp
    sub  rsp, 28h          ; shadow space + zarovnání

    ; tady můžeme RBX a RDI volně používat

    add  rsp, 28h
    pop  rdi
    pop  rbx
    pop  rbp
    ret

Pro shellcode je toto kritické z jiného důvodu než by bylo pro běžný kód. Shellcode se spouští uvnitř cizího procesu, v cizím vláknu, uprostřed cizího call stacku. Program, ve kterém je shellcode injektován, má v non-volatile registrech uložené hodnoty, na jejichž zachování spoléhá. Pokud shellcode tyto registry přepíše a neobnoví je, program po návratu z shellcodu pokračuje s poškozenými hodnotami, a pravděpodobně spadne na místě, které s naším kódem zdánlivě nesouvisí.

V případě XMM registrů platí stejné pravidlo. Registry XMM6 až XMM15 jsou non-volatile, XMM0 až XMM5 jsou volatile. Pokud shellcode volá funkce, které interně používají SSE nebo AVX instrukce, což dnes dělá prakticky každá optimalizovaná funkce v moderních systémových knihovnách, musí být non-volatile XMM registry zachovány.

Praktický (a zlatý) přístup pro shellcode: Na začátku uložit všechny non-volatile obecné registry, které budeme v shellcodu používat, zarovnat zásobník, volat WinAPI, a před voláním instrukce RET vše obnovit v opačném pořadí. Program, do kterého se vracíme, nesmí poznat, že jsme narušili jeho běh.


První shellcode

Úspěšně jsme prošli nezbytnou teorii a je na čase vyvinout si první vlastní Win64 shellcode.

Upřímně, rozmýšlel jsem se, čím by bylo vhodné začít, abych znovu nevytvářel shellcode, který již přede mnou vytvářelo x jiných autorů tutoriálů a shellcode developerů. Došel jsem ale k závěru, že klasický shellcode spouštějící aplikaci calc.exe přes WinAPI funkci WinExec[3] je z pohledu výuky to nejlepší řešení. Kód je dostatečně jednoduchý pro implementaci a zároveň umožňuje čtenáři okamžité vizuální zhodnocení jeho funkčnosti. Zároveň nám umožňuje si aktivně ukázat všechny výše popsané teoretické znalosti (shadow space, zarovnání zásobníku, volací konvence, obnova non-volatile registrů).

Adresu WinAPI funkce WinExec získáme za běhu přes PEB[1] traversal a porovnání ROR13 hashů exportovaných názvů. Tedy stejnou techniku, kterou jsme rozebírali v druhém a třetím dílu. ROR13 se v rámci psaní shellcodů stal de facto standardem. Jeho implementace je kratší než DJB2, snadno implementovatelná v assembleru, a každý, kdo někdy četl nějaký shellcode writeup, tuto funkci okamžitě pozná.

Vypočítané hashe jména hledané DLL knihovny a jména hledané exportované funkce:

KERNEL32.DLL  ->  0x6E2BCA17   (uppercase, case-insensitive)
WinExec       ->  0x0E8AFE98   (přesný název, case-sensitive)

Názvy modulů před hashováním převádíme na velké znaky, protože operační systém Windows může ve struktuře PEB uvádět jméno DLL v různých modifikovaných variantách. Názvy funkcí hashujeme přesně tak, jak je uvádí export directory. Ta velikost písmen rozlišuje.

; =============================================================================
; win_exec_shellcode.asm
; Shellcode: Spouští calc.exe přes WinExec
; Technika: PEB traversal + ROR13 hash + Microsoft x64 ABI
; Assembler: NASM x64
;
; Hash konstanty (ROR13):
;   KERNEL32.DLL  -> 0x6E2BCA17   (uppercase)
;   WinExec       -> 0x0E8AFE98   (case-sensitive)
; =============================================================================

BITS 64

section .text
global shellcode_start

shellcode_start:
    ; -----------------------------------------------------------------
    ; Prolog
    ; -----------------------------------------------------------------
    push rbp
    mov  rbp, rsp                    ; zachování původního RSP
    and  rsp, 0xFFFFFFFFFFFFFFF0     ; zarovnání na 16 bajtů
    push rbx
    push rdi
    push rsi
    push r12
    push r13
    push r14
    push r15                         ; 7 pushů - lichý počet
    sub  rsp, 28h                    ; shadow space (20h) + 8 bajtů pro zarovnání

    ; -----------------------------------------------------------------
    ; Krok 1: Bázová adresa kernel32.dll přes PEB
    ; -----------------------------------------------------------------
    mov  rax, [gs:0x60]             ; GS segment -> PEB
    mov  rax, [rax + 0x18]          ; PEB+0x18 -> Ldr (PEB_LDR_DATA *)
    mov  rax, [rax + 0x20]          ; Ldr+0x20 -> InMemoryOrderModuleList.Flink
    mov  rax, [rax]                 ;          -> [1] hostitelský EXE
    mov  rax, [rax]                 ;          -> [2] kernel32.dll
    mov  r12, [rax + 0x20]          ; +0x20 od InMemoryOrderLinks -> DllBase

    ; -----------------------------------------------------------------
    ; Krok 2: Export directory kernel32.dll
    ; -----------------------------------------------------------------
    mov  rbx, r12
    mov  eax, [rbx + 0x3C]          ; IMAGE_DOS_HEADER.e_lfanew
    mov  eax, [rbx + rax + 0x88]    ; OptionalHeader+0x70: DataDirectory[0].VirtualAddress
    lea  rdi, [rbx + rax]           ; VA export directory

    ; IMAGE_EXPORT_DIRECTORY:
    mov  ecx, [rdi + 0x1C]
    lea  r13, [rbx + rcx]           ; VA AddressOfFunctions
    mov  ecx, [rdi + 0x20]
    lea  rsi, [rbx + rcx]           ; VA AddressOfNames
    mov  ecx, [rdi + 0x24]
    lea  r14, [rbx + rcx]           ; VA AddressOfNameOrdinals

    xor  rcx, rcx                   ; index = 0
    mov  edx, [rdi + 0x18]          ; NumberOfNames

    ; -----------------------------------------------------------------
    ; Krok 3: Hledání WinExec podle ROR13 hashů
    ; -----------------------------------------------------------------
.hash_loop:
    cmp  rcx, rdx
    jge  .epilog                    ; nenalezeno

    mov  eax, [rsi + rcx * 4]         ; RVA názvu[index]
    lea  rax, [rbx + rax]           ; VA == pointer na string

    push rcx                        ; záloha indexu
    push rdx                        ; záloha NumberOfNames
    xor  r8d, r8d                   ; hash = 0

.hash_char:
    movzx ecx, byte [rax]
    test  ecx, ecx
    jz    .hash_done
    mov   r9d, r8d
    shr   r9d, 13                   ; >> 13
    shl   r8d, 19                   ; << 19 (= 32 - 13)
    or    r8d, r9d                  ; ROR13
    add   r8d, ecx
    inc   rax
    jmp   .hash_char

.hash_done:
    pop  rdx
    pop  rcx

    cmp  r8d, 0x0E8AFE98            ; hash WinExec
    je   .found
    inc  rcx
    jmp  .hash_loop

    ; -----------------------------------------------------------------
    ; Krok 4: Překlad indexu na VA funkce přes ordinals
    ; -----------------------------------------------------------------
.found:
    movzx eax, word [r14 + rcx * 2]   ; AddressOfNameOrdinals[index] == ordinal
    mov  eax, [r13 + rax * 4]         ; AddressOfFunctions[ordinal]  == RVA
    lea  rax, [rbx + rax]           ; VA WinExec

    ; -----------------------------------------------------------------
    ; Krok 5: Volání WinExec("calc.exe", SW_SHOW)
    ; -----------------------------------------------------------------
    lea  rcx, [rel calc]     ; 1. parametr: lpCmdLine
    mov  edx, 1                     ; 2. parametr: SW_SHOW
    call rax

    ; -----------------------------------------------------------------
    ; Závěr: Obnova registrů v opačném pořadí
    ; -----------------------------------------------------------------
.epilog:
    add  rsp, 28h
    pop  r15
    pop  r14
    pop  r13
    pop  r12
    pop  rsi
    pop  rdi
    pop  rbx
    mov  rsp, rbp                    ; obnova původního RSP
    pop  rbp
    ret

section .data
calc:
    db "calc.exe", 0

Screenshot x64dbg s otevřenou kalkulačkou v popředí. RIP ukazuje na instrukci add rsp, 28h - první instrukci epilogu po návratu z WinExec.
Shellcode pozastavený těsně po návratu z WinExec - kalkulačka v popředí potvrzuje úspěšné spuštění. RIP ukazuje na první instrukci epilogu.

Stojí za to projít prolog detailněji, protože tady se sbíhají všechny principy najednou.

Prolog začíná zálohou registru RSP do RBP a jeho zarovnáním. Teprve potom ukládáme non-volatile registry.

Následně uložíme non-volatile registry: RBX, RDI, RSI, R12, R13, R14 a R15. To je 7 pushů, tedy lichý počet, zarovnání zásobníku je po jejich aplikování narušeno. Instrukce sub rsp, 28h tento nesoulad opravuje. 32 bajtů shadow space plus 8 bajtů pro opravu zarovnání. RSP mod 16 je v tento okamžik rovno nule. Instrukce CALL uloží na zásobník návratovou adresu (8 bajtů) a RSP se posune o 8 dolů. Po vstupu do WinAPI funkce WinExec je RSP mod 16 rovno 8. Přesně v tomto stavu očekává ABI vstup do každé funkce.

Dvě věci v kódu jsme si vědomě zjednodušili. Za prvé, přecházíme po pevně daném počtu kroků v InMemoryOrderModuleList. Předpokládáme tedy, že pořadí modulů v paměti procesu bude ntdll.dll, hostitelský EXE, kernel32.dll. Toto pořadí platí na Windows 7 a novějších, ale specifikace toto pořadí nezaručuje. Robustní implementace by ověřovala jméno modulu hashováním BaseDllName. Za druhé, lea rcx, [rel calc] používá RIP-relative adresování a funguje, protože kód kompilujeme jako PE soubor. V raw injektovaném shellcodu, kde neznáme absolutní adresu dat, by byl třeba jiný přístup. To je téma, ke kterému se vrátíme v dalším dílu.

Diagram zásobníku se šesti položkami: shadow space pro R9, R8, RDX a RCX, caller frame a návratová adresa na adrese RSP+0x00
Rozložení zásobníku při vstupu do WinExec - návratová adresa na vrcholu, 32 bajtů shadow space nad ní, RSP mod 16 = 8


Pohled přes WinDbg

Než se pokusíme náš kód spustit, ukážeme si, jak vypadají použité struktury v reálném procesu. Připojíme WinDbg k běžící instanci notepad.exe a projdeme celou cestu krok za krokem.

Krok 1: PEB a InMemoryOrderModuleList

Začneme výpisem PEB aktuálního procesu:

; dt = "display type" - zobrazí strukturu podle debug symbolů z PDB
; ntdll!_PEB = typ struktury z debug symbolů ntdll.dll
; @$peb = pseudoregistr WinDbg ukazující na PEB aktuálního procesu

0:000> dt ntdll!_PEB @$peb
   +0x000 InheritedAddressSpace : 0 ''
   +0x002 BeingDebugged    : 0x1 ''
   +0x003 IsImageDynamicallyRelocated : 0y1
   ...
   +0x010 ImageBaseAddress : 0x00007ff6`97ab0000 Void
   +0x018 Ldr              : 0x00007ff9`29d338e0 _PEB_LDR_DATA
   ...

Hned na offsetu +0x003 vidíme IsImageDynamicallyRelocated : 0y1. To nám prozrazuje, že ASLR je aktivní a modul byl načten na náhodnou adresu. Nás ale zajímá Ldr na offsetu +0x018, pointer na strukturu _PEB_LDR_DATA[2], který ukrývá seznam načtených modulů.

Rozvineme ho:

; poi() = "pointer-sized integer" - dereferencuje adresu jako ukazatel
; poi(@$peb+0x18) = přečte 8-bajtovou hodnotu na adrese PEB+0x18, tedy adresu Ldr

0:000> dt ntdll!_PEB_LDR_DATA poi(@$peb+0x18)
   +0x000 Length           : 0x58
   +0x004 Initialized      : 0x1 ''
   +0x010 InLoadOrderModuleList      : _LIST_ENTRY [ 0x000001d8`c8a24400 - 0x000001d8`c8a34ab0 ]
   +0x020 InMemoryOrderModuleList    : _LIST_ENTRY [ 0x000001d8`c8a24410 - 0x000001d8`c8a34ac0 ]
   +0x030 InInitializationOrderModuleList : _LIST_ENTRY [ 0x000001d8`c8a24280 - 0x000001d8`c8a29450 ]

Struktura InMemoryOrderModuleList na offsetu +0x020 je kruhový seznam LIST_ENTRY uzlů. Projdeme ho příkazem dl:

; dl = "display linked list" - projde obousměrně propojený seznam Flink ukazatelů
; poi(poi(@$peb+0x18)+0x20) = adresa prvního uzlu InMemoryOrderModuleList
; 10 = maximální počet uzlů k zobrazení (hexadecimálně, tedy 16)

0:000> dl poi(poi(@$peb+0x18)+0x20) 10
000001d8`c8a24410  000001d8`c8a24270 00007ff9`29d33900   ; [0] ntdll.dll
000001d8`c8a24270  000001d8`c8a291e0 000001d8`c8a24410   ; [1] notepad.exe
000001d8`c8a291e0  000001d8`c8a29770 000001d8`c8a24270   ; [2] kernel32.dll
...

Každý řádek je jeden LIST_ENTRY uzel. Levá hodnota je Flink (následující uzel), pravá je Blink (předchozí uzel). Třetí položka v tomto řetězci odpovídá kernel32.dll. Od tohoto uzlu je DllBase na offsetu +0x020. To je přesně ten offset, který používáme v našem kódu: mov r12, [rax + 0x20].

Krok 2: Export directory kernel32.dll

Nyní tedy máme bázovou adresu. Teď z ní musíme získat export directory. Na offsetu +0x3C je pole e_lfanew, relativní offset PE hlavičky:

; dd = "display dwords" - zobrazí paměť jako 32-bitové hodnoty
; L1 = "length 1" - zobrazí pouze jednu hodnotu

0:000> dd 00007ff927a80000+3c L1
00007ff9`27a8003c  000000f8

PE hlavička leží na base + 0xF8. Od ní je OptionalHeader na offsetu +0x18 a DataDirectory[0] na dalším offsetu +0x70. Sečtením těchto hodnot dohromady získáme offset od začátku PE hlavičky: 0x18 + 0x70 = 0x88. Přesně tento offset máme v našem kódu v instrukci mov eax, [rbx + rax + 0x88]:

0:000> dd 00007ff927a80000+F8+88 L1
00007ff9`27a80180  000a66a0

RVA export directory je tedy 0x000a66a0. Přičteme k ní bázovou adresu a přečteme strukturu:

; La = zobrazí 10 hodnot (hexadecimálně 0xa = 10 dwordů = 40 bajtů)

0:000> dd 00007ff927a80000+000a66a0 La
00007ff9`27b266a0  00000000 06fd28ce 00000000 000aa91c
00007ff9`27b266b0  00000001 000006a2 000006a2 000a66c8
00007ff9`27b266c0  000a8150 000a9bd8

Přečtené bajty odpovídají polím struktury IMAGE_EXPORT_DIRECTORY:

+0x00  Characteristics      = 0x00000000
+0x04  TimeDateStamp        = 0x06fd28ce
+0x0C  Name (RVA)           = 0x000aa91c
+0x10  Base                 = 0x00000001
+0x14  NumberOfFunctions    = 0x000006a2   (1698 funkcí)
+0x18  NumberOfNames        = 0x000006a2   (1698 pojmenovaných exportů)
+0x1C  AddressOfFunctions   = 0x000a66c8   (RVA)
+0x20  AddressOfNames       = 0x000a8150   (RVA)
+0x24  AddressOfNameOrdinals= 0x000a9bd8   (RVA)

Ověříme jméno modulu:

; da = "display ASCII" - zobrazí paměť jako ASCII řetězec až do NULL bajtu

0:000> da 00007ff927a80000+000aa91c
00007ff9`27b2a91c  "KERNEL32.dll"

Offsety +0x1C, +0x20 a +0x24 jsou tři pole, přes která kód prochází při hledání funkce. Smyčka projde všechny pojmenované exporty a pro každý spočítá ROR13 hash, dokud nenarazí na shodu s 0x0E8AFE98.

Krok 3: Proč nestačí IAT

Než se pustíme do hashovací smyčky, musíme si položit otázku: Proč vůbec potřebujeme PEB traversal a hash resolver? Proč nestačí podívat se do IAT procesu?

IAT (Import Address Table) je tabulka funkcí, které proces staticky importuje. Kompilátor ji sestavil v době, kdy sestavoval aplikaci. Pojďme se tedy podívat, co notepad.exe skutečně importuje:

; !dh = "display headers" - rozšířený příkaz (!) zobrazující PE hlavičky modulu
; -f = zobrazí data directories (export, import, IAT, resources, ...)

0:000> !dh 00007ff6`97ab0000 -f
...
       0 [       0] address [size] of Export Directory
   309C0 [     3FC] address [size] of Import Directory
   298D8 [     B68] address [size] of Import Address Table Directory
...

; dps = "display pointer-sized values with symbols" - zobrazí ukazatele a dohledá
;        jejich symbolická jména (název modulu!název funkce) z načtených PDB
; L80 = zobrazí 0x80 (128) položek

0:000> dps 00007ff6`97ab0000+298D8 L80
00007ff6`97ad98d8  00007ff8`e81a4190 COMCTL32!ImageList_Create
...
00007ff6`97ad9a28  00007ff9`299637a0 USER32!DrawTextW
...
00007ff6`97ad9a78  00007ff9`2999dc70 USER32!MessageBoxW
...
00007ff6`97ad9cc8  00007ff9`28612470 advapi32!IsTextUnicode

COMCTL32, GDI32, USER32, advapi32, funkce pro vykreslování, dialogy, tisk, schránku. WinAPI funkce WinExec v seznamu není. Notepad.exe tuto funkci nikdy nepotřeboval a proto ji kompilátor do IAT nezahrnul.

Shellcode nemůže spoléhat na to, že cílový proces bude importovat funkci, kterou potřebuje (i když i tato situace může nastat a má pak smysl vytvořit si pro tyto případy speciální shellcode na míru, hlavně s ohledem na výslednou velikost a stopu). Proto musí jít jinou cestou. Musí nejprve najít kernel32.dll v PEB, projít její export directory a adresu funkce zjistit za běhu sám. Bez závislosti na tom, co kompilátor cílové aplikace importoval.

Krok 4: Zásobník před voláním WinExec

Pro tento krok připojíme WinDbg k jednoduchému testovacímu programu, který WinAPI funkci WinExec volá explicitně. Notepad.exe WinExec nikdy nevolá, jak jsme si ukázali v předchozím kroku, a breakpointu by tak nikdy nedosáhl.

; bp = "breakpoint" - nastaví softwarový breakpoint (int 3) na danou adresu nebo symbol
; g  = "go" - spustí proces a čeká na breakpoint nebo výjimku

0:000> bp kernel32!WinExec
0:000> g
Breakpoint 1 hit
KERNEL32!WinExec:
00007ff9`27af0b60 488bc4          mov     rax,rsp

Zastavili jsme na prvním bajtu WinExec. Zobrazíme si obsah registrů:

; r = "registers" - zobrazí aktuální hodnoty všech obecných registrů

0:000> r
rax=0000000000000001 rbx=0000000000000008 rcx=00007ff62c4e4000
rdx=0000000000000005 ...
rip=00007ff927af0b60 rsp=0000003cfe9ffaa8

Registr RCX obsahuje pointer na string "calc.exe", tedy první parametr funkce. Registr RDX obsahuje hodnotu 5 (SW_SHOW). Volací konvence funguje přesně, jak jsme popsali.

Zásobník:

; dqs = "display quadwords with symbols" - zobrazí 8-bajtové hodnoty a vyhledá symboly
; L8  = zobrazí 8 položek (8 × 8 bajtů = 64 bajtů) od vrcholu zásobníku

0:000> dqs rsp L8
0000003c`fe9ffaa8  00007ff6`2c4e269b main+0x269b      ; návratová adresa
0000003c`fe9ffab0  00000000`00000008                   ; shadow space pro RCX
0000003c`fe9ffab8  00000000`00000028                   ; shadow space pro RDX
0000003c`fe9ffac0  000001af`547e15e8                   ; shadow space pro R8
0000003c`fe9ffac8  000001af`547e1570                   ; shadow space pro R9
0000003c`fe9ffad0  00000000`00000028
0000003c`fe9ffad8  00007ff6`2c4e12ee main+0x12ee
0000003c`fe9ffae0  00000000`00000000

Diagram šesti kroků prologu shellcodu: push rbp, mov rbp rsp, and rsp, sedm pushů non-volatile registrů a sub rsp 28h s výslednou hodnotou RSP mod 16 po každém kroku.
Stav zásobníku a hodnota RSP mod 16 po každé instrukci prologu.

Na vrcholu zásobníku leží návratová adresa. Hned za ní je 32 bajtů shadow space, které caller alokoval před instrukcí CALL. WinExec je může libovolně přepsat a první instrukce mov rax, rsp naznačuje, že přesně to udělá.

Všimněme si klíčového detailu - zarovnání. Hodnota v registru RSP při vstupu do WinExec je 0x0000003cfe9ffaa8. Poslední bajt je 0xA8, tedy 168 v desítkové soustavě. 168 % 16 = 8. RSP % 16 = 8 je přesně ta hodnota, kterou Microsoft x64 ABI vyžaduje při vstupu do funkce.


Co jsme si ukázali

Microsoft x64 volací konvence není jen nějaké doporučení. Je to závazná dohoda, na které závisí každý kus kódu v systému. První čtyři parametry jdou do registrů RCX, RDX, R8 a R9. Caller alokuje shadow space velikosti 32 bajtů před každým voláním. Registr RSP musí být zarovnán na 16 bajtů těsně před instrukcí CALL. Non-volatile registry musí být po návratu obnoveny do původního stavu.

Shellcode navíc trpí problémem, který běžný PE kód nemá. Neví, v jakém stavu dostane zásobník. Proto prolog začíná zálohou registru RSP do registru RBP a jeho zarovnáním, aby byl zásobník v deterministickém stavu pro volání WinAPI a epilog dokázal registr RSP spolehlivě obnovit.


Co přijde v příštím díle

Máme první funkční shellcode, ale ne zcela dokonalý. Obsahuje dvě nedokonalosti: string "calc.exe" je uložen v datové sekci místo na zásobníku a tělo shellcodu obsahuje NULL bajty, které omezují jeho použitelnost na specifické případy přenosu. V příštím dílu obě odstraníme a přidáme i optimalizaci kódu.


Reference


Poznámka

Původní dokumentace a výzkumné poznámky byly napsány v češtině. Anglický překlad byl zpracován s využitím jazykových nástrojů na bázi AI s cílem zajistit srozumitelnost a věcnou správnost.