## Kutsutavat: `cdecl`, `stdcall`, `fastcall`

![`cdecl` / `stdcall` / `fastcall` -kutsutapojen vertailutaulu: pinon näkymä ennen kutsua, kuka siivoaa pinon, paluuarvo `EAX`/`RAX`:ssä.](sanity:image-09deefdf3ce0cd254c941fa98ac396ca8cd62297-1200x628-png)


Edellisessä funktio-moduulissa rakensimme funktiokutsuja `cdecl`-tyyliin: parametrit pinoon oikealta vasemmalle, paluuarvo `EAX`:iin, kutsuja siivoaa pinon. Mutta `cdecl` ei ole ainoa tapa. Kun reverse engineeraat valmista binääriä, ensimmäinen analyysityö on tunnistaa **kutsutapa (calling convention)**: se kertoo, miltä funktion rajat ja parametrit näyttävät.

---

## `cdecl`: C:n perinteinen kutsutapa (32-bittinen)

Kertaus moduulista "Funktiot ja kutsupinot":

- Parametrit pinotaan **oikealta vasemmalle** (viimeinen pinotaan ensin).
- Paluuarvo jätetään `EAX`-rekisteriin (tai `EDX:EAX`-pariin 64-bittisille).
- **Kutsuja siivoaa pinon** `CALL`:n jälkeen: `ADD ESP, N` jossa `N` = parametrien yhteenlaskettu koko.
- Tukee muuttuvan määrän parametreja (esim. `printf`), koska kutsuja tietää aina kuinka monta argumenttia hän pinosi.

```assembly_x86
section .text

; --- pääohjelma: kutsutaan summa(100, 234) ---
PUSH 234              ; toinen parametri (oikealta vasemmalle)
PUSH 100              ; ensimmäinen parametri
CALL summa
ADD ESP, 8            ; CALLER siivoaa parametrit (2 * 4 tavua)
INT 1                 ; tulostaa 334
HLT

summa:
PUSH EBP
MOV EBP, ESP
MOV EAX, [EBP + 8]    ; ensimmäinen parametri
ADD EAX, [EBP + 12]   ; toinen parametri
LEAVE
RET
```

Disassemblyn tunnistus: jokaisen `CALL`:n jälkeen seuraa `ADD ESP, N`. Jos näet sen, koodi käyttää `cdecl`:ä.

---

## `stdcall`: Win32 API:n kutsutapa

Microsoftin Windowsin Win32 API käyttää **`stdcall`**:ia. Erot `cdecl`:iin:

- Parametrit pinotaan **samoin** (oikealta vasemmalle).
- Paluuarvo on edelleen `EAX`:ssa.
- **Funktio itse siivoaa pinon** käyttämällä `RET N`-muotoa, jossa `N` on parametrien koko.

```assembly_x86
section .text

PUSH 234
PUSH 100
CALL summa            ; EI siivousta CALLin jälkeen: RET tekee sen
INT 1
HLT

summa:
PUSH EBP
MOV EBP, ESP
MOV EAX, [EBP + 8]
ADD EAX, [EBP + 12]
LEAVE
RET                   ; (oikeassa Win32-koodissa tämä olisi `RET 8`)
```

Tunnistus: `CALL` ilman seuraavaa `ADD ESP, N`:ää, ja funktion loppu päättyy `RET N`-käskyyn (ei pelkkä `RET`). Tämä on tunnusmerkki Win32-koodista.

Huom: Hakatemian emulaattori tukee vain `RET`-käskyä ilman immediate-vakiota; todellisuudessa stdcallin `RET N` on **kutsutun funktion** atominen operaatio, joka palaa ja siivoaa pinon samalla, ilman että kutsuva koodi joutuu siivoamaan.

---

## `fastcall`: ensimmäiset parametrit rekistereihin

`fastcall` (Microsoft 32-bittinen) siirtää **kaksi ensimmäistä parametria rekistereihin** `ECX` ja `EDX`. Loput menevät pinoon oikealta vasemmalle. Kutsuttu funktio siivoaa pinon (`stdcall`:n tapaan).

- Parametri 1 → `ECX`
- Parametri 2 → `EDX`
- Parametri 3+ → pino (oikealta vasemmalle)
- Paluuarvo → `EAX`

Tunnistus: kutsupisteessä `MOV ECX, ...` ja `MOV EDX, ...` ennen `CALL`:a; funktion alussa `ECX` ja `EDX` käytössä parametreina ilman, että niitä haetaan pinosta.

---

## Kutsuja-tallennettavat vs kutsuttu-tallennettavat rekisterit

Kun funktio kutsuu toista funktiota, jotkin rekistereistä voivat muuttua kesken kaiken. Tärkeää tietää: **kuka vastaa minkäkin rekisterin säilyttämisestä?**

### Kutsuja-tallennettavat (caller-saved, "scratch")

Funktio saa **muuttaa** näitä vapaasti, ja kutsuja olettaa, että ne voivat olla mitä tahansa kutsun jälkeen. Jos haluat säilyttää arvon, **kutsuja** vastaa pinoamisesta ennen `CALL`:a.

- `EAX`, `ECX`, `EDX`

### Kutsuttu-tallennettavat (callee-saved, "preserved")

Funktion täytyy palauttaa nämä **sellaisina kuin ne olivat** kutsuhetkellä. Yleinen kuvio: funktion alussa `PUSH EBX/ESI/EDI`, lopussa `POP` käänteisessä järjestyksessä.

- `EBX`, `ESI`, `EDI`, `EBP`

```assembly_x86
section .text

; kutsuja
MOV EAX, 7
MOV EBX, 11
CALL aliohjelma
; EAX voi olla mitä tahansa nyt (caller-saved)
; EBX on edelleen 11 (callee-saved)
INT 1
HLT

aliohjelma:
PUSH EBP
MOV EBP, ESP
PUSH EBX                ; tallenna kutsuttu-tallennettava ennen käyttöä
MOV EBX, 999            ; käytetään EBX:ää sisäisesti
MOV EAX, 42             ; muutetaan EAX (caller-saved, ei tarvitse säilyttää)
POP EBX                 ; palauta alkuperäinen EBX
LEAVE
RET
```

Tämä sopimus on **kompromissi**: caller-saved-rekistereiden käyttö funktion sisällä on nopeampaa (ei pinoamisia), mutta jos kutsuja haluaa niiden säilyvän, hänen täytyy itse pinota ne ennen `CALL`:a.

---

## Lyhyt katsaus x86-64:n kutsutapoihin

64-bittinen x86 jätti pino-vetoisen kutsumallin lähes kokonaan taakseen. Sen sijaan:

- **System V AMD64** (Linux, macOS): ensimmäiset 6 parametria rekistereihin `RDI`, `RSI`, `RDX`, `RCX`, `R8`, `R9`. Paluuarvo `RAX`. Caller-saved: `RAX`, `RCX`, `RDX`, `RSI`, `RDI`, `R8`-`R11`.
- **Microsoft x64** (Windows): ensimmäiset 4 parametria rekistereihin `RCX`, `RDX`, `R8`, `R9`. Paluuarvo `RAX`. Kutsuja varaa lisäksi 32 tavua "shadow space" pinosta.

Käsitteet ovat samat (parametrit, paluuarvot, kutsuja-/kutsuttu-tallennettavat): vain rekistereiden ja pinon roolit eroavat. Kun astut 64-bittiseen maailmaan, lue alustasi ABI-dokumentaatio läpi.

---

## Yhteenveto

| Konventio | Parametrit | Pino siivotaan | Tunnusmerkki |
|---|---|---|---|
| `cdecl` (32-bit C) | pino, oik→vas | kutsuja: `ADD ESP, N` | `ADD ESP` joka `CALL`:n jälkeen |
| `stdcall` (Win32) | pino, oik→vas | kutsuttu: `RET N` | `RET N` funktion lopussa |
| `fastcall` (MS32) | `ECX`, `EDX`, sitten pino | kutsuttu: `RET N` | `MOV ECX/EDX` ennen `CALL`:a |
| SystemV AMD64 | `RDI`, `RSI`, `RDX`, `RCX`, `R8`, `R9` | - rekisteripohjainen | 64-bittiset rekisterit kutsupisteissä |

Reverse engineeringissä ensimmäinen tehtävä funktion analyysissa on tunnistaa kutsutapa. Sen jälkeen tiedät tarkalleen mistä parametrit löytyvät, mihin paluuarvo palautetaan ja mitä rekistereitä pidetään pyhinä.


Kutsutavat

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

Merkkijono- ja muistioperaatiot

Lue käännettyä assemblya

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

Kutsutavat

Kutsutavat: cdecl, stdcall, fastcall

Hakkeroinnin oppiminen alkaa tästä

Kutsutavat: `cdecl`, `stdcall`, `fastcall`