## Kertolasku ja jakolasku

Yhteen- ja vähennyslasku mahtuvat siististi yhteen rekisteriin. Kerto- ja jakolasku eivät: kahden 32-bittisen luvun tulo voi olla 64-bittinen, ja jakolasku tuottaa sekä osamäärän että jakojäännöksen. x86 ratkaisee tämän käyttämällä **rekisteriparia `EDX`:`EAX`** sekä tuloksena että jaettavana.
![EDX:EAX-rekisteripari kerto- ja jakolaskussa: IMUL tuottaa 64-bittisen tulon, IDIV jakaa koko parin.](sanity:image-ffcb4420e997f17be80e5b1ff6876df08fc924c2-1536x1024-png)
Tästä syystä `MUL`/`IMUL` ja `DIV`/`IDIV` ovat tällä kurssilla *yhden operandin* käskyjä: toinen operandi on aina implisiittisesti `EAX` (ja `DIV`:ssä `EDX`:`EAX`).

---

## `MUL` ja `IMUL`: kertolasku

`IMUL <lähde>` laskee `EDX:EAX = EAX × lähde` eli kertoo `EAX`:n annetulla rekisterillä (tai muistipaikalla) ja sijoittaa 64-bittisen tuloksen niin, että alemmat 32 bittiä menevät `EAX`:iin ja ylemmät 32 `EDX`:ään.

```assembly_x86
section .text

MOV EAX, 21
MOV EBX, 2
IMUL EBX          ; EDX:EAX = 21 * 2 = 42  -> EAX = 42, EDX = 0
INT 1             ; tulostaa 42
```

- `MUL` on etumerkitön kertolasku, `IMUL` etumerkillinen. Positiivisilla operandeilla, joiden tulo mahtuu 32 bittiin, molemmat antavat saman lopputuloksen: `EAX` saa tuloksen ja `EDX` on 0. Ero tulee näkyviin kahdessa tilanteessa: kun operandi tulkitaan negatiivisena (`IMUL` käyttää two's complementia, `MUL` ei) tai kun tulo kasvaa yli 32 bittiä leveäksi (`IMUL` etumerkkilaajentaa ylävuon `EDX`:ään, `MUL` nollaa sen). Esimerkkimme `21 * 2 = 42` mahtuu 32 bittiin, joten `EAX = 42` ja `EDX = 0` molemmilla.
- Jos tiedät tuloksen mahtuvan 32 bittiin (yleinen tapaus), riittää `EAX`: `EDX`:ää ei tarvitse katsoa. Mutta se *muuttuu silti*, joten jos `EDX`:ssä oli jotain tärkeää, se on nyt mennyttä.

---

## `DIV` ja `IDIV`: jakolasku

`IDIV <jakaja>` laskee `EDX:EAX / jakaja` ja sijoittaa **osamäärän `EAX`:iin** ja **jakojäännöksen `EDX`:ään**.

Tässä on helppo kompastua: jaettava on koko 64-bittinen `EDX`:`EAX`-pari. Jos jaat 32-bittisen luvun, `EDX`:n on oltava nolla (tai etumerkkilaajennus negatiiviselle); muutoin jaat aivan väärää jättiläislukua. Käytännössä etumerkillisille jaoille kääntäjä emittoi `CDQ`-käskyn, joka laajentaa `EAX`:n `EDX:EAX`:ksi automaattisesti.

```assembly_x86
MOV EAX, 100      ; jaettavan alaosa
MOV EDX, 0        ; jaettavan yläosa: NOLLAA ennen jakoa!
MOV EBX, 7        ; jakaja
IDIV EBX          ; EAX = 100 / 7 = 14   (osamäärä)
                  ; EDX = 100 mod 7 = 2  (jakojäännös)
```

### Nollalla jako kaataa ohjelman

Jos jakaja on 0, prosessori (ja Hakatemian emulaattori) heittää `Division by zero` -virheen ja suoritus pysähtyy. Tarkista jakaja ennen jakoa, jos sen arvo ei ole varmasti nollasta poikkeava:

```assembly_x86
CMP EBX, 0
JE  ohita_jako
IDIV EBX
ohita_jako:
```

---

## Miksi tämä on tärkeää reverse engineeringissä

Kun käännät korkean tason koodia, kääntäjä korvaa monet jaot ja kertolaskut bittisiirroilla ja taikavakioilla (esim. jako 10:llä muuttuu kertolaskuksi `0x66666667`:llä ja siirroksi). Mutta kun näet oikean `idiv` tai `imul` -käskyn, tiedät heti: tässä lasketaan jotain, jonka kääntäjä ei pystynyt optimoimaan pois; usein jakaja on muuttuja. `EDX`:`EAX`-pari on tunnusmerkki.

---

## Yhteenveto

- `MUL` / `IMUL <lähde>`: `EDX:EAX = EAX × lähde`. `IMUL` = etumerkillinen.
- `DIV` / `IDIV <jakaja>`: `EAX = osamäärä`, `EDX = jakojäännös`, jaettava = `EDX`:`EAX`.
- **Nollaa `EDX` ennen jakolaskua**, jos jaat 32-bittistä lukua.
- Nollalla jako pysäyttää ohjelman: tarkista jakaja epävarmoissa tapauksissa.
- Yhden operandin muoto johtuu siitä, että `EDX`:`EAX` on aina implisiittinen toinen operandi.


Kertolasku ja jakolasku

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

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

Capstone: kirjoita, käännä, debuggaa

x86-64 ABI ja kutsutavat

Yhteenveto ja jatkopolku

Loppu

x86 ASM

Kertolasku ja jakolasku

Kertolasku ja jakolasku

Hakkeroinnin oppiminen alkaa tästä