Wprowadzenie Debugger jest programem służącym do analizy kodu wykonywalnego. Pozwala zrozumieć to, co dzieje się w trakcie wykonywania skompilowanego programu jak również odnaleźć ewentualne błędy (z ang. bugs). Wykorzystamy w tym celu program ald (Assembly Language Debugger). Jest to przykładowy debugger przeznaczony dla języka asembler. Pozwala on śledzić wykonywanie programu krok po kroku, jak również zatrzymać się tylko w konkretnych miejscach (tzw. pułapkach), by oglądnąć zawartość rejestrów, pamięci i stosu. Dzięki temu w prosty sposób możemy odnaleźć miejsca programu, gdzie jego działanie poszło nie po naszej myśli.

Instalacja

Źródła aktualnej wersji programu dostępne są na stronie projektu (http://sourceforge.net/projects/ald/). Wewnątrz rozpakowanego folderu ald-x.y.z wykonujemy jako zwykły użytkownik polecenia konfiguracji i kompilacji pakietu:

./configure make

Następnie w celu zainstalowania aplikacji wraz z dokumentacją man w naszym systemie jako administrator wydajemy polecenie:

make install

W niektórych dystrybucjach należy wydać polecenie:

sudo make install

W przypadku, gdy nie posiadamy konta administratora, skompilowany plik wykonywalny ald znajdujemy w katalogu ald-x.y.z/source, skąd możemy go skopiować do katalogu, z którego będziemy go wykonywać. W praktyce może to być ten sam katalog, w którym znajdują się pliki asm. Należy wówczas pamiętać, że w celu uruchomienia debugera wydajemy polecenie:

./ald

Możemy zatem przejść do następnego rozdziału.

Pierwsze uruchomienie Dla pewności, czy proces instalacji zakończył się pomyślnie możemy zapoznać się z podstawową dokumentacją pakietu wydając polecenie man ald, jak również uruchomić aplikację poleceniem ald bez żadnych argumentów.

[myself@localhost ~]$ ald Assembly Language Debugger 0.1.7 Copyright (C) 2000-2004 Patrick Alken

ald>

Chcąc zapoznać się z podstawową pomocą wewnątrz aplikacji wydajemy polecenie help. Aby opuścić aplikację wydajemy polecenie quit.

Prosta deasemblacja Wykorzystamy do tego celu skompilowaną wersję "pierwszego programu" wyświetlającego napis Hello world!. Uruchamiamy debugger podając nazwę pliku wykonywalnego jako argument:

ald hello

W efekcie czego otrzymamy podstawowe informacje dotyczące pliku wykonywalnego hello.

user@myhost:~$ ald hello Assembly Language Debugger 0.1.7 Copyright (C) 2000-2004 Patrick Alken

hello: ELF Intel 80386 (32 bit), LSB - little endian, Executable, Version 1 (Current) Loading debugging symbols...(10 symbols loaded) ald>

Aby deasemblować dany plik z poziomu ALD wprowadzamy polecenie d i potwierdzamy klawiszem ENTER.

ald> d 08048080: B804000000 mov eax, 0x4 08048085 BB01000000 mov ebx, 0x1 0804808A B9A4900408 mov ecx, 0x80490a4 0804808F BA0E000000 mov edx, 0xe 08048094 CD80 int 0x80 08048096 B801000000 mov eax, 0x1 0804809B BB05000000 mov ebx, 0x5 080480A0 CD80 int 0x80 080480A2 0000 add byte [eax], al 080480A4 48 dec eax 080480A5 656C insb 080480A7 6C insb 080480A8 6F outsd 080480A9 2C20 sub al, 0x20 080480AB 776F ja +0x6f (0x804811c) 080480AD 726C jc +0x6c (0x804811b) 080480AF 64210A and dword [fs:edx], ecx 080480B2 002E add byte [esi], ch 080480B4 7379 jnc +0x79 (0x804812f) 080480B6 6D insd 080480B7 7461 je +0x61 (0x804811a) 080480B9 6200 bound eax, dword [eax] 080480BB 2E7374 jnc +0x74 (0x8048131) 080480BE 7274 jc +0x74 (0x8048134) Hit to continue, or to quit

Widzimy, że pierwsze wiersze przykładowego listingu w ostatniej kolumnie do złudzenia przypominają niedawno kompilowany kod źródłowy napisany w języku asembler. Zauważamy jedynie, że używane etykiety często zastąpione są już konkretnymi adresami liczbowymi w używanej pamięci. Lewa kolumna zawiera kolejno adresy pamięci zajmowanej przez dane polecenie. Środkowa kolumna zawiera polecenia w kodzie maszynowym. W tym momencie nie chcemy znać zawartości dalszej pamięci, więc naciskamy klawisz q a następnie ENTER.

Wykonanie krok-po-kroku Aby wykonać pierwszą instrukcję, naciskamy n po czym klawisz ENTER.

ald> n eax = 0x00000004 ebx = 0x00000000 ecx = 0x00000000 edx = 0x00000000 esp = 0xBFE4B130 ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000 ds = 0x007B es = 0x007B fs = 0x0000 gs = 0x0000 ss = 0x007B cs = 0x0073 eip = 0x08048085 eflags = 0x00200212

Flags: AF IF ID

08048085 BB01000000 mov ebx, 0x1 ald>

Wartość rejestru EIP zawiera adres następnej instrukcji czekającej na wykonanie przez procesor. Ostatni wiersz powyższego listingu zawiera tę instrukcję. Aby ją wykonać, wystarczy już tylko nacisnąć ENTER.

ald> eax = 0x00000004 ebx = 0x00000001 ecx = 0x00000000 edx = 0x00000000 esp = 0xBFE4B130 ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000 ds = 0x007B es = 0x007B fs = 0x0000 gs = 0x0000 ss = 0x007B cs = 0x0073 eip = 0x0804808A eflags = 0x00200212

Flags: AF IF ID

0804808A B9A4900408 mov ecx, 0x80490a4 ald>

. . .

Możemy w ten sposób prześledzić, jak zmienia się zawartość rejestrów w trakcie wykonywania programu. Po wykonaniu ostatniej instrukcji powinniśmy otrzymać komunikat o zakończeniu działania programu.

. . .

ald> eax = 0x00000001 ebx = 0x00000005 ecx = 0x080490A4 edx = 0x0000000E esp = 0xBFE4B130 ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000 ds = 0x007B es = 0x007B fs = 0x0000 gs = 0x0000 ss = 0x007B cs = 0x0073 eip = 0x080480A0 eflags = 0x00200212

Flags: AF IF ID

080480A0 CD80 int 0x80 ald> Program terminated normally (Exit status: 0x0005) ald>

Warto zwrócić uwagę, że kod błędu zwracany przez program zawiera się w rejestrze EBX.

Wstrzymanie wykonania W przypadku dłuższych i bardziej skomplikowanych algorytmów wykonywanie krok po kroku może być uciążliwe i czasochłonne. Aby usprawnić ten proces możemy ustawić pułapkę (tzw. breakpoint) tylko w miejscu, w którym chcielibyśmy wykonanie programu wstrzymać, by odczytać jego stan i następnie prześledzić krok po kroku, w którym miejscu następuje błąd wykonania.

Przykładowo poniższy program miał za zadanie wyświetlenie zawartości rejestru EAX w systemie dziesiętnym.

;; decimalPrint.asm ;; Wypisuje zawartość EAX w systemie dziesiętnym

segment .text global _start _start: mov eax,0x0007 call _printEAXdecimal

;wyjscie mov eax,1 mov ebx,5 int 0x80

segment .data msg db ' '

segment .text

_printEAXdecimal: push edx push ecx push ebx push eax

mov ebx,10 mov ecx,10 xor edx,edx N1: div ebx add edx,48 dec ecx mov [msg+ecx],dl cmp ecx,0 jne N1

mov eax,4 mov ebx,1 mov ecx,msg mov edx,10 int 0x80

pop eax pop ebx pop ecx pop edx ret

Na pierwszy rzut oka wszystko wydaje się być w porządku. Kompilacja wraz z linkowaniem przebiegła pomyślnie. Próba wykonania programu daje jednak poniższy wynik:

user@myhost:~$ ./decimalPrint Floating point exception user@myhost:~$

Program nie miał wykonywać żadnych operacji zmiennoprzecinkowych. Przypuszczamy jednak, że problem może mieć miejsce w wierszu, w którym wykonujemy operację dzielenia całkowitego:

div ebx

Chcielibyśmy zatem wstrzymać działanie programu tuż przed wykonaniem tej operacji, by dokładnie sprawdzić argumenty instrukcji oraz wynik jej działania. W tym celu uruchamiamy debugger poleceniem:

user@myhost:~$ ald decimalPrint Assembly Language Debugger 0.1.7 Copyright (C) 2000-2004 Patrick Alken

decimalPrint: ELF Intel 80386 (32 bit), LSB - little endian, Executable, Version 1 (Current) Loading debugging symbols...(11 symbols loaded) ald>

Następnie przeprowadzamy deasemblację (klawisz d i ENTER) w celu poznania adresu wskaźnika do interesującej na instrukcji:

ald> d 08048080: B807000000 mov eax, 0x7 08048085 E80C000000 call near +0xc (0x8048096:_printEAXdecimal) 0804808A B801000000 mov eax, 0x1 0804808F BB05000000 mov ebx, 0x5 08048094 CD80 int 0x80 08048096: 52 push edx 08048097 51 push ecx 08048098 53 push ebx 08048099 50 push eax 0804809A BB0A000000 mov ebx, 0xa 0804809F B90A000000 mov ecx, 0xa 080480A4 31D2 xor edx, edx 080480A6: F7F3 div ebx 080480A8 81C230000000 add edx, 0x30 080480AE 49 dec ecx 080480AF 8891D8900408 mov byte [ecx+0x80490d8], dl 080480B5 81F900000000 cmp ecx, 0x0 080480BB 75E9 jne +0xe9 (0x80481a6) 080480BD B804000000 mov eax, 0x4 080480C2 BB01000000 mov ebx, 0x1 080480C7 B9D8900408 mov ecx, 0x80490d8 080480CC BA0A000000 mov edx, 0xa 080480D1 CD80 int 0x80 080480D3 58 pop eax Hit to continue, or to quit

Naciskamy klawisz q oraz ENTER, by nie wyświetlać dalszych obszarów pamięci. Szukany adres to 0x080480A6. Trzeba zatem pod wskazanym adresem ustawić pułapkę. Do tego celu służy polecenie break:

ald> break 0x080480a6 Breakpoint 1 set for 0x080480A6 ald>

Dla pewności możemy wyświetlić wszystkie zdefiniowane pułapki, aby mieć pewność, czy program nie będzie dodatkowo wstrzymany w żadnym innym miejscu. Do tego celu służy polecenie lbreak:

ald> lbreak Num Type Enabled Address IgnoreCount HitCount 1 Breakpoint y 0x080480A6 none 0 (N1+0x0) ald>

Jeśli wszystko się zgadza, możemy uruchomić program poleceniem run:

ald> run Starting program: decimalPrint Breakpoint 1 encountered at 0x080480A6 eax = 0x00000007 ebx = 0x0000000A ecx = 0x0000000A edx = 0x00000000 esp = 0xBFC9251C ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000 ds = 0x007B es = 0x007B fs = 0x0000 gs = 0x0000 ss = 0x007B cs = 0x0073 eip = 0x080480A6 eflags = 0x00000246

Flags: PF ZF IF

080480A6: F7F3 div ebx ald>

Przede wszystkim interesują nas zawartości rejestrów EAX, EBX oraz EDX, gdyż tylko one są argumentami powyższej instrukcji. Dzielna znajduje się w rejestrach EDX:EAX, natomiast dzielnik umieszczony jest w rejestrze EBX. Na tym etapie nie widać żadnych potencjalnych problemów, możemy więc kontynuować wykonanie programu krok po kroku używając polecenia n:

ald> n eax = 0x00000000 ebx = 0x0000000A ecx = 0x0000000A edx = 0x00000007 esp = 0xBFC9251C ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000 ds = 0x007B es = 0x007B fs = 0x0000 gs = 0x0000 ss = 0x007B cs = 0x0073 eip = 0x080480A8 eflags = 0x00000246

Flags: PF ZF IF

080480A8 81C230000000 add edx, 0x30 ald>

Dzielenie całkowite zostało wykonane poprawnie. Wynik dzielenia znajduje się w rejestrze EAX, natomiast reszta z dzielenia w rejestrze EDX. Być może w następnym przebiegu pętli ujawnią się jakieś problemy. Kontynuujemy zatem wykonanie programu poleceniem continue (lub w skrócie c):

ald> c Breakpoint 1 encountered at 0x080480A6 eax = 0x00000000 ebx = 0x0000000A ecx = 0x00000009 edx = 0x00000037 esp = 0xBFC9251C ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000 ds = 0x007B es = 0x007B fs = 0x0000 gs = 0x0000 ss = 0x007B cs = 0x0073 eip = 0x080480A6 eflags = 0x00000206

Flags: PF IF

080480A6: F7F3 div ebx ald>

Na pierwszy rzut oka tym razem również wszystko jest w porządku. Jednak po wnikliwej analizie zawartości rejestrów zauważymy, że w rejestrze EDX znajdują się pozostałości z poprzedniego obiegu pętli. Aby uniknąć błędnych wyników, należy poprawić kod tak, aby zerowanie rejestru EDX przeprowadzać na początku każdego obiegu pętli przed wykonaniem operacji dzielenia. Spróbujemy mimo wszystko kontynuować działanie programu krok po kroku:

ald> n

Program received signal SIGFPE (Arithmetic exception) Location: 0x080480A6 eax = 0x00000000 ebx = 0x0000000A ecx = 0x00000009 edx = 0x00000037 esp = 0xBFBA9ADC ebp = 0x00000000 esi = 0x00000000 edi = 0x00000000 ds = 0x007B es = 0x007B fs = 0x0000 gs = 0x0000 ss = 0x007B cs = 0x0073 eip = 0x080480A6 eflags = 0x00010206

Flags: PF IF RF

080480A6: F7F3 div ebx ald>

Widzimy, że operacja dzielenia nie została wykonana i zgłoszony jest wyjątek za pomocą sygnału SIGFPE. Kolejna próba wykonania operacji skończy się zamknięciem programu wraz ze zwróceniem kodu błędu:

ald> n Program terminated with signal SIGFPE (Arithmetic exception) ald>

Po wprowadzeniu stosownych poprawek prawidłowy kod źródłowy będzie miał postać:

;; Wypisuje zawartość EAX w systemie dziesiętnym

segment .text global _start _start: mov eax,0x0007 call _printEAXdecimal

;wyjscie mov eax,1 mov ebx,5 int 0x80

segment .data msg db ' '

segment .text