## Bittioperaatiot

Tähän asti olemme käsitelleet lukuja kokonaisuuksina: lisätty, vähennetty, vertailtu. Mutta prosessori osaa myös pureskella lukuja bitti bitiltä. Bittioperaatiot ovat ydintyökalu lippujen asettamiseen, oikeuksien tarkistamiseen, datan pakkaamiseen ja loputtomaan määrään matalan tason kikkoja, ja reverse engineeringissä törmäät niihin jatkuvasti.
![AND/OR/XOR-totuustaulut, AND-maskauksen vaiheet ja XOR:n yleiset kikat.](sanity:image-ec67f0f68b57755d971f9fdfdbda70078b77cb02-1536x1024-png)
### Totuustaulut lyhyesti

Kolme pääoperaatiota toimivat bitti kerrallaan kahden luvun välillä:

- `AND`: tulosbitti on 1 vain jos *molemmat* lähdebitit ovat 1. (`1100 AND 1010 = 1000`)
- `OR`: tulosbitti on 1 jos *jompikumpi* (tai molemmat) lähdebiteistä on 1. (`1100 OR 1010 = 1110`)
- `XOR`: tulosbitti on 1 jos lähdebitit ovat *eri* (toinen 1, toinen 0). (`1100 XOR 1010 = 0110`)

Kaikki kolme kirjoitetaan kahden operandin muodossa, aivan kuten `ADD` ja `SUB`:

```assembly_x86
AND EAX, EBX     ; EAX = EAX AND EBX
OR  EAX, 0xFF    ; EAX = EAX OR 0xFF
XOR EAX, EAX     ; EAX = 0   (tunnettu nollausnikse)
```

---

## Maskaus `AND`:lla

Kaikkein yleisin käyttö: **eristä** tietty osa luvusta. Maski on bittikuvio, jossa 1-bitit "päästävät läpi" ja 0-bitit "nollaavat".

```assembly_x86
MOV EAX, 0xAB    ; 1010 1011
AND EAX, 0x0F    ; 0000 1111  -> jäljelle jää 0000 1011 = 0x0B = 11
```

Tai eristä ylänybble: `AND EAX, 0xF0` jättää vain ylimmät 4 bittiä. Tätä näkee jatkuvasti, kun pakattua dataa puretaan kenttä kerrallaan, esimerkiksi väriarvoista, lippurekisteristä tai verkkopakettien otsikoista.

### Onko bitti päällä?

Yksittäisen bitin testaaminen: maskaa kaikki muut pois ja katso onko tulos nolla.

```assembly_x86
MOV EAX, 11      ; 1011: onko bitti 2 (arvo 4) päällä?
AND EAX, 4       ; 1011 AND 0100 = 0000 -> ZF = 1, ei päällä
JZ  pois_paalta
```

Koska `AND` päivittää `EFLAGS`-liput (kuten `ADD`/`SUB`/`CMP`), voit ketjuttaa sen suoraan ehdolliseen hyppyyn.

---

## Bittien asettaminen `OR`:lla

`OR` pakottaa valitut bitit päälle koskematta muihin:

```assembly_x86
MOV EAX, 16      ; 0001 0000
OR  EAX, 1       ; 0001 0001  -> bitti 0 asetettu, muut ennallaan
```

Kombinaatio `AND` (nollaa kenttä) + `OR` (kirjoita uusi arvo kenttään) on tavallinen tapa päivittää yksi osa pakatusta tavusta muuttamatta muita.

---

## `XOR`:n kikat

`XOR` on monikäyttöisin:

- **Kääntäminen (toggle):** `XOR EAX, 1` kääntää alimman bitin: 0→1, 1→0. Maskattuna useampia bittejä kerralla.
- **Nollaus:** `XOR EAX, EAX` asettaa `EAX`:n nollaan. Konekielessä tämä on lyhyempi ja nopeampi kuin `MOV EAX, 0`, joten kääntäjät suosivat sitä: reverse engineeringissä `xor eax, eax` luetaan aina "`EAX` = 0".
- **Itsensä kumoava:** `(x XOR k) XOR k == x`. Tämä on yksinkertaisimman "salauksen" (`XOR`-cipher) ja monien obfuskointitemppujen ydin: sama avain sekä salaa että purkaa.

```assembly_x86
section .text

MOV EAX, 1337
XOR EAX, 0xAA    ; "salaa"
XOR EAX, 0xAA    ; "purkaa" -> takaisin 1337
INT 1
```

---

## Yhteenveto

- `AND`: 1-bitit päästävät läpi, 0-bitit nollaavat. Maskaukseen ja bittitesteihin.
- `OR`: pakottaa valitut bitit päälle, muut ennallaan.
- `XOR`: kääntää bittejä; `XOR reg, reg` nollaa rekisterin; itsensä kumoava (`XOR`-cipher).
- Kaikki kolme ovat kahden operandin käskyjä ja päivittävät `EFLAGS`-liput.


Bittioperaatiot

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

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ä

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

Bittioperaatiot

Bittioperaatiot

Totuustaulut lyhyesti

Hakkeroinnin oppiminen alkaa tästä