După un scurt breviar care va explica noțiunile introduse în acest laborator, va urma o parte practică care alternează între secțiuni de tip tutorial, cu parcurgere pas cu pas și prezentarea soluției, și exerciții care trebuie să fie rezolvate.

Deși folosirea unui mediu grafic pentru programare poate părea mai atractivă, de multe ori folosirea liniei de comandă oferă mai multă putere și control asupra a ceea ce vrem să facem. În plus, folosirea utilitarelor din linia de comandă în scripturi poate facilita automatizarea unor task-uri, lucru care ne va face viața mai ușoară în nenumărate cazuri.

În cadrul acestui laborator, vom folosi utilitare în linia de comandă atât pentru asamblarea și link-editarea fișierelor sursă, cât și pentru analiza statică și dinamică a programelor obținute din parcurgerea tutorialelor și a exercițiilor.

Analiza statică a unui program constă în inspectarea diferitelor aspecte din fișierul obiect sau executabil.

Câteve din programele utile pentru analiza statică pe care le vom folosi și în cadrul tutorialelor/exercițiilor sunt:

• nm - utilitar folosit pentru insepctarea simbolurilor și secțiunilor din executabile
• objdump - program folosit pentru dezasamblarea (traducerea din cod-mașină în limbaj de asamblare) programelor binare
• IDA - o unealtă foarte puternică pentru dezasamblarea și inspectarea fișierelor obiect și executabile

Spre deosebire de analiza statică, analiza dinamică constă în inspectarea unui program aflat în execuție. Practic, analiza dinamică se face la runtime.

Unul dintre cele mai folosite programe pentru analiză dinamică este gdb. Acesta oferă o gamă largă de operații ce pot fi făcute, de la inspectarea memoriei, la schimbarea control flow-ului și până la modificarea registrelor de pe procesor, în timpul rulării unui program.

În cadrul exercițiilor vom folosi arhiva de laborator.

Descărcați arhiva, decomprimați-o și accesați directorul aferent.

Deschideți fișierul hello-world.asm din arhivă și înțelegeți codul.

Primul pas este să pornim un shell (Command Prompt, PowerShell sau MSYS, dacă este instalat). După ce avem linia de comandă vom naviga în directorul cu task-urile acestui laborator.

Pentru a asambla fișierul hello-world.asm, vom folosi utilitarul nasm.exe (program care este folosit în spate și de către SASM). Acesta se află în subdirectorul NASM, unde este instalat SASM pe sistemul vostru.

Dacă folosim Command Prompt avem:

"C:\Program Files (x86)\SASM\NASM\nasm.exe" -g -f win32 hello-world.asm -o hello-world.obj

Pentru a verifica “corectitudinea” asamblării, haideți să dezasamblăm fișierul hello-world.obj folosind utilitarul objdump.exe, astfel:

"C:\Program Files (x86)\SASM\MinGW\bin\objdump.exe" -d hello-world.obj

Putem observa similaritatea dintre codul inițial și codul dezasamblat, mai puțin la instrucțiunea call, unde adresa pare greșită. Acest fapt se întâmplă din cauza faptului că fișierul obiect obținut nu “știe” cine este printf. Acest lucru se va afla la pasul de link-editare, iar adresa va fi modificată la cea corespunzătoare.

Link-editarea unuia sau mai multor fișiere obiect constă în rezolvarea tuturor simbolurilor externe și crearea unui singur fișier executabil din toate fișiere primite la intrare.

Pentru link-editare vom folosi gcc.exe. De asemenea și gcc este folosit de SASM pentru link-editarea fișierelor obiect.

"C:\Program Files (x86)\SASM\MinGW\bin\gcc.exe" -g -m32 hello-world.obj -o hello-world.exe

Acum puteți rula executabilul pentru a vedea că toți pașii au funcționat. Pentru lansarea în execuție din linie de comandă folosiți construcția

.\hello-world.exe

Ar trebui să vi se afișeze pe ecran Hello, World.

Pornind de la fișierul hello-world.asm, va trebui să implementați funcționalitatea de bază a utilitarului cat: citește o singură linie de la intrarea standard și o afișează la ieșirea standard.

După ce ați terminat de implementat, asamblați fișierul sursă și link-editați fișierul obiect obținut din asamblare, pentru a obține un executabil. Pentru a primi punctajul aferent exercițiului, trebuie să prezentați atât codul cât și funcționalitatea programului când este în execuție.

Ce facem atunci când vrem să modularizăm programul și să avem mai multe fișiere sursă, fiecare cu un anume rol? Practic va trebui să creăm pentru fiecare fișier sursă, fișierul obiect corespunzător, iar apoi să link-edităm toate fișierele obiect obținute într-un singur executabil care să conțină tot codul.

În directorul linking-multiple avem două fișiere: main.asm și helpers.asm. Deschideți ambele fișiere și observați “legătura” dintre ele (cine apelează ce funcție și din ce fișier). După ce ați înțeles flow-ul programului asamblați fiecare fișier în parte, pentru a obține două fișiere obiect: main.obj și helpers.obj.

Pentru link-editarea multiplă se folosește aceeași comandă gcc, numai că se dau mai multe fișiere de intrare. Spre exemplu:

"C:\Program Files (x86)\SASM\MinGW\bin\gcc.exe" -g -m32 main.obj helpers.obj -o palindrome.exe

După cum probabil ați observat, funcția reverse din helpers.asm nu face nimic. În cadrul acestui exercițiu, va trebui să implementați corpul funcției, unde este comentariul TODO, astfel încât șirul de caractere care a fost trimis ca parametru să fie întors in-place.

Aveți (pseudo-)codul în C care ar face acest lucru:

void reverse(char *s)
{
  int n = strlen(s);
  int i;
  char tmp;
 
  for (i = 0; i < n / 2; ++i) {
    tmp = s[i];
    s[i] = s[n - i - 1];
    s[n - i - 1] = tmp;
  }
}

După implementare va trebui să asamblați și link-editați programul.

GDB este o unealtă foarte utilă pentru analiza dinamică a programelor. Acesta este folosit foarte des pentru găsirea cauzelor care duc la erori într-un program. În continuare vă vom prezenta câteva dintre comenzile cele mai importante.

Primul pas este să urmăriți și să înțelegeți codul din gdb-tutorial.asm. Pe scurt, programul primește un parametru index și citește de la tastatură o linie. Programul afișează doar un caracter, mai exact al index-lea caracter din șirul dat la intrare.

După ce ați citit codul sursă, asamblați și link-editați fișierul. După ce ați obținut executabilul gdb-tutorial.exe (sau ce nume i-ați dat), vom porni GDB-ul cu acel fișier:

"C:\Program Files (x86)\SASM\MinGW\bin\gdb.exe" gdb-tutorial.exe

După ce ați pornit programul gdb, toată interacțiunea cu acesta se face prin prompt-ul de gdb.

Pentru a lansa programul urmărit în execuție există două comenzi disponibile:

• run - această comandă va lansa în execuție programul
• start - spre deosebire de run, această comandă va începe execuția programului, însă se va opri imediat după intrarea în main

Aceste două comenzi mai pot fi folosite în două feluri:

1. start 1 2 3 4

2. start < file.in

Utilizarea aceasta este similară cu execuția programului direct din linia de comandă (fără GDB), prima variantă însemnând că se trimit 4 parametri (1, 2, 3 și 4) programului, iar a doua, că file.in se redirectează ca intrare standard pentru program.

Lansați programul în execuție folosind comanda GDB run. Ce observați? Rulați din nou programul, de data aceasta dând comenzii run parametrul corespunzător.

GDB se blochează la citirile de la input. Haideți să corectăm asta folosind un fișier de intrare. Creați un fișier (spre exemplu text.in) în directorul cu executabilul care să conțină textul “ana are mere”. Porniți din nou GDB și lansați în execuție programul cu parametrul de intrare 11 și cu fișierul text.in, redirectat.

Ce observați? Programul își termină execuția cu succes. Deoarece nu a existat niciun breakpoint setat în program, programul nu s-a oprit din execuție decât când a terminat treaba.

În cazul pornirii programului, puteți folosi instrucțiunea start care va opri execuția după intrarea în main.

Elementul esențial al GDB-ului este breakpoint-ul. Practic, un breakpoint setat la o anumită instrucțiune face ca execuția programului să se oprească de fiecare dată când se ajunge la acest punct.

Adăugarea unui breakpoint se face cu construcția

break [location]

, unde location poate fi numele unei funcții sau o adresă din zona .text. În cazul cel din urmă, adresa trebuie să fie precedată de * (star). Exemplu: break *0x004013af.

Pentru continuarea programului după eventuala sa oprire într-un breakpoint, puteți folosi comanda continue.

Un alt lucru interesant în GDB este comanda commands, care poate asocia unui breakpoint un bloc de comenzi GDB ce vor fi executate la fiecare oprire în breakpoint-ul respectiv.

Exemplu:

(gdb) break *0x004013af
Breakpoint <n> at 0x4013af
(gdb) commands <n>
Type commands for breakpoint(s) <n>, one per line.
End with a line saying just "end"
> print $eax
> x/i $eip
> end

Pentru a nu rămâne blocat în breakpoint (spre exemplu dacă scrieți un script de gdb), puteți adăuga în blocul de instrucțiuni și comanda continue.

Haideți să adăugăm un breakpoint la label-ul ok. Dacă dăm continue, vom observa că programul s-a oprit în breakpoint-ul tocmai creat.

Atunci când execuția programului este oprită (de exemplu la un breakpoint), putem da comenzi care continuă execuția “pas cu pas”. Pentru a face asta, cel mai des sunt folosite două comenzi:

• stepi - care practic trimite o instrucțiune spre execuție și după execuția acesteia întoarce control-ul la debugger (programul se oprește)
• nexti - comandă similară cu stepi, însă dacă instrucțiunea curentă este un apel de funcție, debugger-ul nu va intra în funcție (va chema funcția și se va opri la următoarea instrucțiune după call)

Dacă emitem comanda stepi, putem observa că se afișează instruction pointer-ul instrucțiunii următoare dupa cea la care am făcut break (prima de la label-ul ok).

Pentru a dezasambla o porțiune de executabil, se poate folosi comanda disassemble din GDB. Dacă aceasta nu primește niciun parametru, va afișa dezasamblarea funcției curente din cadrul execuției.

În cadrul exemplului nostru, dacă cerem dezasamblarea funcției curente (folosind disassemble fără parametri) putem observa că ne aflăm la label-ul ok. Observație: GDB iterpretează label-ul ok ca o funcție din cauza codului inițial, care este scris în limbaj de asamblare.

Pentru a vedea mai clar efectul stepi/nexti putem rula commanda disassemble înainte și după stepping.

Pentru a afișa diferite valori accesibile GDB-ului se folosește comanda print. De exemplu, pentru a afișa valoarea unui registru (de exemplu eax), vom folosi construcția print $eax.

Pentru inspectarea memoriei se folosește comanda x (examine). Modul de folosire al acestei comenzi este următorul:

x/nfu address

, unde:

• n este numărul de elemente afișate
• f este formatul de afișare (x pentru hexa, d pentru zecimal, s pentru șir de caractere și i pentru instrucțiuni)
• u este dimensiunea unui element (b pentru 1 octet, h pentru 2, w pentru 4 și g pentru 8 octeți)

De exemplu, o funcționalitate similară cu disassemble o putem obține și folosind x unde formatul este instrucțiune. Astfel, putem afișa, de exemplu, 10 instrucțiuni începând de la instrucțiunea curentă cu construcția x/10i $eip.

Folosind executabilul creat la exercițiul anterior (gdb-tutorial.asm), trebuie să setați un breakpoint la intrare în bucla din program (când se mută în subregistrul al un caracter din șirul input). În plus, trebuie să adăugați o serie de comenzi astfel încât la fiecare intrare în buclă, GDB să afișeze valoarea subregistrului al și valoarea counter-ului (în cazul nostru ecx). Hint! folosiți comanda commands.

Folosind tot executabilul de mai înainte, afișați adresele de return ale tuturor funcțiilor din program (gets, atoi, printf, usage). Pentru cazul funcției usage, trebuie să porniți programul fără parametri.

Pentru acest tutorial pornim de la fișierul sursă segfault-tutorial.asm. Înainte de a începe tutorialul, citiți sursa, înțelegeți ce face și apoi asamblați și link-editați programul.

Dacă încercați să rulați programul fără parametri, se poate observa că progamul “crapă”. Dacă executăm programul sub gdb, putem observa că programul primește SIGSEGV. Pentru a putea determina problema, executăm comanda backtrace, care arată ultimele stack frame-uri prin care execuția programului a trecut. În cazut nostru, doar două:

(gdb) backtrace
#0 0x7607d2c3 in strcat () ...
#1 0x00000000 in ?? ()

Ne dăm seama că frame-ul interesant pentru noi este #0. Pentru a schimba frame-ul curent folosim comana frame <nr. frame>. Odată ce suntem pe frame-ul ce ne interesează putem să încercăm dezasamblarea programului pentru a identifica problema.

După instrucțiunea disassemble, putem observa instruction pointer-ul (notat pe dezasamblarea din GDB cu ⇒ în dreptul unei instrucțiuni) că a rămas la instrucțiunea

mov eax, DWORD PTR [ecx]

Deja putem bănui o posibilă cauză a segmentation fault-ului. Inspectați registrul ecx. Ce valoare are? Ce încearcă să facă instrucțiunea cu probleme?

Pornind de la executabilul segfault.exe, rulat sub gdb, analizați atât backtrace-ul cât și pas cu pas codul pentru a identifica cauza care duce la Segmentation Fault.

În această secțiune vom prezenta foarte pe scurt câteva dintre numeroasele aspecte ale programului IDA.

În primul rând va trebui să descărcați installer-ul de IDA de aici și să-l instalați pe mașinile din laborator. După ce programul s-a instalat, porniți Ida Pro Free. La prompt-ul de welcome alegeți varianta [GO] Work on your own. Din meniul de sus dați “Open…” și deschideți fișierul de la exercițiul 10 (segfault.exe).

Dintre numeroasele view-uri posibile din IDA, cele mai importante sunt:

• Control-flow graph-ul ce conține pentru fiecare bloc dezasamblarea sa
• Names care este o tabelă cu simbolurile din executabil
• Functions care conține toate informațiile despre o funcție (dacă e statică sau dintr-o bibliotecă; tipul funcției etc.)

Deși pot fi multe de spus despre IDA, în cadrul acestui laborator ne vom limita doar la capabilitățile de analiză statică ale sale.

Pornind de la executabilul control-flow.exe rulat sub gdb, trebuie să găsiți o modalitate să se afișeze un flag. Până nu veți rezolva corect problema, se va afișa “No flag for you.”

Pornind de la fișierul obiect decompile.obj, treaba voastră este să reconstruiți codul sursa (scris în C) din care a provenit binarul. Puteți folosi orice utilitar de analiză statică, însă cel mai indicat pentru acest task este IDA, deoarece reprezintă foarte clar graful de control al execuției.