## Merkkijono- ja muistioperaatiot: `MOVS`, `STOS`, `LODS`, `SCAS` ja `REP`-etuliite

![`REP MOVSB` -kuvio: `ESI` lukee ja `EDI` kirjoittaa, `ECX` toimii laskurina: tämä on `memcpy` koneenkielessä.](sanity:image-6fd8044953bdac20e0692f28d9df81a943625505-1200x628-png)


x86:ssa on oma käskyperhe pelkästään muistialueiden käsittelyyn: kopiointi, alustaminen, läpikäynti, etsiminen. Nämä käskyt ovat **implisiittisiä**: ne lukevat ja kirjoittavat tiettyihin rekistereihin ilman että niitä mainitaan operandina, ja `REP`-etuliite tekee niistä toistettavia. C-kirjastojen `memcpy`, `memset` ja `strlen` kääntyvät usein yhdeksi näistä, joten reverse engineeringissä niihin törmää koko ajan.

> **Huom:** Tässä moduulissa käsiteltäviä käskyjä ei voi ajaa kurssimme emulaattorissa; esimerkit on tarkoitettu lukemista varten, ei suoritettaviksi. Käytännön kokeilun voit tehdä myöhemmin oikealla assemblerilla (esim. NASM + Linux).

---

## Implisiittiset rekisterit

Merkkijono-operaatioilla on kaksi kiinteää osoitinrekisteriä ja yksi datarekisteri:

- `ESI` (Source Index): lähde-osoite. Operaatiot, jotka **lukevat** muistista, käyttävät `ESI`:ä.
- `EDI` (Destination Index): kohde-osoite. Operaatiot, jotka **kirjoittavat** muistiin, käyttävät `EDI`:ä.
- `EAX` (tai `AX`/`AL` koosta riippuen): datarekisteri lataus- ja vertailuoperaatioille.

Lisäksi `EFLAGS`-rekisterin **Direction Flag** (`DF`) määrittää, kasvavatko vai pienenevätkö `ESI`/`EDI` operaation jälkeen:

- `CLD` (Clear Direction) → `DF = 0` → osoittimet kasvavat (eteenpäin).
- `STD` (Set Direction) → `DF = 1` → osoittimet pienenevät (taaksepäin).

Käytännössä kääntäjät asettavat lähes aina `DF = 0` ennen näitä operaatioita. C-funktiot olettavat sen.

---

## `MOVS`: kopioi yksi alkio lähteestä kohteeseen

`MOVSB` / `MOVSW` / `MOVSD` kopioi yhden tavun / sanan / kaksoissanan osoitteesta `[ESI]` osoitteeseen `[EDI]`, ja kasvattaa molempia osoittimia alkion koolla.

Käytännössä yksittäinen `MOVSB` tekee tämän:

```assembly_x86
MOV AL, BYTE [ESI]    ; lue tavu lähteestä
MOV BYTE [EDI], AL    ; kirjoita kohteeseen
INC ESI               ; siirry seuraavaan lähde-tavuun
INC EDI               ; siirry seuraavaan kohde-tavuun
```

`MOVSD` tekisi saman 4-tavuiselle, eli kasvattaisi `ESI`/`EDI` 4:llä.

---

## `STOS`: tallenna `EAX`/`AX`/`AL` kohteeseen

`STOSB` / `STOSW` / `STOSD` kirjoittaa `AL` / `AX` / `EAX`-rekisterin sisällön osoitteeseen `[EDI]` ja kasvattaa `EDI`:tä.

```assembly_x86
; STOSB on käytännössä:
MOV BYTE [EDI], AL    ; kirjoita AL kohteeseen: EI lukua ESI:stä
INC EDI               ; siirry seuraavaan tavuun (DF=0)
```

Eli `STOSB` täyttää muistia rekisterin `AL` arvolla. Eroaa `MOVSB`:stä siten, että lähdettä (`ESI`) ei lueta, vaan `AL`:n arvo on kiinteä täytearvo.

Käytetään tyypillisesti muistialueen alustamiseen yhdellä arvolla, esim. nollaamiseen.

---

## `LODS`: lataa lähteestä `EAX`/`AX`/`AL`:iin

`LODSB` / `LODSW` / `LODSD` lukee tavun/sanan/dwordin osoitteesta `[ESI]` rekisteriin ja kasvattaa `ESI`:tä. Hyvin harvoin käytetään yksinään: yleensä silmukan sisällä, jossa luettu tavu prosessoidaan.

---

## `SCAS`: vertaa `EAX`/`AX`/`AL`:ta `[EDI]`:iin

`SCASB` / `SCASW` / `SCASD` tekee `CMP`-tyylisen vertailun datarekisterin (`AL`/`AX`/`EAX`) ja `[EDI]`:n välillä, päivittää liput (`ZF`, `SF`, jne.) ja kasvattaa `EDI`:tä. Käytetään esim. terminoivan nullin etsimiseen merkkijonosta.

---

## `REP`-etuliite: tee `ECX` kertaa

Yksittäinen merkkijonokäsky tekee yhden alkion. Mutta lähes aina ne yhdistetään `REP`-etuliitteeseen, joka **toistaa** käskyn:

- `REP MOVSB`: toista `MOVSB`, kunnes `ECX = 0`. Vähentää `ECX`:ää joka kierroksella.
- `REP STOSB`: toista `STOSB`, kunnes `ECX = 0`.
- `REPE` / `REPZ`: toista, kunnes `ZF = 0` *tai* `ECX = 0` (ehdollinen).
- `REPNE` / `REPNZ`: toista, kunnes `ZF = 1` *tai* `ECX = 0` (käänteinen).

### `REP MOVSB` vastaa `memcpy`:tä

```
; C:n vastine: memcpy(edi, esi, ecx)
MOV ESI, lähde         ; ESI ← lähdeosoite
MOV EDI, kohde         ; EDI ← kohdeosoite
MOV ECX, pituus        ; ECX ← kopioitavien tavujen määrä
CLD                    ; DF = 0, edetään eteenpäin
REP MOVSB              ; kopioi ECX tavua [ESI] → [EDI]
```

Kun näet tämän kuvion disassemblyssä, sinulla on lähes varmasti `memcpy`-kutsu inlinattuna.

### `REP STOSB` vastaa `memset`:iä

```
; C:n vastine: memset(edi, al, ecx)
MOV EDI, kohde         ; EDI ← kohdeosoite
MOV AL, täytearvo      ; AL ← tavu, jolla täytetään
MOV ECX, pituus        ; ECX ← tavujen määrä
CLD
REP STOSB              ; kirjoita AL ECX tavuun alkaen [EDI]:stä
```

`REP STOSD` täyttää 4 tavua kerrallaan; kääntäjä valitsee variantin tehokkuuden mukaan.

### `REPNE SCASB` vastaa `strlen`-kuviota

```
; C:n vastine: laske merkkijonon pituus (etsi terminoiva 0)
MOV EDI, merkkijono    ; EDI ← merkkijonon alku
MOV AL, 0              ; etsittävä arvo = null-terminaattori
MOV ECX, 0xFFFFFFFF    ; suuri yläraja
CLD
REPNE SCASB            ; etsi 0:aa; lopeta kun löytyy (ZF=1) tai ECX=0
NOT ECX                ; muunna jäljellä oleva ECX merkkijonon pituudeksi
DEC ECX                ; vähennä 1 (null ei kuulu pituuteen)
```

Tämä on niin tunnusomainen kuvio, että disassemblyn lukija tunnistaa sen yhdellä silmäyksellä `strlen`:iksi.

---

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

`memcpy`, `memset`, `strlen`, `strcmp` ja `memcmp` ovat C-kirjaston yleisimpiä funktioita. Käännetyssä koodissa ne usein **inlinaantuvat** eli kääntäjä ei kutsu erillistä funktiota, vaan sijoittaa sen koodin suoraan kutsupaikkaan `REP`-kuviona. Jos et tunne näitä kuvioita, saatat luulla nähneesi monimutkaisen silmukan, vaikka kyseessä on yksinkertainen muistinkäsittely.

Kun siis näet `REP MOVS*`-, `REP STOS*`- tai `REPNE SCAS*`-kuvion:
- Älä lue silmukkaa askel kerrallaan.
- Kysy sen sijaan: mitä C-funktiota tämä toteuttaa? Yleensä vastaus löytyy hetkessä.

---

## Yhteenveto

- Merkkijono-operaatiot käyttävät implisiittisiä rekistereitä: `ESI` (lähde), `EDI` (kohde), `EAX`/`AX`/`AL` (data).
- `MOVS` kopioi `[ESI]` → `[EDI]`, `STOS` kirjoittaa datarekisterin, `LODS` lukee `[ESI]`:stä, `SCAS` vertaa `[EDI]`:iin.
- `DF` ohjaa osoittimien suunnan (eteen/taakse). `CLD` = eteenpäin (yleisempi).
- `REP`-etuliite toistaa käskyn `ECX` kertaa. `REPE`/`REPNE` lopettaa myös lipun mukaan.
- Yleisimmät kuviot: `REP MOVSB` vastaa `memcpy`:tä, `REP STOSB` vastaa `memset`:iä, `REPNE SCASB` vastaa `strlen`-haku.
- Tunnistamalla nämä kuviot luet käännettyä C-koodia paljon sujuvammin.


Merkkijono- ja muistioperaatiot

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

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

Merkkijono- ja muistioperaatiot

Merkkijono- ja muistioperaatiot: MOVS, STOS, LODS, SCAS ja REP-etuliite

Hakkeroinnin oppiminen alkaa tästä

Merkkijono- ja muistioperaatiot: `MOVS`, `STOS`, `LODS`, `SCAS` ja `REP`-etuliite