Laborator 04: Introducere în limbajul de asamblare

În acest laborator, vom prezenta o parte din instrucțiunile x86, precum și o suită de exemple introductive.

Înainte de a începe efectiv să învățăm să citim cod scris în limbaj de asamblare, iar apoi să scriem primele noastre programe, trebuie să răspundem la câteva întrebări.

După cum probabil știți, rolul de bază al unui calculator - în speță, al procesorului - este de a citi, interpreta și executa instrucțiuni. Aceste instrucțiuni sunt codificate în cod mașină.

Un exemplu ar fi:

1011000000001100011001100011000111011111111111100100

Această secvență de biți nu ne spune nimic în mod deosebit. Putem să facem o conversie în baza 16 pentru a o comprima și grupa mai bine.

\xB0\x0C\x66\x31\xD2\xFF\xE4

În continuare, pentru mulți dintre noi nu spune nimic această secvență. De aici vine necesitatea unui limbaj mai ușor de înțeles și utilizat.

Limbajul de asamblare ne permite să scriem programe text care mai departe vor fi traduse, prin intermediul unui utilitar numit asamblor, specific fiecărei arhitecturi, în cod mașină. Majoritatea limbajelor de asamblare asigură o corespondență directă între instrucțiuni. De exemplu:

mov al, 12 <-> '\xB0\x0C'
xor dx, dx <-> '\x66\x31\xD2'
jmp esp    <-> '\xFF\xE4'

Pe lângă valoarea didactică foarte mare, în care înțelegeți în ce constă “stack overflow”, reprezentarea datelor și ce e specific procesorului cu care lucrați, există câteva aplicații în care cunoașterea limbajului de asamblare și, implicit, a arhitecturii sunt necesare sau chiar critice.

Este destul de probabil ca cel puțin unul din programele pe care le-ați scris în trecut să genereze următorul rezultat:

Segmentation fault

Uneori, veți fi întâmpinați de o serie de date similare cu cele de mai jos:

Page Fault cr2=10000000 at eip e75; flags=6
eax=00000030 ebx=00000000 ecx=0000000c edx=00000000
esi=0001a44a edi=00000000 ebp=00000000 esp=00002672
cs=18 ds=38 es=af fs=0 gs=0 ss=20 error=0002

Pentru cineva care cunoaște limbaj de asamblare, e relativ ușor să se apuce să depaneze problema folosind un debugger precum gdb sau OllyDbg, deoarece mesajul îi furnizează aproape toate informațiile de care are nevoie.

Gândiți-vă cum ați scrie un program C care să realizeze criptare și decriptare AES. Apoi, indicați compilatorului faptul că doriți să vă optimizeze codul. Evaluați performanța codului respectiv (dimensiune, timp de execuție, număr de instrucțiuni de salt etc.). Deși compilatoarele sunt deseori trecute la categoria “magie neagră”, există situații în care pur și simplu știți ceva despre procesorul pe care lucrați mai bine ca acestea.

Mai mult, e suficient să înțelegeți cod asamblare pentru a putea evalua un cod și optimiza secțiunile critice ale acestuia. Chiar dacă nu veți programa în limbaj de asamblare, veți fi conștienți de codul ce va fi generat de pe urma instrucțiunilor C pe care le folosiți.

O mare parte din aplicațiile uzuale sunt closed-source. Tot ce aveți când vine vorba de aceste aplicații este un fișier deja compilat, binar. Există posibilitatea ca unele dintre acestea să conțină cod malițios, caz în care trebuie analizate într-un mediu controlat (malware analysis/research).

Există cazuri în care se impun constrângeri asupra dimensiunii codului și/sau datelor, cum este cazul device-urilor specializate pentru un singur task, având puțină memorie. Din această categorie fac parte și driverele pentru dispozitive.

Pentru mai multe detalii, discutați cu asistentul vostru de laborator pentru a vă împărtăși experiența lui personală în materie de limbaj de asamblare și cazurile practice de utilizare folosite.

Aproape toate procesoarele importante de la Intel împart un ISA (instruction set architecture) comun. Aceste procesoare sunt puternic backwards compatible, având mare parte din instrucțiuni neschimbate de-a lungul generațiilor, ci doar adăugate sau extinse.

Procesoarele din această familie intră în categoria largă de CISC (Complex Instruction Set Computers). Filozofia din spatele lor este de a avea un număr mare de instrucțiuni, cu lungime variabilă, capabile să efectueze operații complexe, în mai mulți cicli de ceas.

Unitățile de lucru de bază pentru procesoarele x86 sunt registrele. Acestea sunt o suită de locații în cadrul procesorului prin intermediul cărora acesta interacționează cu memoria, I/O etc.

Procesoarele x86 au 8 astfel de registre de 32 de biți. Deși oricare dintre acestea poate fi folosit în cadrul operațiilor, din motive istorice, fiecare registru are un rol anume.

Pe lângă acestea, mai există câteva registre speciale care nu pot fi accesate direct de către programator, cum ar fi EFLAGS și EIP (instruction pointer).

EIP este un registru în care se găsește adresa instrucțiunii curente, care urmează să fie executată. El nu poate fi modificat direct, programatic, ci indirect prin instrucțiuni de jump, call și ret.

Registrul EFLAGS conține 32 de biți folosiți pe post de indicatori de stare sau variabile de condiție. Spunem că un indicator/flag este setat dacă valoarea lui este 1. Cei folosiți de către programatori în mod uzual sunt următorii:

Deși setul curent de instrucțiuni pentru procesoarele Intel are proporții biblice, noi ne vom ocupa de un subset din acestea, și anume, o parte dintre instrucțiunile 80386.

Toate instrucțiunile procesoarelor x86 se pot încadra în 3 categorii: transfer de date, aritmetice/logice și de control. Vom enumera doar câteva instrucțiuni reprezentative, deoarece multe dintre ele se aseamănă.

Accesați directorul 0-walkthrough din arhiva laboratorului.

1. Deschideți fișierul ex1.asm și citiți comentariile. Asamblați folosind utilitarul make și rulați. Folosind gdb, parcurgeți programul linie cu linie (comanda start urmată de next) și observați schimbarea valorilor registrelor în urma executării instrucțiunilor MOV și ADD. Ignorați secvența de instrucțiuni a macro-ului PRINTF32.
2. Deschideți fișierul ex2.asm și citiți comentariile. Asamblați folosind utilitarul make și rulați. Folosind gdb, observați schimbarea registrului EIP la executarea instrucțiunii JMP. Pentru a trece peste instrucțiunile macro-ului PRINTF32, adăugați un breakpoint la label-ul jump_incoming (comanda break urmată de run).
3. Deschideți fișierul ex3.asm și citiți comentariile. Asamblați folosind utilitarul make și rulați. Folosind gdb, parcurgeți programul folosind breakpoint-uri. Urmăriți flow-ul programului. De ce se afișează mai întâi 15 și după aceea 3? Din cauza jump-ului de la linia 9. Către ce locație indică jump-ul de la linia 25? Către label-ul zone1.
4. Deschideți fișierul ex3.asm și citiți comentariile. Asamblați folosind utilitarul make și rulați. Folosind gdb, parcurgeți programul. De ce nu se ia jump-ul de la linia 12? Pentru că instrucțiunea JE face saltul dacă este setat bit-ul ZF din registrul FLAGS. Acesta este setat de instrucțiunea CMP, care face diferența dintre valorile registrelor EAX și EBX fără a stoca rezultatul. Însă ADD-ul de la linia 11 șterge acest flag, deoarece rezultatul operației este diferit de 0.

Accesați directorul 1-2-hello-world din arhiva laboratorului. Modificați programul astfel încât afișarea mesajului să se facă numai dacă conținutul registrului eax este mai mare decât cel din ebx. Modificați și valoarea registrelor pentru a face în continuare afișarea mesajului "Hello, World!".

1. Modificați programul astfel încât să mai afișeze încă un mesaj ('Goodbye, World!')
2. Folosind instrucțiuni de tip jump, modificați programul astfel încât să afișeze de N ori 'Hello, World!', unde N este dat prin intermediul registrului ECX. Evitați ciclarea la infinit.

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Goodbye, World!

Accesați directorul 3-grumpy-jumps. Treceți prin codul sursă din grumpy-jumps.asm.

1. Modificați valorile registrelor EAX si EBX astfel încât la rularea lui să se afișeze mesajul Well done!. Urmăriți comentariile marcate cu TODO
2. De ce, în continuare, se afișează și mesajul greșit? Modificați sursa astfel încât să nu se mai afișeze mesajul greșit.

Pornind de la scheletul de cod din directorul 4-sets va trebui să implementați operații pe mulțimi ce pot conține elemente între 0 și 31. Un mod eficient de a face asta (atât din punct de vedere al spațiului cât și al vitezei) ar fi să reprezentăm mulțimile astfel încât un registru să reprezinte o mulțime. Fiecare bit din registru va reprezenta un element din mulțime (dacă bit-ul i este setat atunci mulțimea conține elementul i)

- Aveți definite 2 mulțimi. Ce valori conțin? Realizați reuniunea celor 2 mulțimi.

- Folosiți instrucțiunea or pentru a adăuga două elemente noi în mulțime.

- Faceți intersecția celor 2 mulțimi.

- Determinați elementele care lipsesc din mulțimea eax pentru ca aceasta să fie completă.

- Eliminați un element din prima mulțime.

- Faceți diferența între mulțimi.

PRINTF32 `Reuniunea este: \x0`
PRINTF32 `%u\n\x0`, eax

Calculați minimul dintre numerele din 2 registre (eax și ebx) folosind o instrucțiune de salt și instrucțiunea xchg.

Calculați al N-lea număr Fibonacci, unde N este dat prin intermediul registrului eax.

• Programming from the Ground Up
• Reverse Engineering for Beginners
• Intel 64 and IA-32 Architectures Software Developer Manual
• Intel 80386 Programmer's Reference Manual
• RISC vs. CISC
• Intel x86 JUMP Quick Reference