## 64-bittiseen siirtyminen

![`RAX` (64 bit) sisältää `EAX`:n (32) joka sisältää `AX`:n (16) joka sisältää `AH`:n ja `AL`:n; System V kutsutapa siirtää parametrit rekistereihin.](sanity:image-a4accafb9585b678befce0ac4ef8675598de8020-1200x628-png)


Tähän asti olemme kirjoittaneet 32-bittistä x86:tta. Mutta lähes kaikki, mitä reverseroit tai exploitoit nykyään, on **x86-64** (myös tunnettu nimellä **AMD64** tai **x64**). Tämä moduuli vie sinut käsiksi 64-bittiseen maailmaan: uudet rekisterit, uusi kutsutapa (calling convention), uusi syscall-malli.

Käsitteet ovat samat: rekisterit, pino, hypyt, funktiot. Mutta leveys ja sopimukset eroavat. Sieltä lähtien onkin "vain enemmän bittejä".

---

## Uudet rekisterit

32-bittinen `EAX` on 64-bittisessä koodissa **`RAX`**:n alempi puolikas. Samoin koko rekisterijoukko on laajennettu 64-bittiseksi ja **kahdeksan uutta rekisteriä** on lisätty:

| 64-bit | 32-bit (alempi 32) | 16-bit | 8-bit |
|---|---|---|---|
| `RAX` | `EAX` | `AX` | `AL` |
| `RBX` | `EBX` | `BX` | `BL` |
| `RCX` | `ECX` | `CX` | `CL` |
| `RDX` | `EDX` | `DX` | `DL` |
| `RSI` | `ESI` | `SI` | `SIL` |
| `RDI` | `EDI` | `DI` | `DIL` |
| `RBP` | `EBP` | `BP` | `BPL` |
| `RSP` | `ESP` | `SP` | `SPL` |
| `R8` | `R8D` | `R8W` | `R8B` |
| `R9` | `R9D` | `R9W` | `R9B` |
| `R10`-`R15` | `R10D`-`R15D` | ... | ... |

Tärkeä yksityiskohta: kun kirjoitat 32-bittiseen alemman puoliskoon (esim. `MOV EAX, 0x1234`), **ylempi 32 bittiä nollautuu automaattisesti**:

```assembly_x86
; ennen: RAX = 0xDEADBEEF12345678
MOV EAX, 0                ; nyt RAX = 0x0000000000000000, EI 0xDEADBEEF00000000!
```

Tämä on tarkoituksellinen optimointi (mahdollistaa lyhyempiä koodauksia), mutta se yllättää: jos haluat säilyttää `RAX`:n ylemmän puoliskon, käytä `RAX`:n täysleveys-versiota tai 16/8-bittisiä osia (jotka EIVÄT nollaa muuta).

---

## SystemV-kutsutapa (Linux, macOS)

64-bittinen Linux ja macOS käyttävät **System V AMD64** -kutsutapaa funktiokutsuihin. Ensimmäiset 6 parametria menevät rekistereihin:

| Parametri | Rekisteri |
|---|---|
| 1 | `RDI` |
| 2 | `RSI` |
| 3 | `RDX` |
| 4 | `RCX` |
| 5 | `R8` |
| 6 | `R9` |

Loput parametrit menevät pinoon. Paluuarvo on `RAX`:ssä (tai `RDX:RAX`:ssä jos arvo on yli 64 bittiä).

**Caller-saved** (kutsuja tallentaa jos haluaa säilyttää): `RAX`, `RCX`, `RDX`, `RSI`, `RDI`, `R8`-`R11`.

**Callee-saved** (funktion täytyy palauttaa): `RBX`, `RBP`, `R12`-`R15`.

---

## syscallit 64-bittisessä Linuxissa

32-bitissä käytimme `int 0x80`:aa. 64-bitissä syscallit kutsutaan **`syscall`**-käskyllä, jolla on oma kutsutapa:

| Parametri | Rekisteri |
|---|---|
| syscall-numero | `RAX` |
| 1 | `RDI` |
| 2 | `RSI` |
| 3 | `RDX` |
| 4 | `R10` *(ei `RCX`; kts. alla)* |
| 5 | `R8` |
| 6 | `R9` |

Syscall-numerot ovat **eri** kuin 32-bitissä: `write` on 1 (ei 4), `exit` on 60 (ei 1). Numerot löytyvät `/usr/include/asm/unistd_64.h`:sta tai netin syscall-taulukoista.

> Miksi `R10` eikä `RCX` parametrille 4? Itse `syscall`-käsky tallentaa paluuosoitteen (RIP) rekisteriin `RCX` ja flagit `R11`:een ennen kuin kerneliin hypätään, joten `RCX` ei voi kantaa parametria yli kutsun. System V valitsi `R10`:n paikkapelaajaksi, jotta C-ABIa ja syscall-ABIa voidaan kuitenkin pitää muuten symmetrisinä (kaikki muut viisi parametrirekisteriä `RDI`, `RSI`, `RDX`, `R8`, `R9` yhtenevät).

---

## "Hei!" 64-bittisesti

Sama tervehdys-ohjelma kuin viime moduulissa, mutta 64-bittisessä:

```nasm
; hei.asm: 64-bittinen NASM, tulostaa "Hei!\n"

section .data
    msg: db "Hei!", 10
    msglen: equ $ - msg

section .text
    global _start
_start:
    ; write(stdout, msg, msglen)
    mov rdx, msglen        ; parametri 3: pituus
    mov rsi, msg           ; parametri 2: osoite
    mov rdi, 1             ; parametri 1: fd (1 = stdout)
    mov rax, 1             ; syscall: write
    syscall

    ; exit(0)
    mov rdi, 0             ; exit status
    mov rax, 60            ; syscall: exit
    syscall
```

Käännös on hieman erilainen:

```sh
nasm -f elf64 -o hei.o hei.asm
ld -o hei hei.o
./hei                  # tulostaa: Hei!
```

`-f elf64` (ei `elf32`). `ld` ilman `-m elf_i386`; oletus on 64-bit ELF.

@embed x86-m21-64bit-toolchain

---

## `objdump` 64-bittisellä koodilla

Sama työkalu, sama lippu. Nyt näet pidempiä konekielen koodauksia ja `R`-alkuisia rekistereitä:

```sh
objdump -d -M intel hei
```

Output sisältää nyt mm. `mov rax, 0x3c` (= 60, exit-syscall) ja `syscall`-mnemonic. Vertaa edellisen moduulin `int 0x80`-tulostukseen; formaattieron näet heti.

---

## RIP-suhteellinen osoitus

64-bittisessä koodissa muistihaut käyttävät usein **RIP-suhteellista** osoitusta. Esimerkiksi `[rel msg]` tarkoittaa "msg:n osoite suhteessa nykyiseen `RIP`:iin", ei absoluuttinen osoite. Tämä on osa **Position Independent Code** (PIC) -mallia, joka tekee ohjelmasta uudelleenladattavan mihin tahansa muistiin (ASLR mahdollistuu).

```nasm
lea rsi, [rel msg]         ; lataa msg:n osoite RSI:iin RIP-suhteellisesti
```

Reverse engineeringissä `LEA RAX, [rip + 0x12345]` on **erittäin** yleinen; sillä tavalla 64-bittinen koodi viittaa globaaleihin muuttujiin ja vakioihin.

---

## Yhteenveto

- 64-bittiset rekisterit: `RAX`/`RBX`/.../`RDI`/`RBP`/`RSP` + uudet `R8`-`R15`. Alemmat osat (`EAX`, `AX`, `AL`) toimivat edelleen.
- `MOV EAX, X` **nollaa** `RAX`:n ylemmän puoliskon: yleinen yllätys reverse engineeringissä.
- SystemV-kutsutapa: parametrit `RDI`, `RSI`, `RDX`, `RCX`, `R8`, `R9`. Paluuarvo `RAX`.
- Syscallit: `syscall`-käsky (ei `int 0x80`), numero `RAX`:ssä, parametri 4 menee `R10`:een (ei `RCX`:ään).
- `nasm -f elf64` + `ld` ilman `-m`-lippua = 64-bittinen ELF.
- RIP-suhteellinen osoitus on PIC-koodin perusasia, näet sen jatkuvasti modernissa disassemblyssä.


Kirjoita 64-bittinen NASM-ohjelma joka tulostaa stdoutiin tekstin `Hei!` ja päättyy paluuarvolla 0. Käännä se `~/hei`-tiedostoksi. Labra ajaa binäärin ja vertaa stdoutia.

Hei! 64-bittisesti

Kirjoita 64-bittinen NASM-ohjelma `~/hei`, joka tulostaa stdoutiin `Hei!` ja päättyy normaalisti.

Hei, 64-bittisesti: write-syscall stdoutiin

64-bittiseen siirtyminen

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ä

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

64-bittiseen siirtyminen

64-bittiseen siirtyminen

Hakkeroinnin oppiminen alkaa tästä