## Bittisiirrot ja `LEA`: bittien liikuttelu ja osoitearitmetiikka

![SHL siirtää bittejä vasemmalle = kerro 2^n:llä; LEA laskee `[kanta + indeksi*skaalaus + siirto]` osoitelausekkeen yhdellä käskyllä.](sanity:image-3f5f4255678d670f7dbd4e39e5039146b402c8a6-1200x628-png)


Olemme käyttäneet `MOV`-, `ADD`- ja `IMUL`-käskyjä rekistereiden arvojen siirtoon ja laskentaan. Mutta kun käännät C-koodia konekielelle, kääntäjä korvaa monet `IMUL`- ja `IDIV`-käskyt paljon nopeammilla bittisiirroilla, ja monet osoitelaskut yhdellä erikoiskäskyllä nimeltään `LEA`. Nämä ovat takaisinmallinnuksen (reverse engineering) näkymässä jatkuvasti vastassa, joten on aika opetella tunnistamaan ne.

---

## Bittisiirrot: kerrotaan ja jaetaan kahden potenssilla

### `SHL`: siirrä vasemmalle

`SHL kohde, määrä` siirtää kohteen bittejä vasemmalle annetun määrän verran. Oikealle puolelle tulee nollia. Yksi bittisiirto vasemmalle = kerrotaan kahdella.

```assembly_x86
section .text

MOV EAX, 3       ; binäärinä 0...0011 = 3
SHL EAX, 2       ; siirrä 2 bittiä vasemmalle = kerro 4:llä
                 ; nyt EAX = 0...1100 = 12
INT 1            ; tulostaa 12
HLT
```

Yleisesti `SHL kohde, n` = kerrotaan `2^n`:llä. Joten 1 bittisiirto = ×2, 2 bittisiirtoa = ×4, 3 bittisiirtoa = ×8. Kääntäjät suosivat tätä `IMUL`:n sijaan kahden potenssia kerrottaessa: bittisiirto on yhdellä kellojaksolla, kun taas `IMUL` voi viedä useamman.

### `SHR`: siirrä oikealle (etumerkitön)

`SHR kohde, määrä` siirtää bittejä oikealle. Vasemmalle puolelle tulee nollia. Tämä on **etumerkitön** jako kahden potenssilla.

```assembly_x86
section .text

MOV EAX, 80      ; binäärinä 0101 0000 = 80
SHR EAX, 3       ; siirrä 3 bittiä oikealle = jaa 8:lla
                 ; nyt EAX = 0000 1010 = 10
INT 1            ; tulostaa 10
HLT
```

### `SAR`: siirrä oikealle (etumerkillinen)

`SAR` on kuin `SHR`, mutta säilyttää etumerkin: vasempaan päähän kopioidaan alkuperäisen ylimmän bitin arvo. Tätä käytetään **etumerkillisten** lukujen jakoon kahden potenssilla.

```assembly_x86
section .text

MOV EAX, -8      ; binäärinä 1111...1000 = -8
SAR EAX, 1       ; siirrä 1 bitti oikealle, säilytä etumerkki = -8 / 2
                 ; nyt EAX = -4
INT 1            ; tulostaa -4
HLT
```

`SHR`:llä sama operaatio olisi antanut valtavan positiivisen luvun, mikä olisi väärin etumerkillisen luvun jaossa. Kääntäjä valitsee `SHR`:n vs `SAR`:n alkuperäisen muuttujan etumerkillisyyden mukaan. Tämä on käytännössä tunnusmerkki, josta reverse engineeringissä päättelet onko muuttuja `unsigned int` vai `signed int`.

### `SAL`: alias `SHL`:lle

`SAL` on `SHL`:n synonyymi (sama opcode). Mnemonia on olemassa lähinnä symmetriaksi `SAR`:n kanssa. Älä hämmenny, jos näet jommankumman: ne ovat sama käsky.

### `ROL` ja `ROR`: rotaatiot

Siirron sijaan rotaatio: ylin bitti kierretään alimmaksi (`ROL`) tai päinvastoin (`ROR`). Bittejä ei "katoa".

```assembly_x86
section .text

MOV EAX, 0x80000001   ; ylin ja alin bitti asetettu
ROL EAX, 1            ; alin bitti kiertyy ylimmäksi, ylin siirtyy
                      ; nyt EAX = 0x00000003 = 3
INT 1                 ; tulostaa 3
HLT
```

Reverse engineeringissä rotaatioita näkee tyypillisesti salausalgoritmeissa (SHA, MD5, RC5); ne ovat vahva vihje siitä, että tutkit kryptografiakoodia.

---

## `LEA`: Load Effective Address

`LEA` on x86:n outolintu: sen syntaksi näyttää muistihaulta, mutta se ei hae mitään muistista. Se vain **laskee osoitteen** ja sijoittaa sen kohderekisteriin.

```assembly_x86
section .text

MOV EBX, 100
MOV ECX, 3
LEA EAX, [EBX + ECX*4 + 8]    ; EAX = 100 + 3*4 + 8 = 120
INT 1                          ; tulostaa 120
HLT
```

Yhtäkään muistihakua ei tehty. `EAX`:iin tuli `EBX`:n, `ECX*4`:n ja vakion 8 summa. Tämä on kääntäjän rakas temppu: **yksi käsky korvaa kaksi tai kolme `ADD`/`IMUL`-käskyä**, eikä `LEA` päivitä lippuja, mikä tekee siitä turvallisen "läpinäkyvän aritmetiikan" välineen.

### Yleisimmät `LEA`-kuviot reverse engineeringissä

| Lauseke | Tulos |
| --- | --- |
| `LEA EAX, [EBX + EBX*2]` | `EAX = EBX * 3` |
| `LEA EAX, [EBX + EBX*4]` | `EAX = EBX * 5` |
| `LEA EAX, [EBX + EBX*8]` | `EAX = EBX * 9` |
| `LEA EAX, [ECX + 1]` | `EAX = ECX + 1` (ilman lippumuutosta) |
| `LEA EAX, [EBX + ECX]` | `EAX = EBX + ECX` |

Kun näet `LEA`-rivin disassemblyssä, älä lue sitä muistihakuna. Lue se algebrana: "kohde = se mitä hakasulkeiden sisällä on", eli sisältä ei dereferoida mitään.

```assembly_x86
section .text

; Toteutetaan "x = a*5 + b" yhdellä rivillä:
MOV EBX, 7         ; a = 7
MOV ECX, 9         ; b = 9
LEA EAX, [EBX + EBX*4]   ; EAX = a*5 = 35
ADD EAX, ECX             ; EAX = a*5 + b = 44
INT 1
HLT
```

---

## Yhteenveto

- `SHL kohde, n`: siirrä bittejä vasemmalle = `kohde * 2^n` (etumerkitön).
- `SHR kohde, n`: siirrä oikealle = `kohde / 2^n` (etumerkitön).
- `SAR kohde, n`: siirrä oikealle ja säilytä etumerkki = etumerkillinen jako.
- `SAL` = `SHL` (alias).
- `ROL` / `ROR`: rotaatiot ilman bittien menettämistä; salauskoodin tunnusmerkki.
- `LEA target, [base + index*scale + offset]`: laskee osoitteen, ei hae muistista. Käännetyssä koodissa yleensä kompakti aritmeettinen käsky, joka ei sotke lippuja.


Bittisiirrot ja LEA

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

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

Bittisiirrot ja LEA

Bittisiirrot ja LEA: bittien liikuttelu ja osoitearitmetiikka

Hakkeroinnin oppiminen alkaa tästä

Bittisiirrot ja `LEA`: bittien liikuttelu ja osoitearitmetiikka