User Tools

Site Tools


laboratoare:laborator-08

This is an old revision of the document!


A PCRE internal error occured. This might be caused by a faulty plugin

====== Laborator 8: Interfața în linia de comandă, analiza statică și dinamică ====== 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. ===== Interfața în linia de comanda ===== 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ă ===== 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 ===== Analiza dinamică ===== 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. ===== Tutoriale și exerciții ===== Î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. <note warning> Decât dacă se specifică altfel în cerință, toate utilitarele vor fi rulate din linia de comandă. Bineînțeles, puteți folosi orice editor text pentru a rezolva exercițiile (chiar și SASM), însă asamblarea, link-editarea etc. vor fi făcute din interfața în linia de comandă. </note> ==== [0.5p] 1. Tutorial: Asamblarea din linia de comandă ==== Deschideți fișierul ''hello-world.asm'' din arhivă și înțelegeți codul. <note> Observați că atât funcțiile externe cât și funcția ''main'' sunt precedate de ''_'' (underscore). Aceasta este utilizarea standard pe Windows. Înainte funcționau ''printf'' și alte funcții externe deoarece erau de fapt doar macro-uri la funcțiile prefixate cu underscore, definite în ''io.inc''. De asemenea, CMAIN era doar un macro la ''_main''. </note> 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: <code> "C:\Program Files (x86)\SASM\NASM\nasm.exe" -g -f win32 hello-world.asm -o hello-world.obj </code> <note> ''-g'' spune asamblorului să adauge simboluri de debug în fișierul obiect rezultat ''-f'' menționează formatul executabilului (în cazul nostru ''win32'') </note> Pentru a verifica "corectitudinea" asamblării, haideți să dezasamblăm fișierul ''hello-world.obj'' folosind utilitarul ''objdump.exe'', astfel: <code> "C:\Program Files (x86)\SASM\MinGW\bin\objdump.exe" -d hello-world.obj </code> 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. ==== [0.5p] 2. Tutorial: Link-editarea unui fișier obiect ==== 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. <code> "C:\Program Files (x86)\SASM\MinGW\bin\gcc.exe" -g -m32 hello-world.obj -o hello-world.exe </code> <note> ''-g'' este folosit cu același scop ca la nasm.exe, de a introduce simboluri de debug în executabil ''-m32'' specifică arhitectura pentru care executabilul este generat (în cazul nostru, arhitectură pe 32 biți) </note> 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 <code> .\hello-world.exe </code> Ar trebui să vi se afișeze pe ecran ''Hello, World''. ==== [1.5p] 3. Implementare minimală ''cat'' ==== 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. <note> Folosiți funcțiile ''gets'' și ''puts'' pentru a nu mai adăuga șiruri de formatare pentru scanf și printf. </note> 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. ==== [0.5p] 4. Tutorial: Link-editarea mai multor fișiere obiect ==== 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: <code> "C:\Program Files (x86)\SASM\MinGW\bin\gcc.exe" -g -m32 main.obj helpers.obj -o palindrome.exe </code> ==== [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//. Aveți (pseudo-)codul în C care ar face acest lucru: <code C> 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; } } </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. === 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 ==== 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 ==== Î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. ==== [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.

laboratoare/laborator-08.1449042911.txt.gz · Last modified: 2015/12/02 09:55 by catalin.vasile3004