## Stack-pohjainen puskurin ylivuoto (buffer overflow): alustava

![Pinon näkymä, jossa paikallinen puskuri ylivuotaa ja ylikirjoittaa pinokehyksen `[saved EBP]` ja `[ret addr]` -solut `AAAA`-tavuilla.](sanity:image-b5cfe3a2c4dcbd9a46a55f0b875c04bcc1d0e6e6-1200x628-png)


Tähän asti olemme käsitelleet pinoa puhtaana: funktiot pinoavat parametrejaan ja palautusosoitteita, ja kaikki on järjestyksessä. Mutta entä jos ohjelma **kirjoittaa pinoon liikaa**? Tästä syntyy yksi tunnetuimmista bugiluokista: **stack-pohjainen puskurin ylivuoto** (stack buffer overflow). Tämä moduuli ei vielä opeta sinua exploitoimaan: exploit-kehitys on oma kurssinsa. Mutta opit *miten ja miksi* nämä haavoittuvuudet syntyvät, niin että jatkokurssissa pääset suoraan tositoimiin.

---

## Kertaus: pino kasvaa alaspäin

Muistutus moduulista "Funktiot ja kutsupinot": pino kasvaa **muistissa alaspäin**. `PUSH` pienentää `ESP`:tä; `POP` kasvattaa. Funktion alussa rakennetaan pinokehys (stack frame):

```
| edelliset parametrit |    ← korkea osoite
| paluuosoite          |    ← [EBP + 4]   ← CALL pinosi tämän
| vanha EBP            |    ← [EBP]       ← prologue (PUSH EBP) pinosi tämän
| paikallismuuttuja 1  |    ← [EBP - 4]
| paikallismuuttuja 2  |    ← [EBP - 8]
| paikallinen puskuri  |    ← [EBP - 12]  ... ja eteenpäin
| ...                  |    ← matala osoite, ESP osoittaa tänne
```

Olennaista: **paikallinen puskuri sijaitsee pinossa SAMASSA paikassa kuin paluuosoite (return address), vain matalammassa muistiosoitteessa.**

---

## Miten ylivuoto tapahtuu?

Klassinen tapaus: C-funktio varaa kiinteän kokoisen taulukon pinosta ja sitten kopioi siihen käyttäjältä saatua dataa ilman, että tarkistaa pituutta.

```c
void haavoittuva(char* input) {
    char puskuri[16];           // pinossa
    strcpy(puskuri, input);     // EI tarkista, kuinka pitkä input on
    // ...
}
```

Jos `input` on yli 16 tavua pitkä, `strcpy` jatkaa kirjoittamista taulukon päälle ja sen jälkeen: ensin paikallismuuttujien päälle, sitten **vanhan `EBP`:n päälle**, sitten **paluuosoitteen päälle**, sitten kutsujan parametrien päälle.

Pinon näkymä ennen ja jälkeen:

```
ennen ylivuotoa:                 ylivuodon jälkeen:
| paluuosoite (4 t.)  |          | AAAA  (ylikirjoitettu)|
| vanha EBP (4 t.)    |          | AAAA  (ylikirjoitettu)|
| puskuri[15]         |          | AAAA  (input-data)   |
| puskuri[14]         |          | AAAA  (input-data)   |
| ...                 |          | ...                  |
| puskuri[0]          |          | AAAA  (input-data)   |
```

Kun funktio lopulta yrittää palata (`RET`), prosessori lukee paluuosoitteen pinosta, mutta nyt se on `0x41414141` ("AAAA"), ei alkuperäinen kutsupaikka. Prosessori hyppää sinne. Ohjelma joko kaatuu (yleensä) tai, jos hyökkääjä on suunnitellut datan tarkasti, **alkaa suorittaa hyökkääjän valitsemaa koodia**.

---

## Demonstraatio emulaattorissamme

Tehdään se konkreettiseksi. Alla on ohjelma, joka kutsuu funktiota; funktio kirjoittaa pinoon liikaa ja korruptoi paluuosoitteen.

```assembly_x86
section .text

; --- pääohjelma ---
MOV EAX, 999
CALL haavoittuva
INT 1               ; jos kaikki menee oikein, tulostuisi 999
HLT

; --- haavoittuva funktio ---
haavoittuva:
PUSH EBP
MOV EBP, ESP
; Tämä funktio simuloi puskurin ylivuotoa: se kirjoittaa "huolimattomasti"
; paluuosoitteen päälle. Oikeassa C-ohjelmassa tämä tapahtuisi esim.
; strcpy-kutsulla joka kopioi liian pitkän käyttäjäsyötteen paikalliseen
; puskuriin, mutta tehdään sama eksplisiittisesti yhdellä MOVilla:
;
;   [EBP]   = vanha tallennettu EBP
;   [EBP+4] = paluuosoite (kutsujan EIP)
;
; Ylikirjoitetaan se suoraan tavuilla "AAAA":
MOV DWORD [EBP+4], 0x41414141

LEAVE
RET                  ; <-- RET lukee nyt 0x41414141 paluuosoitteena
```

Aja koodi. Tutki muistinäkymästä `EBP+4`-paikkaa ennen `RET`:ää: siellä lukee `0x41414141` alkuperäisen paluuosoitteen sijaan.

Kun `RET` ajetaan, emulaattori yrittää hypätä osoitteeseen `0x41414141` (= 1094795585 desimaalina). Osoite on validin muistialueen ulkopuolella → emulaattori heittää virheen. Oikealla CPU:lla seuraisi joko `Segmentation fault` tai (jos hyökkääjän valitsema osoite oli pätevä) hyökkääjän valitseman koodin suorittaminen.

@embed x86-m18-buffer-overflow

---

## Mitä hyökkääjä tekisi?

Klassinen "exploit": pyöräytä tarpeeksi `NOP`-täytettä ja sen perään **shellcode** (komentotulkin avaava koneenkielinen sekvenssi). Ylikirjoita paluuosoite osoittamaan johonkin puskurissa olevaan `NOP`-liu'un keskelle, kun `RET` palauttaa, prosessori "liukuu" `NOP`-liukua pitkin shellcodeen ja suorittaa sen. Hyökkääjällä on nyt komentokehotteen avaava ohjelma uhrijärjestelmässä.

Tässä on **hyvin** yksinkertaistettu kuvaus; jatkokurssi käsittelee tarkemmin shellcoden kirjoittamisen, paluuosoitteen oikeaa kohdentamista ja moderneja exploit-tekniikoita.

---

## Modernit suojaukset

Onneksi pelkkä `strcpy`:n riski ei riitä exploitiin nykyään. Modernien käyttöjärjestelmien ja kääntäjien suojaukset ovat tehneet tästä klassisesta kuviosta vaikeasti hyödynnettävän:

### Stack canary (pinokanari)

Kääntäjä lisää funktion alkuun salaisen arvon ("kanarin") pinokehyksen sisälle, paikallismuuttujien ja tallennetun runkorekisterin (saved EBP/RBP) väliin: juuri ennen sitä aluetta, jota paluuosoitteen ylikirjoitus joutuisi peittämään. Funktion lopussa, ennen `RET`:ää, kanari tarkistetaan. Jos se on muuttunut, ohjelma kaatuu hallitusti (`__stack_chk_fail`). Hyökkääjän on vaikea ylikirjoittaa paluuosoitetta tietämättä kanarin arvoa.

### ASLR (Address Space Layout Randomization)

Käyttöjärjestelmä sijoittaa pinon, heap-alueen ja kirjastot satunnaisiin osoitteisiin joka käynnistyksellä. Hyökkääjä ei voi ennakolta tietää, mihin paluuosoite osoittaa; hänen täytyy ensin **vuotaa** osoitteita jollain toisella haavoittuvuudella.

### NX bit / DEP (Data Execution Prevention)

Pinon muistialueet merkitään suorittamattomiksi eli vaikka pinoissasi olisi shellcodea, prosessori kieltäytyy suorittamasta sitä. Hyökkääjän täytyy turvautua **return-oriented programming** (ROP) -tekniikkaan: koota hyökkäys olemassa olevista koodinpätkistä, joita yhdistellään paluuosoiteketjuilla. Tämä on jatkokurssin keskeisin tekniikka.

### Stack canaryn, ASLR:n ja NX:n yhdistelmä

Yhdessä nämä tekevät klassisesta "shellcode pinoon, paluuosoite yli" -hyökkäyksestä lähes käyttökelvottoman. Moderni exploit-kehitys on ennen kaikkea taitoa **kiertää** näitä suojauksia: ROP-ketjut, info-vuodot, heap-feng-shui, JIT-spraying. Mutta kaikki tämä rakentuu sille perustietämykselle, että pino + funktiokehys + paluuosoite ovat hyökkäysvektori.

---

## Yhteenveto

- Paikallisen puskurin ylivuoto voi ylikirjoittaa pinon muut arvot: muut paikallismuuttujat, vanhan `EBP`:n ja erityisesti **paluuosoitteen**.
- Kun funktio `RET`-käskyllä palaa, prosessori hyppää paluuosoitteen mukaan: eli hyökkääjän valitsemaan paikkaan, jos hän on saanut sen ylikirjoitetuksi.
- Tämä on **stack-pohjainen puskurin ylivuoto** (`stack buffer overflow`): yksi vanhimmista ja klassisimmista haavoittuvuusluokista.
- Modernit suojaukset (stack canary, ASLR, NX, DEP) tekevät tällaisten exploit-yritysten naivin version käyttökelvottomaksi. Niiden kiertäminen on **exploit-kehityskurssin** ydinsisältöä.


Stack-pohjainen puskurin ylivuoto

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

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

Stack-pohjainen puskurin ylivuoto

Stack-pohjainen puskurin ylivuoto (buffer overflow): alustava

Hakkeroinnin oppiminen alkaa tästä