## Capstone: kirjoita, käännä, debuggaa

![`factorial(5)`-funktion rekursiivinen kutsuketju pinossa: viisi sisäkkäistä `factorial`-kehystä, kukin `n` ja paluuosoite.](sanity:image-26e0c841d6a55f7c23a5a9de02f9041d80d0a4af-1200x628-png)

> "Capstone" on tässä kurssin **päätöshanke**; ei sekoitettava reverse engineering -kentän [Capstone-disassemblerikirjastoon](https://www.capstone-engine.org/), johon palaat seuraavalla kurssilla.

Tähän asti olet:

- Kirjoittanut x86-assemblya kurssimme emulaattorissa.
- Lukenut käännetyn koodin idiomeja (`LEA`, `XOR reg, reg`, `TEST`/`JZ`).
- Käännellyt NASM-ohjelmia oikealla `nasm`+`ld`-työkaluparilla, ensin 32-bittisenä, sitten 64-bittisenä.
- Oppinut gdb:n perusteet: breakpointit, askelletus, rekisterit, muisti.

Aika yhdistää kaikki.

---

## Tehtävä

Kirjoita **64-bittinen NASM-ohjelma**, joka:

1. Laskee `factorial(5) = 120` rekursiivisella tai iteratiivisella funktiolla.
2. Päättyy paluuarvolla `120` (eli `exit(120)`).

Vaatimukset:

- Funktion täytyy olla **omana funktionaan** (call/ret), ei inline-koodina `_start`:n sisällä.
- Käytä **System V** -kutsutapaa: parametri (`5`) menee `RDI`:hin, paluuarvo `RAX`:ssä.
- Toimi pinon kanssa siististi: älä jätä sitä korruptoituneeksi.

Käännä `~/fact`-nimiseksi (`nasm -f elf64`, sitten `ld`). Labra ajaa binäärin ja tarkistaa, että `echo $?` antaa `120`.

---

## Vihjeitä

### Iteratiivinen ratkaisu (helpompi)

Käytä silmukkaa ja kaksi rekisteriä: yksi kertymälle (`RAX`), yksi laskurille:

```assembly_x86
; pseudokoodi:
; rax = 1                ; tulos
; rcx = rdi              ; jäljellä olevia kertaa
; while (rcx > 1) { rax *= rcx; rcx-- }
; return rax
```

### Rekursiivinen ratkaisu (haastavampi, oppivampi)

Klassinen rekursio:

```c
factorial(n):
    if (n <= 1) return 1
    return n * factorial(n - 1)
```

Tämä vaatii **call/ret-mekaniikan** ja **`RBX`:n säilyttämisen** (callee-saved!). Stack frame -tekniikka on moduulista "Funktiot ja kutsupinot" kerrattavissa, mutta 64-bittisesti:

- `RSP`:n täytyy olla **16-tavuun kohdistettu** ennen `call`:ia (System V ABI).
- Helppo tapa: `push rbp; mov rbp, rsp` riittää tasaamiseen, koska `call` painaa 8-tavuisen paluuosoitteen + `push rbp` painaa 8 tavua = 16 tavua linjassa.

### Kertominen 64-bittisessä

`IMUL` toimii joko yhden tai kahden operandin muodossa:

```assembly_x86
IMUL RBX                  ; RDX:RAX = RAX * RBX  (kuten 32-bit)
IMUL RAX, RBX             ; RAX = RAX * RBX  (uudempi 2-operandin muoto)
IMUL RAX, RBX, 3          ; RAX = RBX * 3   (3-operandin muoto, vakio)
```

Faktoriaalille kahden operandin muoto on yleensä siisteintä:

```assembly_x86
IMUL RAX, RCX             ; rax *= rcx
```

### exit-syscall 64-bitissä

Kuten moduulissa "64-bittiseen siirtyminen":

```nasm
mov rdi, rax              ; siirrä paluuarvo exit-statukseksi
mov rax, 60               ; syscall: exit
syscall
```

### Debuggaus gdb:ssä

Kun ohjelma ei toimi:

1. `gdb -q ~/fact`
2. `set disassembly-flavor intel` (tai laita `~/.gdbinit`:iin)
3. `b _start` ja `b factorial`
4. `run`, sitten `disas` ja `info reg` joka pysäytyksessä
5. Kun lähestyt `ret`:iä, varmista että `RAX` on `120`

---

## Yhteenveto

Tämä capstone testaa kaikkea kurssin keskeisistä asioista:

- Asm-syntaksi (NASM, Intel-tyyli, kommentit, labelit, sektiot)
- 64-bittiset rekisterit, kutsutapa (calling convention), syscalls
- Funktiokutsut ja stack frame -mekaniikka
- Aritmetiikka (`IMUL`, `DEC`/`SUB`, ehdolliset hypyt)
- Toolchain (nasm + ld + ajaminen + paluuarvon tarkistus)
- gdb (jos koodi ei toimi heti)

Kun labra hyväksyy, olet tehnyt täyden matkan emulaattorista oikean konekielen kirjoittamiseen, kääntämiseen, ajamiseen ja debuggaukseen.


Kirjoita 64-bittinen NASM-ohjelma, jossa on `factorial`-funktio (omana funktiona, ei inlinena). Kutsu sitä arvolla 5 ja päätä prosessi paluukoodilla 120. Käännä se `~/fact`-tiedostoksi. Labra ajaa binäärin ja tarkistaa exit-koodin.

Factorial(5) = 120

Kirjoita 64-bittinen NASM-ohjelma `~/fact`, jossa on oma `factorial`-funktio: kutsu sitä arvolla 5 ja päätä prosessi paluukoodilla 120.

Capstone: 64-bittinen factorial(5)

Capstone: kirjoita, käännä, debuggaa

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

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

x86-64 ABI ja kutsutavat

Yhteenveto ja jatkopolku

Loppu

x86 ASM

Capstone: kirjoita, käännä, debuggaa

Capstone: kirjoita, käännä, debuggaa

Hakkeroinnin oppiminen alkaa tästä