## Lue käännettyä assemblya kuten reverse engineer

![Neljä kääntäjäidiomia esiteltynä korttina: `XOR reg, reg`, `TEST reg, reg` + `JZ`, `LEA` aritmeettisena oikotienä, `SHL` kahden potenssin kertolaskuna.](sanity:image-f5fa7a67d681a8d1f28103f035f6b4f553a415ac-1200x628-png)


Olet kirjoittanut x86-assemblya. Mutta `gdb`:ssä, IDA:ssa, Ghidrassa tai radare2:ssa et yleensä kirjoita, vaan luet. Käännetty koodi ei näytä siltä, miltä kirjoittamasi koodi näyttäisi. Kääntäjät käyttävät kymmeniä yleisiä **idiomeita**: kompakteja kuvioita, joiden taakse kätkeytyy yksinkertainen korkean tason rakenne. Tämä moduuli opettaa tunnistamaan ne.

> Disassembly-näkymät käyttävät yleensä **pienaakkosia** (`mov`, `xor`, `eax`); sellaisina ne tulostuvat objdumpista, gdb:stä, IDAsta ja Ghidrasta. Tästä moduulista eteenpäin näet molempia tyylejä: omat snipettisi UPPERCASE, disassembly-listaukset lowercase.

---

## Idiomi #1: `XOR reg, reg` = "rekisteri nollaan"

Aina kun haluat asettaa rekisterin nollaan, voisit kirjoittaa `MOV EAX, 0`. Kääntäjät eivät tee niin. Sen sijaan:

```assembly_x86
section .text

XOR EAX, EAX        ; EAX = 0
INT 1               ; tulostaa 0
HLT
```

Miksi? Konekielessä `XOR EAX, EAX` on **lyhyempi** (2 tavua vs 5 tavua), nopeampi ja jopa modernit CPU:t käsittelevät sen erikoistapauksena (zero-idiom). Disassemblyssä **aina** kun näet rekisterin XORin itsensä kanssa, lue se: "tämä on nollaus".

```
xor eax, eax        ; ← eax = 0
xor ecx, ecx        ; ← ecx = 0
```

Älä mieti XORia bittioperaationa tässä: kuvio on kerralla ymmärrettävä.

---

## Idiomi #2: `TEST reg, reg` + `JZ` = "if (reg == 0)"

Kun C:ssä testaat onko muuttuja nolla, kääntäjä käyttää **`TEST`**-käskyä, ei `CMP`:tä. `TEST reg, reg` laskee `reg & reg`:n ja päivittää liput, mutta ei tallenna mihinkään. Lopputulos on sama kuin `CMP reg, 0`, mutta kompaktimpi.

```assembly_x86
section .text

MOV EAX, 0          ; oletetaan, että EAX on funktion paluuarvo
TEST EAX, EAX       ; vertaa nollaan
JZ on_nolla         ; jos EAX = 0, hyppää
MOV EAX, 100        ; muuten EAX = 100
JMP loppu
on_nolla:
MOV EAX, 42         ; EAX = 42 (tämä haara ajetaan)
loppu:
INT 1               ; tulostaa 42
HLT
```

C-vastine on yksinkertainen:

```c
if (eax == 0) eax = 42;
else eax = 100;
```

Takaisinmallinnuksessa (reverse engineering) siis: `TEST X, X` seuraa lähes aina `JZ`/`JNZ`/`JS`/`JNS`-hyppy. Käännä se mielessäsi heti: "if (X cond) ...".

@embed x86-m17-objdump-idioms

---

## Idiomi #3: `LEA` aritmetiikkaa, joka ei näytä aritmetiikalta

Kuten edellisessä moduulissa opit, `LEA` on kääntäjän rakas temppu kompakteille aritmeettisille lausekkeille.

```assembly_x86
section .text

MOV EBX, 7
LEA EAX, [EBX + EBX*4 + 1]   ; EAX = 7 + 7*4 + 1 = 36
INT 1
HLT
```

Disassemblyssä `lea eax, [ebx + ebx*4 + 1]`: älä lue sitä muistioperaationa! Lue se algebrana: `EAX = EBX*5 + 1`.

---

## Idiomi #4: Funktion alku ja loppu

Käännetyt funktiot alkavat ja päättyvät tunnistettavalla **funktiokehyksellä**. Lähes aina:

```
push ebp                ; tallenna kutsujan pohja
mov ebp, esp            ; ankkuroi uusi pohja
sub esp, N              ; varaa N tavua paikallismuuttujille
; ... funktion runko ...
mov esp, ebp            ; vapauta paikallinen muisti
pop ebp                 ; palauta kutsujan pohja
ret                     ; palaa
```

Kun selaat disassemblya ja etsit funktion rajoja, etsi `push ebp; mov ebp, esp` (alku) ja `leave; ret` tai `pop ebp; ret` (loppu). Tämä on käytännössä jokaisen kääntäjätuotetun ei-trivialin funktion tunnusmerkki; `ENTER`-käskyä ei moderneissa binääreissä juuri näe, koska se on hidas mikrokoodattu käsky, jota kääntäjät kiertävät.

Paikallismuuttujat löytyvät yleensä **negatiivisina siirtoina `EBP`:stä**:

- `[EBP - 4]` = ensimmäinen paikallinen
- `[EBP - 8]` = toinen paikallinen
- `[EBP - 12]` = kolmas, jne.

Parametrit ovat **positiivisina siirtoina**:

- `[EBP + 8]` = ensimmäinen parametri
- `[EBP + 12]` = toinen
- jne.

Vakio `8` (eikä `4` tai `0`) tulee siitä, että `[EBP]` on tallennettu vanha `EBP`, ja `[EBP + 4]` on tallennettu paluuosoite (return address); molemmat ovat 4 tavua.

---

## Idiomi #5: `JMP`-taulukko (switch-statement)

Kun C:ssä kirjoitat:

```c
switch (x) {
    case 0: ...
    case 1: ...
    case 2: ...
    case 3: ...
}
```

ja arvojen ero on pieni, kääntäjä luo yleensä **hyppytaulukon**: taulukko osoitteita, jokainen `case` yhdessä paikassa. `JMP`-käsky käyttää muuttujan arvoa indeksinä taulukkoon ja hyppää oikealle riville:

```
cmp eax, 3              ; rajatarkistus
ja default              ; jos arvo > 3, default-haaraan
jmp [taulukko + eax*4]  ; hyppää taulukosta luettuun osoitteeseen
```

Tunnistus: `cmp` rajatarkistus, sitten **`jmp` muistioperandilla, jossa on `*4` skaalaus**. Tämä on switchin paljastava sormenjälki: vaikka et heti tiedä millaisesta switchistä on kyse, tiedät ainakin että kyseessä on hyppytaulukko.

---

## Idiomi #6: Aritmeettiset oikotiet kahden potenssille

Modernit kääntäjät korvaavat:

- `* 2` → `SHL reg, 1`
- `* 4` → `SHL reg, 2`
- `* 8` → `SHL reg, 3`
- `/ 2` (etumerkitön) → `SHR reg, 1`
- `/ 4` (etumerkillinen) → `SAR reg, 2`
- `% 256` → `AND reg, 0xFF`
- `% 16` → `AND reg, 0xF`

Yleisemmin: kahden potenssilla jakaminen → bittisiirto; modulus kahden potenssilla → `AND`-maskaus. Jos näet näitä kuvioita, käännä mielessäsi takaisin kerto-/jakolaskuksi.

Ja `* 10`:lle kääntäjä saattaa kirjoittaa:

```assembly_x86
section .text

MOV EBX, 17
LEA EAX, [EBX + EBX*4]    ; EAX = EBX * 5
SHL EAX, 1                ; EAX = EAX * 2 = EBX * 10
INT 1                     ; tulostaa 170
HLT
```

Eli `LEA + SHL` = "kerro 10:llä". Tämä on kompakti versio: kaksi käskyä yhden `IMUL`:n sijaan.

---

## Idiomi #7: Funktion paluuarvo aina `EAX`:ssa

Käännetyissä C-funktioissa **paluuarvo on aina `EAX`:ssa** (tai `EDX:EAX`:ssa 64-bittisille). Jos funktion loppupuolella ennen `RET`:ää näet `MOV EAX, jotain`, se on todennäköisesti paluuarvon asetus.

```
...
mov eax, [ebp - 8]   ; valmistele paluuarvo paikallisesta muuttujasta
leave
ret                  ; palauta EAX kutsujalle
```

Vastaavasti `CALL`:n jälkeen ensimmäinen `EAX`-luenta on lähes aina paluuarvon käyttö:

```
call jokin_funktio
test eax, eax        ; ← tarkista funktion paluuarvo
jz error
```

---

## Idiomi #8: Inlinattu funktio

Joskus kääntäjä päättää **inlinata** lyhyen funktion suoraan kutsupaikkaan. Funktion runko toistuu silloin kutsuvan funktion sisällä, eikä erillistä `CALL`:a näy. Inlinattu funktio:

- Ei näy disassemblyssä erillisenä `CALL`:na.
- Ei alkua funktiolle (NASMissa: ei `global`-rivillä, ei labeloituna kutsukohteena).
- Voi pakottaa kutsujan funktiokehyksen kasvamaan (lisää paikallismuuttujia).

Inlinaus on yleinen optimointi varsinkin pienissä, usein kutsutuissa funktioissa (esim. `min`, `max`, `swap`). Reverse engineeringissä huomaat sen siitä, että koodi näyttää "toistaa itseään". Sama kuvio esiintyy monessa funktiossa.

---

## Käytännön esimerkki

Käytetään yhdessä useita idiomeja:

```assembly_x86
section .text

; C-vastine: x = arr[i] * 5 + 1; return x;
MOV EBX, 7                ; oletetaan arr[i] = 7
LEA EAX, [EBX + EBX*4 + 1]  ; EAX = 7*5 + 1 = 36   (idiomi #3)
TEST EAX, EAX             ; varmistus: paluuarvo ei ole nolla (idiomi #2)
JZ virhe
INT 1                     ; tulostaa 36
HLT
virhe:
XOR EAX, EAX              ; virheen sattuessa palauta 0 (idiomi #1)
INT 1
HLT
```

Kuusi riviä koodia, kolme idiomeista. Tyypillinen näkymä; kerran nähtynä alkaa tunnistaa hetkessä.

---

## Yhteenveto

| Idiomi | Tunnistus | C-vastine |
|---|---|---|
| `XOR reg, reg` | rekisteri XORataan itsellä | `reg = 0` |
| `TEST reg, reg` + `JZ` | TEST itsensä kanssa, hyppy | `if (reg == 0)` |
| `LEA dest, [...]` | hakasulkeet ilman muistihakua | algebrallinen yhtälö |
| `push ebp; mov ebp, esp` | funktion alku | uusi funktiokehys |
| `jmp [taulukko + reg*4]` | indeksoitu hyppy | `switch` -taulukko |
| `SHL reg, n` / `SAR reg, n` | bittisiirto vakiolla | kerro/jaa kahden potenssilla |
| `MOV EAX, jotain; RET` | aseta `EAX` ennen `RET`:ää | paluuarvo |
| Toistuva sama kuvio | ei `CALL`:a, sama silmukka | inlinattu funktio |

Disassemblyä luet pian kuin korkean tason kieltä, kun nämä kuviot ovat hallussa, mieli ei "lukita" yksittäisten käskyjen tasolle, vaan poimii idiomit suoraan.


Lue käännettyä assemblya

Opi x86-assemblyn perusteet selainpohjaisella emulaattorilla: konekielestä rekistereihin, hypyistä ja silmukoista funktioihin ja kutsupinoon. Pohjatyö reverse engineeringiä ja exploit-kehitystä varten.

Tällä kurssilla pureudutaan x86-arkkitehtuurin assemblyyn: kieleen, joka istuu suoraan konekielen päällä ja ohjaa prosessoria käsky kerrallaan. Lähdemme aivan perusteista: mitä konekieli edes on, miten prosessori sitä suorittaa, miltä numerot näyttävät bittitasolla ja miten data on tallennettu muistiin.

Hands-on-osiossa pääset kokeilemaan oppimaasi selaimessa toimivalla emulaattorilla. Kirjoitat ohjelmia, jotka liikuttavat dataa rekistereiden ja muistin välillä, vertailevat lukuja, hyppivät koodissa ehtojen mukaan, toistavat silmukoita ja lopulta kutsuvat omia funktioita kutsupinon kautta. Kaikki vaiheittain ja debuggerin keinoin tarkasteltavissa.

Tämä kurssi on tarkoitettu pohjaksi reverse engineering- ja exploit-kehityskursseille. Kun ymmärrät, miltä binäärit näyttävät prosessorille, decompiloidut funktiot ja stack-pohjaiset haavoittuvuudet alkavat avautua aivan eri tavalla.

Mitä on x86 assembly?

Prosessorin toiminta

Numerojärjestelmät

Datatyypit ja negatiiviset numerot

Endianness

Intro

Rekisterit ja niiden käyttö

Ehtolauseet ja hypyt

Aritmetiikka

Bittioperaatiot

Kertolasku ja jakolasku

Loopit

Muisti ja .data-segmentti

Funktiot ja kutsupinot

Hands-on

Bittisiirrot ja LEA

Kutsutavat

Merkkijono- ja muistioperaatiot

Stack-pohjainen puskurin ylivuoto

Lue ja ymmärrä konekoodia

NASM-perusteet

Sektiot ja symbolit

Output-formaatit ja linkitys

Linkittäminen C-kirjastoon

Makrot ja `%include`

Capstone: oma `strlen` ja write

NASM käytännössä

64-bittiseen siirtyminen

Zero-extension ja REX-prefix

System V AMD64 -kutsutapa

Pinon linjaus ja red zone

RIP-relative ja PIE

Linux syscall-ABI

Capstone: kirjoita, käännä, debuggaa

x86-64 ABI ja kutsutavat

Yhteenveto ja jatkopolku

Loppu

x86 ASM

Lue käännettyä assemblya

Lue käännettyä assemblya kuten reverse engineer

Hakkeroinnin oppiminen alkaa tästä