## NASM-perusteet: pois selaimesta

![`nasm` → objektitiedosto → `ld` → ajettava binääri. Linuxin `int 0x80` `exit`-syscall ja paluuarvo `42` shellistä.](sanity:image-bdcb6fa391f00f111ce25f45e08c8d9502ab423f-1200x628-png)


Tähän asti olemme käyttäneet selaimessa toimivaa emulaattoria. Hyvä oppimistyökalu, mutta piilottaa paljon: oikeaa muistia, prosessoria, käyttöjärjestelmää sekä oikeaa kääntäjä- ja linkkeri-työkaluketjua. Tämä moduuli vie sinut **oikeaan ympäristöön**: siihen, missä assembly käännetään oikealla assemblerilla (**NASM**), linkataan oikealla linkkerillä (**ld**) ja ajetaan oikeana Linux-prosessina.

Tämän jälkeen mikä tahansa muu x86-koodi, jota katsot reverse engineeringissä tai exploit-kehityksessä, näyttää tutulta.

> Moduulin lopussa pääset itse kokeilemaan: labraympäristössä on Debian-pohjainen Linux-kone, jossa `nasm`, `gdb`, `gcc-multilib` ja muu työkalupakki on valmiina. Tällä sivulla käymme työnkulun läpi ensin demona, jotta tiedät mitä odottaa.

---

## Mikä on NASM?

**NASM** (Netwide Assembler) on yleisimmin käytetty x86-assembler. Sen syntaksi on **Intel-tyylinen**: sama kuin emulaattorimme ja sama kuin IDAn / Ghidran disassembly-näkymä. (Vaihtoehto on AT&T-syntaksi, jota gdb käyttää oletuksena ja `objdump` tulostaa oletuksena (ilman `-M intel`-lippua), mutta siitä lisää myöhemmin.)

NASM lukee `.asm`-tiedoston ja tuottaa **objektitiedoston** (`.o`). Linkkeri **ld** ottaa objektitiedoston (tai useita) ja tuottaa lopullisen suoritettavan binäärin.

```
file.asm  --(nasm)-->  file.o  --(ld)-->  file (binary)
```

---

## Ensimmäinen NASM-ohjelma: exit-koodi paluuna

Aloitetaan kaikkein yksinkertaisimmasta: ohjelma joka vain päättyy paluuarvolla **42**. Linuxissa prosessin paluuarvo (`echo $?` shellissä) tulee `exit`-syscallista, jota kutsutaan rekisterin `EBX` arvolla.

Lähdetiedosto `exit.asm` näyttää tältä:

```nasm
; exit.asm: 32-bittinen NASM, päättyy paluuarvolla 42

section .text
    global _start          ; ld etsii ohjelman aloituspisteen

_start:
    mov ebx, 42            ; exit-statuksen numero
    mov eax, 1             ; syscall-numero: exit (1)
    int 0x80               ; syscall-keskeytys (32-bit Linuxin tapa)
```

Käännös `nasm`:lla, linkitys `ld`:llä ja ajo Linux-shellissä menevät näin:

```sh
nasm -f elf32 -o exit.o exit.asm
ld -m elf_i386 -o exit exit.o
./exit
echo $?      # tulostaa 42
```

Terminaalissa se näyttää tältä:

@embed m20-nasm-toolchain

Ensimmäinen oikea x86-binääri valmis. Huomaa:

- `nasm -f elf32` kertoo NASMille, että haluamme **32-bittisen ELF-objektin** (Linuxin oma binääriformaatti).
- `ld -m elf_i386` linkittää 32-bittiseksi (`elf_i386` = 32-bit x86 ELF).
- Tuloksena syntyy ajettava `exit`-binääri, jonka paluuarvo `echo $?` paljastaa.

---

## Mitä konekielessä on?

Käännetty binääri sisältää muutakin kuin ohjelman koodia: ELF-header, sektiot, debug-tiedot. Mutta `.text`-sektio on se, mikä prosessori suorittaa. Voit tutkia sitä työkalulla **`objdump`**:

```sh
objdump -d exit
```

Tulostuksessa näet jotain tällaista (osoitteet voivat vaihdella):

```
08049000 <_start>:
 8049000:	bb 2a 00 00 00       	mov    $0x2a,%ebx
 8049005:	b8 01 00 00 00       	mov    $0x1,%eax
 804900a:	cd 80                	int    $0x80
```

Vasemmalla on **osoite**, keskellä **konekielen tavut** ja oikealla **disassembloitu mnemonic-muoto**. Huomaa:

- `0x2a` = 42 (`mov $0x2a, %ebx` = `MOV EBX, 42`).
- `cd 80` on `INT 0x80`-käskyn konekielinen koodaus.
- Mnemoniikan järjestys on **AT&T-tyyliä** (`mov src, dst`): toisinpäin kuin Intel/NASM. Älä hämmenny.

Voit pakottaa `objdump`:in Intel-tyyliin:

```sh
objdump -d -M intel exit
```

Tästä lähtien `objdump -M intel` on hyvä tottumus, jos olet tottunut Intel-syntaksiin (kuten kurssimme on käyttänyt).

---

## syscall-numerot ja `int 0x80`

`int 0x80` on **32-bittisen Linuxin** tapa kutsua käyttöjärjestelmää. Ennen `int 0x80`:ää asetat:

- `EAX` = syscall-numero (esim. 1 = exit, 4 = write)
- `EBX`, `ECX`, `EDX`, `ESI`, `EDI`, `EBP` = parametrit järjestyksessä (max 6)

Esim. `write(fd, buf, count)`-syscall (numero 4) tulostaisi tekstiä:

```nasm
section .data
    msg: db "Hei!", 10       ; teksti + uusi rivi (10 = '\n')
    msglen: equ $ - msg      ; lasketaan pituus käännösaikana

section .text
    global _start
_start:
    mov edx, msglen          ; parametri 3: pituus
    mov ecx, msg             ; parametri 2: osoite
    mov ebx, 1               ; parametri 1: file descriptor (1 = stdout)
    mov eax, 4               ; syscall: write
    int 0x80

    mov ebx, 0               ; exit status 0
    mov eax, 1               ; syscall: exit
    int 0x80
```

Tämä on **oikea ohjelma**: se tulostaa stdoutiin ilman libc:tä, ilman `printf`:ää, ilman mitään välikäsiä. Pelkkä asm + Linux-syscall.

---

## Vihjeitä Linux-työnkulkuun

- Vakio-NASM-virhe: "operand size mismatch" tarkoittaa että rekisterin ja arvon koot eivät täsmää. Tarkista että käytät `EAX` vs `RAX` oikealle bittisyydelle.
- Jos saat "fatal: unable to open file": olet luultavasti väärässä hakemistossa. `pwd` kertoo missä olet.
- `objdump -d binary | less` antaa hyvät selausnäppäimet (`/` haku, `q` poistuminen).

---

## Yhteenveto

- Oikea NASM-työnkulku: kirjoita `.asm` → `nasm -f elf32 ...` → `ld -m elf_i386 ...` → aja.
- Linux-syscall 32-bittisessä koodissa: aseta `EAX` syscallin numero, `EBX`-`EDI` parametrit, `int 0x80`.
- `objdump -d -M intel` näyttää konekielen Intel-syntaksissa: sama mihin olet tottunut.
- Tämä ympäristö (oikeat binäärit, oikea muisti, oikeat osoitteet) on **sama** mistä reverse engineering ja exploit-kehitys lähtevät.

Kirjoita 32-bittinen NASM-ohjelma joka päättyy paluuarvolla 42. Käännä se `~/exit`-tiedostoksi (`nasm -f elf32 -o exit.o exit.asm`, sitten `ld -m elf_i386 -o exit exit.o`). Labra ajaa binäärin ja tarkistaa paluukoodin.

Exit 42

Kirjoita 32-bittinen NASM-ohjelma `~/exit.asm`, käännä ja linkitä se `~/exit`-binääriksi ja saata se päättymään exit-koodilla 42.

Exit 42: ensimmäinen NASM-binäärisi

NASM-perusteet

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

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

NASM-perusteet

NASM-perusteet: pois selaimesta

Hakkeroinnin oppiminen alkaa tästä