Differences

This shows you the differences between two versions of the page.

--- laboratoare:laborator-08 [2015/12/02 03:11]
adrian.bogatu
+++ laboratoare:laborator-08 [2015/12/02 10:20]
catalin.vasile3004 [[1p] 11. Tutorial: IDA]
@@ Line 24: / Line 24: @@
 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.
-  * command parameters and file redirect (run)
-  * break
-  * step by step (step, next, continue)
-  * disassemble (must mention intel syntax v at&t)
-  * print/display register values, flags
-  * print/display integers
-  * break and compute address from registers, memory zones, etc.
-  * print strings
-  * print instructions, current instructions
-  * print stack
-  * present peda python thingie
-  * as zice debug program (dar ar fi practic sa existe cate un exercitiu de genu' la fiecare din comenzile mentionate anterior, mai ales la partile care incep cu "print something")
-  * debug segfault
 ===== Tutoriale și exerciții =====
-În cadrul exercițiilor vom folosi arhiva de laborator.
+În cadrul exercițiilor vom folosi {{laboratoare:lab-08-tasks.zip|arhiva de laborator}}.
 Descărcați arhiva, decomprimați-o și accesați directorul aferent.
@@ Line 127: / Line 113: @@
 </code>
-==== [1.5p] 5. Completarea fișierului cu funții ajutătoare ====
+==== [1.5p] 5. Completarea fișierului cu funcții ajutătoare ====
 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//.
@@ Line 146: / Line 132: @@
 }
 </code>
+După implementare va trebui să asamblați și link-editați programul.
 ==== [1p] 6. Tutorial: GDB ====
+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:
+<code>
+"C:\Program Files (x86)\SASM\MinGW\bin\gdb.exe" gdb-tutorial.exe
+</code>
+După ce ați pornit programul gdb, toată interacțiunea cu acesta se face prin prompt-ul de gdb.
+=== Lansarea în execuție a programului ===
+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:
+  - <code>start 1 2 3 4</code>
+  - <code>start < file.in</code>
+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.
+=== Breakpoints ===
+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
+<code>break [location]</code>
+, 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:
+<code>
+(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
+</code>
+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.
+<note>
+Variaţii:\\
+**break label** - breakpoint la labelul **label**\\
+**break *(label + <offset>)** - breakpoint la **label + offset**\\
+</note>
+=== Parcurgerea instrucțiunilor ===
+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'').
+=== Dezasamblarea programului ===
+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.
+<note>
+Default, sintaxa folosită de GDB la dezasamblare este cea "AT&T". Pentru a folosi sintaxa cunoscută vouă (sintaxa intel), executați în GDB comanda ''set disassembly-flavor intel''.
+</note>
+Î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.
+<note>
+Dacă ați intrat într-o funcție lungă și nu vreți să dați de ''nexti'' de foarte multe ori, vă recomandăm instrucțiunea GDB ''finish'', care "termină" o funcție. **Atenție** la funcțiile recursive.
+</note>
+<note>
+**disassemble label, +<length>** - afişează <length> bytes de cod dezasamblat începând de la labelul **label**.
+</note>
+=== Inspectarea memoriei și a registrelor ===
+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:
+<code>
+x/nfu address
+</code>
+, 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''.
 ==== [0.5p] 7. Afișarea unor informații la fiecare trecere printr-un breakpoint ====
-==== [1p] 8. Afișarea adresei de retur a unei funcții ====
+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''.
+==== [1p] 8. Afișarea adresei de retur ale unor funcții ====
+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.
 ==== [0.5p] 9. Tutorial: Depanarea unui Segfault folosind GDB ====
+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ă:
+<code>
+(gdb) backtrace
+#0 0x7607d2c3 in strcat () ...
+#1 0x00000000 in ?? ()
+</code>
+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
+<code>mov eax, DWORD PTR [ecx]</code>
+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?
 ==== [1.5p] 10. Rezolvarea unui Segfault ====
+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.
 ==== [1p] 11. Tutorial: IDA ====
-==== [1.5p] Bonus: Modificarea control-flow-ului unui program folosind GDB ====
-==== [2p] Bonus: Decompilarea unui program folosind IDA ====
+Î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 [[https://out7.hex-rays.com/files/idafree50.exe|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.
+<note>
+IDA este destul de avansat încât are posibilitatea de a face tracking şi în Kernelul sistemului de operare. Motiv pentru care trebuie rulat cu drepturi de administrator pentru a putea dreptul la o resursă critică a sistemului.
+</note>
+==== [2p] Bonus: Modificarea control-flow-ului unui program folosind GDB ====
+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."
+==== [2p] Bonus: Decompilarea unui program folosind IDA ====
+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.

Introducere în organizarea calculatorului și limbaj de asamblare

User Tools

Site Tools

Differences

Page Tools