[L2H] – Debugging with gdb – Part 1

L2H ဆိုတာကေတာ့ Learn to Hack လို႕ဆိုလိုတာပါ ။ ဆိုလိုတာကေတာ့ L2H နဲ႕စတဲ့ post ေလးေတြက Hacking မလုပ္ခင္ေလ့လာေစခ်င္တဲ့ဟာေလးေတြေပါ့။ Hack ၾကည့္ျပီးမွရလာတဲ့ သင္ခန္းစာေတြကေတာ့ Hack to Learn ေပါ့ ။ ဟုတ္သာမဟုတ္သာအသာထား Blog မွာေတာ့ ရွာရလြယ္တာေပါ့။

တကယ္လို႕ Binary Exploitation ေတြဘာေတြေလ့လာမယ့္သူေတြအေနနဲ႕ Debugging ကို အနည္းဆံုး အေျခခံေလာက္ေတာ့သိထားဖို႕လိုပါတယ္။ ဒါမွ ေကာင္းေကာင္းနားလည္နိုင္မွာျဖစ္တယ္။ မဟုတ္ရင္ေတာ့ သူမ်ားဆြဲျပထားတဲ့ Visual ေလးေတြနဲ႕ ဟုတ္လိမ့္နိုးနုိး လက္ခံရပါလိမ့္မယ္။ Program တစ္ခုကို ကိုယ္တိုင္ေရးၾကည့္ ျပီးရင္ Debug လုပ္ၾကည့္ဆိုရင္ေတာ့ အဲ့လိုမျဖစ္ေတာ့ဘူးေပါ့။ ကိုယ္တိုင္မ်က္ေစ့နဲ႕ ျမင္လိုက္ရတာျဖစ္တဲ့အတြက္ ပိုလဲမွတ္မိမယ္လို႕ထင္ပါတယ္။ ေနာက္တစ္ခုကေတာ့ Exploitation ေတြကိုစမ္းတဲ့အခါ အျမဲတမ္း သူမ်ားျပထားတဲ့အတိုင္း မျဖစ္ပါဘူး။ က်ေနာ္တို႕စက္ေတြကမတူၾကဘူးမလား။ အဲ့ဒီအတြက္ မတူတာေလးေတြကေတာ့ရွိမယ္။

Debugger တစ္ခုကဘာေတြလုပ္လို႕ရလဲ?

Set Breakpoints 
Enable Single Step Mode
View CPU registers 
View Process Memory 
Disassemble instructions
Attach to a running process 
and etc ...

Command ေတြအတြက္ေတာ့ ပူစရာမလိုဘူး Cheat Sheet ေတြရွာလို႕ရတယ္။ အဓိက ဘယ္လိုအသံုးျပဳရမယ္ဆိုတာကိုပဲ က်ေနာ္တို႕ေလ့လာဖို႕လိုမယ္။

Example Cheatsheet

https://darkdust.net/files/GDB%20Cheat%20Sheet.pdf

အမ်ားၾကီးရွိပါေသးတယ္။ ကိုယ္ၾကိုက္တဲ့ Cheat sheet သိမ္းထားေပါ့။

ဒီလုိုဆို အသံုးျပဳဖို႕ကုိက်ေနာ္တို႕ေလ့လာၾကမယ္။ ဘယ္လိုေလ့လာမလဲ ? က်ေနာ္႕မွာ idea ေလးတစ္ခုေတာ့ရွိတယ္။ အဲဒါေလးကိုပဲ သံုးတာေပါ့။

လိုအပ္တာေလးေတြကေတာ့

C Program

Understand how C Program work

Debug it

ဒီလိုမ်ိဳး အၾကမ္းဖ်င္းခ်လိုက္မယ္။ ဒီေတာ့ေသခ်ာတာက C Program ေလးေတြလိုမယ္။

1.Hello World

#include <stdio.h>
int main()
{
        printf("Hello World");
}

Compilation

compile လုပ္တဲ့အခါမွာ C code ကိုပါ debug လုပ္တဲ့အခါ ပါေစခ်င္ရင္ေတာ့ -ggdb ကိုသံုးျပီး Compile လုပ္လို႕ရပါတယ္။

root@exploitdev:~/GDB# gcc -ggdb -o helloworld helloworld.c

Running program

root@exploitdev:~/GDB# ./helloworld
Hello World

Starting gdb

Hello Worldroot@exploitdev:~/GDB# gdb helloworld
GNU gdb (Ubuntu 7.11.1-0ubuntu1~16.5) 7.11.1
Copyright (C) 2016 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from helloworld...done.
(gdb)

အေပၚမွာ သံုးခဲ့တဲ့ -ggdb option ကဘာေတြထူးျခားသြားလဲ ?

(gdb) list
1       #include <stdio.h>
2       int main()
3       {
4               printf("Hello World");
5       }

Source code ကို debug လုပ္တဲ့အခါပါခ်င္ရင္ သံုးတယ္လို႕ေျပာခဲ့ပါတယ္။

gdb ကို သံုးတဲ့အခါ Linux မွာဆိုေတာ့ Default က AT&T syntax ေတြျဖစ္ေနပါလိမ့္မယ္။

(gdb) disas main
Dump of assembler code for function main:
   0x0000000000400526 <+0>:     push   %rbp
   0x0000000000400527 <+1>:     mov    %rsp,%rbp
   0x000000000040052a <+4>:     mov    $0x4005c4,%edi
   0x000000000040052f <+9>:     mov    $0x0,%eax
   0x0000000000400534 <+14>:    callq  0x400400 <printf@plt>
   0x0000000000400539 <+19>:    mov    $0x0,%eax
   0x000000000040053e <+24>:    pop    %rbp
   0x000000000040053f <+25>:    retq
End of assembler dump.

ေနာက္တစ္ခုက အခုဆိုရင္ 64 bits Instructions ေတြျဖစ္ေနျပန္ေရာ ? 32 ကိုပဲအရင္လုပ္ခ်င္တာျဖစ္တယ္။ 32 bits Architecture သြင္းလိုက္ရင္ ရပါတယ္။

32 Bit Architecture သြင္းရန္

sudo apt-get update
sudo dpkg --add-architecture i386
sudo apt-get install libc6:i386 libncurses5:i386 libstdc++6:i386
apt install libc6-dev-i386

ဒီလုိဆိုရင္ program ကို 32 bit executable ELF file ျပန္ရေအာင္ Compile ျပန္လုပ္မယ္။

အဆင္ေျပမေျပၾကည့္မယ္။

root@exploitdev:~/GDB# gcc -ggdb -m32 -o helloworld helloworld.c
root@exploitdev:~/GDB# file helloworld
helloworld: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=4086985f4c7dcd5de64ad97774ef35d526628eb8, not stripped

ELF 32-bit ျဖစ္သြားျပီ။ ဒါဆို gdb အေၾကာင္းျပန္ဆက္မယ္။

Main function ကိုပဲ disassemble ျပန္လုပ္မယ္ ။ သံုးရမယ့္ command က

disas <function_name>

(gdb) disas main
Dump of assembler code for function main:
   0x0804840b <+0>:     lea    0x4(%esp),%ecx
   0x0804840f <+4>:     and    $0xfffffff0,%esp
   0x08048412 <+7>:     pushl  -0x4(%ecx)
   0x08048415 <+10>:    push   %ebp
   0x08048416 <+11>:    mov    %esp,%ebp
   0x08048418 <+13>:    push   %ecx
   0x08048419 <+14>:    sub    $0x4,%esp
   0x0804841c <+17>:    sub    $0xc,%esp
   0x0804841f <+20>:    push   $0x80484c0
   0x08048424 <+25>:    call   0x80482e0 <printf@plt>
   0x08048429 <+30>:    add    $0x10,%esp
   0x0804842c <+33>:    mov    $0x0,%eax
   0x08048431 <+38>:    mov    -0x4(%ebp),%ecx
   0x08048434 <+41>:    leave
   0x08048435 <+42>:    lea    -0x4(%ecx),%esp
   0x08048438 <+45>:    ret
End of assembler dump.

32 bits ေတြေတာ့ျဖစ္သြားျပီ။ Intel Syntax ကို ေျပာင္းခ်င္တယ္။ ( Windows ေရာ Linux ေရာ အတြက္ တစ္ခုပဲ မွတ္ေစခ်င္တာပါ ၊ instructions ေတြရဲ႕ source , destination စတာေတြမတူၾကပါဘူး )

gdb မွာ Intel syntax အေနနဲ႕ ျပေစခ်င္ရင္ သံုးတဲ့ Command ရွိပါတယ္။

(gdb) disas main
Dump of assembler code for function main:
   0x0804840b <+0>:     lea    ecx,[esp+0x4]
   0x0804840f <+4>:     and    esp,0xfffffff0
   0x08048412 <+7>:     push   DWORD PTR [ecx-0x4]
   0x08048415 <+10>:    push   ebp
   0x08048416 <+11>:    mov    ebp,esp
   0x08048418 <+13>:    push   ecx
   0x08048419 <+14>:    sub    esp,0x4
   0x0804841c <+17>:    sub    esp,0xc
   0x0804841f <+20>:    push   0x80484c0
   0x08048424 <+25>:    call   0x80482e0 <printf@plt>
   0x08048429 <+30>:    add    esp,0x10
   0x0804842c <+33>:    mov    eax,0x0
   0x08048431 <+38>:    mov    ecx,DWORD PTR [ebp-0x4]
   0x08048434 <+41>:    leave
   0x08048435 <+42>:    lea    esp,[ecx-0x4]
   0x08048438 <+45>:    ret
End of assembler dump.

နွိင္းယွဥ္ၾကည့္မယ္ဆိုရင္ AT&T နဲ႕ Intel ဘယ္လိုကြာတယ္ဆိုတာသိနိုင္ပါတယ္။ source destination စတာေတြ ေျပာင္းျပန္ျဖစ္ေနသလို % ေတြ က်ေနာ္တို႕ကို မ်က္ေစ့ရွုပ္ေစပါတယ္။

Breakpoints

Program တစ္ခုကို ကိုယ္ရပ္ေစခ်င္တဲ့ Instruction မွာ အလုပ္မလုပ္ပဲရပ္ထားခ်င္တယ္ဆိုရင္ေတာ့ breakpoint ေတြသတ္မွတ္လို႕ရပါတယ္။

(gdb) break main
Breakpoint 1 at 0x804841c: file helloworld.c, line 4.
(gdb) break *main+25
Breakpoint 2 at 0x8048424: file helloworld.c, line 4.
(gdb) break *0x08048438
Breakpoint 3 at 0x8048438: file helloworld.c, line 5.

function name နဲ႕ break လို႕ရပါတယ္။ main function ေရာက္ရင္ break မယ္ေပါ့။

ေနာက္တစ္ခုကေတာ့ *main+25 ဆိုျပီး ကိုယ္ရပ္ေစခ်င္တဲ့ instruction မွာရပ္လို႕ရပါတယ္။

address နဲ႕လဲ breakpoint ထားလို႕ရမယ္။

Breakpoint ေတြကိုျပန္ၾကည့္ခ်င္တယ္။

(gdb) info b
Num     Type           Disp Enb Address    What
1       breakpoint     keep y   0x0804841c in main at helloworld.c:4
2       breakpoint     keep y   0x08048424 in main at helloworld.c:4
3       breakpoint     keep y   0x08048438 in main at helloworld.c:5

Num 1 Breakpoint ကို မလိုေတာ့လို႕ ဖ်က္ပစ္လိုက္ခ်င္တယ္။

(gdb) del 1
(gdb) info b
Num     Type           Disp Enb Address    What
2       breakpoint     keep y   0x08048424 in main at helloworld.c:4
3       breakpoint     keep y   0x08048438 in main at helloworld.c:5

အကုန္ဖ်က္မယ္။

(gdb) del
Delete all breakpoints? (y or n) y
(gdb) info b
No breakpoints or watchpoints.

C source code ပါတဲ့ program ေတြဆိုရင္ေတာ့ Line Number နဲ႕ပါ break လို႕ရပါတယ္။

(gdb) list
1       #include <stdio.h>
2       int main()
3       {
4               printf("Hello World");
5       }
(gdb) break 4
Breakpoint 4 at 0x804841c: file helloworld.c, line 4.
(gdb) info b
Num     Type           Disp Enb Address    What
4       breakpoint     keep y   0x0804841c in main at helloworld.c:4

Running Program with gdb

r or run စသည္ျဖင့္သံုးျပီး run လို႕ရပါတယ္။ ခုနက printf မွာ Breakpoint ထားခဲ့ေတာ့ အဲ့ေနရာမွာ ရပ္သြားတယ္။

(gdb) r
Starting program: /root/GDB/helloworld

Breakpoint 4, main () at helloworld.c:4
4               printf("Hello World");

break ထားရာကေန ဆက္ျပီး အလုပ္လုပ္ေစခ်င္တယ္ဆိုရင္ေတာ့ c or continue ကိုသံုးျပီး ဆက္သြားခိုင္းလို႕ရပါတယ္။

(gdb) continue
Continuing.
Hello World[Inferior 1 (process 8111) exited normally]

Break ထားရာကေန ေနာက္ထပ္ code တစ္ေၾကာင္းပဲ အလုပ္လုပ္ေစခ်င္တယ္ဆိုရင္ေတာ့

next or step စတဲ့ Command ေတြကိုသံုးလို႕ရပါတယ္။

(gdb) r
Starting program: /root/GDB/helloworld

Breakpoint 4, main () at helloworld.c:4
4               printf("Hello World");
(gdb) next
5       }
(gdb) step
0xf7e2d637 in __libc_start_main () from /lib/i386-linux-gnu/libc.so.6
(gdb) next
Single stepping until exit from function __libc_start_main,
which has no line number information.
Hello World[Inferior 1 (process 8117) exited normally]

ဒါေပမဲ့ အဲဒါက instuction တစ္ေၾကာင္းမဟုတ္ပါဘူး code တစ္ေၾကာင္းျဖစ္ပါတယ္။ ဒီလိုဆို instruction တစ္ေၾကာင္းကိုဆိုရင္ေရာ?

(gdb) r
Starting program: /root/GDB/helloworld

Breakpoint 4, main () at helloworld.c:4
4               printf("Hello World");
(gdb) ni
0x0804841f      4               printf("Hello World");
(gdb) si
0x08048424      4               printf("Hello World");
(gdb) ni
0x08048429      4               printf("Hello World");
(gdb) ni
0x0804842c      4               printf("Hello World");
(gdb) ni
5       }
(gdb) ni
0x08048434      5       }
(gdb) ni
0x08048435      5       }
(gdb) ni
0x08048438      5       }
(gdb) ni
0xf7e2d637 in __libc_start_main () from /lib/i386-linux-gnu/libc.so.6

ထြက္လာတဲ့ result အရဆိုရင္ က်ေနာ္တို႕ instruction တစ္ေၾကာင္းခ်င္းမလို႕ printf ကို လုပ္ေနတဲ့အခ်ိန္မွာ ပိုမ်ားေနတာေတြ႕ရမွာျဖစ္ပါတယ္။ ( မွတ္ခ်က္ ၊ ၊ ဒီေနရာမွာ က်ေနာ္တို႕ Assembly အေၾကာင္းကိုမေျပာေသးပါဘူး )

2.Local Variables and Stack

#include <stdio.h>
int main()
{
        int local_variable=13;
        printf("Local Variable=%d",local_variable);
}

Local Variable ေတြကို Stack ထဲမွာသိမ္းတာျဖစ္လို႕ gdb မွာ ဘယ္လို memory ကို ၾကည့္လို႕ရမလဲ ဆိုတာေတြကိုေလ့လာလို႕ရပါမယ္။

Run တာေတြ compile လုပ္တာေတြ မေျပာေတာ့ဘူး ။ ျပေတာ့ျပသြားမယ္။

root@exploitdev:~/GDB# gcc -m32 -ggdb -o localstack localstack.c
root@exploitdev:~/GDB# ./localstack
Local Variable=13

printing with gdb

value ေတြကို ၾကည့္ခ်င္တဲ့အခါမွာသံုးပါတယ္။ ဒီေနရာမွာတစ္ခုရွိတာက Program က run လိုက္ျပီဆိုရင္ လုပ္စရာရွိတာလုပ္ျပီး ထြက္သြားမွာျဖစ္တယ္။ ဒါေၾကာင့္ main function ရဲ႕ ret မွာ breakpoint တစ္ခုထားလိုက္ရင္ program က exit ျဖစ္မွာမဟုတ္ေတာ့ဘူး။ ရည္ရြယ္ခ်က္ကေတာ့ register ေတြက်န္ေနေစခ်င္တာေၾကာင့္ျဖစ္ပါတယ္။

(gdb) break *main+55
Breakpoint 1 at 0x8048442: file localstack.c, line 6.

Ok run မယ္

(gdb) run
Starting program: /root/GDB/localstack

Breakpoint 1, 0x08048442 in main () at localstack.c:6
6       }

ရပ္ေနျပီ။ ဒီအခ်ိန္မွာ print ကိုသံုးျပီးဘာေတြထုတ္လို႕ရလဲဆိုတာစမ္းမယ္။

(gdb) list
1       #include <stdio.h>
2       int main()
3       {
4               int local_variable=13;
5               printf("Local Variable=%d",local_variable);
6       }
(gdb) print local_variable
Cannot access memory at address 0xfffffff4

မရဘူး ျဖစ္ေနပါလား ? ဟုတ္တယ္ မရွိေတာ့ဘူး။ leave လုပ္ျပီးျပီဆိုတာနဲ႕ Stack frame ကမရွိေတာ့ဘူးေလ။ ဒါဆိုရင္ printf မွာ break မယ္ ၊ Line Number နဲ႕ break မယ္

(gdb) del 1
(gdb) break 5
Breakpoint 2 at 0x8048423: file localstack.c, line 5.

ျပန္ run မယ္

(gdb) run
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /root/GDB/localstack

Breakpoint 2, main () at localstack.c:5
5               printf("Local Variable=%d",local_variable);

Nice 😉

(gdb) print local_variable
$1 = 13

local_variable ထဲမွာ 13 ရွိတယ္ေပါ့။ အိုေကဒီလိုဆို print ရဲ႕ format ေလးေတြရွိေသးတယ္တဲ့ဗ်။

(gdb) print/x local_variable
$2 = 0xd

0xd က 13 (hex) ၊ ဒီေတာ့ Hexadecimal value ရတယ္ဆိုပါေတာ့။ format ေလးေတြသိထားဖို႕လိုမယ္

Format

a -> Pointer.
c -> Read as integer, print as character.
d -> Integer, signed decimal.
f -> Floating point number.
o -> Integer, print as octal.
s -> Try to treat as C string.
t -> Integer, print as binary (t = „two“).
u ->Integer, unsigned decimal.
x -> Integer, print as hexadecimal

Watchpoints

Break point လိုမ်ိဳး watchpoints လဲရွိပါေသးတယ္။ ဒါကေတာ့ variable ကိုေစာင့္ၾကည့္ခ်င္တဲ့အခါမွာသံုးတယ္။ ဥပမာ local_variable ကို ေစာင့္ၾကည့္ခ်င္တယ္ဆိုပါေတာ့ ။ watchpoint ထားလိုက္မယ္။ value ကိုျပင္လိုက္ျပီဆိုရင္ watchpoint ကရပ္ျပီးေတာ့ က်ေနာ္တို႕ကို old value နဲ႕ modified value ကိုျပမွျဖစ္တယ္။ ဒါကိုျမင္ခ်င္ေတာ့ က်ေနာ္က ခုန program ေလးကိုျပင္လိုက္တယ္။

#include <stdio.h>
int main()
{
        int local_variable=13;
        printf("Local Variable=%d",local_variable);
        local_variable=16;
}

watchpoint ကိုစမ္းမယ္။ ဒီေတာ့ printf မွာတစ္ခါ } မွာတစ္ခါ break ရမွာေပါ့။ အေျခေနကိုၾကည့္ခ်င္တာကိုး

(gdb) list
1 #include <stdio.h>
2 int main()
3 {
4 int local_variable=13;
5 printf("Local Variable=%d",local_variable);
6 local_variable=16;
7 }
(gdb) break 4
Breakpoint 1 at 0x804841c: file localstack.c, line 4.
(gdb) break 7
Breakpoint 2 at 0x8048442: file localstack.c, line 7.

run မယ္ watch မယ္။

(gdb) r
Starting program: /root/GDB/localstack

Breakpoint 1, main () at localstack.c:4
4               int local_variable=13;
(gdb) watch local_variable
Hardware watchpoint 3: local_variable

ဟုတ္ျပီ printf ကိုထုတ္ခိုင္းလိုက္ေတာ့မယ္။

(gdb) continue
Continuing.

Hardware watchpoint 3: local_variable

Old value = 134513777
New value = 13
main () at localstack.c:5
5               printf("Local Variable=%d",local_variable);

ဒီမွာတည္းက break ျပီးက်ေနာ္တို႕ကို လာျပတာကိုေတြ႕ရမွာျဖစ္ပါတယ္။

ဒါဆိုရင္ 16 ကိုထည့္တဲ့အခ်ိန္က်ရင္ေရာ?

(gdb) continue
Continuing.

Hardware watchpoint 3: local_variable

Old value = 13
New value = 16
0x0804843d in main () at localstack.c:6
6               local_variable=16;

ထပ္ break တယ္ လာျပတယ္။ က်ေနာ္တို႕ Break point ေတြကအဲ့မွာမဟုတ္ဘူးေလ ။ အခုမွလာမွာ

(gdb) continue
Continuing.

Breakpoint 2, main () at localstack.c:7
7       }

Examining the stack

esp address ကဘာလဲ ?

(gdb) print $esp
$1 = (void *) 0xffffd640

print လိုက္ယံုပဲျဖစ္ပါတယ္။ ဒါဆို ebp ကေရာ?

(gdb) print $epb
$2 = void
(gdb) x $ebp
0xffffd658:     0x00000000

print လို႕မရဘူး ။ ဒီေတာ့ examine လုပ္တဲ့ command x ကိုသံုးျပီးေတာ့ ၾကည့္လို႕ရပါတယ္။ esp ကိုလဲ ဒီလိုပဲျပန္ၾကည့္မယ္။ print နဲ႕ examine ဘာကြာလဲသိရေအာင္

(gdb) x $esp
0xffffd640:     0x00000001

Print က address ကိုျပတယ္။ x ကေတာ့ address နဲ႕ value ကို ယွဥ္ျပီးျပတယ္။တျခား format ေတြလဲရွိေသးတယ္။

(gdb) x/16x $esp
0xffffd640:     0x00000001      0xffffd704      0xffffd70c      0x08048471
0xffffd650:     0xf7fc73dc      0xffffd670      0x00000000      0xf7e2d637
0xffffd660:     0xf7fc7000      0xf7fc7000      0x00000000      0xf7e2d637
0xffffd670:     0x00000001      0xffffd704      0xffffd70c      0x00000000

4*4 = 16

esp ကေန ပိုၾကီးတဲ့ address ေတြကေန 16 bytes စာထပ္ျပတာျဖစ္ပါတယ္။

ဒီေတာ့ Stack frame ကဘယ္လိုျဖစ္သြားမလဲ ? esp လဲသိတယ္ ebp လဲသိတယ္။

0x00000001      <-  ESP
0xffffd704      
0xffffd70c      
0x08048471
0xf7fc73dc      
0xffffd670      
0x00000000      <- EBP
0xf7e2d637
0xf7fc7000      
0xf7fc7000      
0x00000000      
0xf7e2d637
0x00000001      
0xffffd704      
0xffffd70c      
0x00000000

ဒါမွမဟုတ္ Register ေတြကိုၾကည့္မယ္ဆိုရင္ေရာ? info registers ဆိုျပီးၾကည့္လို႕ရပါတယ္။ i r ကေတာ့အတိုေပါ့။

(gdb) info registers
eax            0xf7fc8dbc       -134443588
ecx            0xffffd670       -10640
edx            0xffffd694       -10604
ebx            0x0      0
esp            0xffffd640       0xffffd640
ebp            0xffffd658       0xffffd658
esi            0xf7fc7000       -134451200
edi            0xf7fc7000       -134451200
eip            0x804841c        0x804841c <main+17>
eflags         0x282    [ SF IF ]
cs             0x23     35
ss             0x2b     43
ds             0x2b     43
es             0x2b     43
fs             0x0      0
gs             0x63     99

gdb မွာ value ေတြကိုေရာ ေျပာင္းလို႕ရေသးလား? ebx ကို ေျပာင္းၾကည့္မယ္ 0x0 ကေန 0x1

(gdb) set $ebx=0x1
(gdb) i r
eax            0xf7fc8dbc       -134443588
ecx            0xffffd670       -10640
edx            0xffffd694       -10604
ebx            0x1      1
esp            0xffffd640       0xffffd640
ebp            0xffffd658       0xffffd658
esi            0xf7fc7000       -134451200
edi            0xf7fc7000       -134451200
eip            0x804841c        0x804841c <main+17>
eflags         0x282    [ SF IF ]
cs             0x23     35
ss             0x2b     43
ds             0x2b     43
es             0x2b     43
fs             0x0      0
gs             0x63     99

ဒါကေတာ့ Basic အေနနဲ႕သိထားရမယ့္ gdb နဲ႕ debugging လုပ္တာေလးေတြျဖစ္ပါတယ္ ။

အျပည့္အဝ ေလ့လာခ်င္ရင္ေတာ့ GDB Documentation က အေကာင္းဆံုးျဖစ္ပါလိမ့္မယ္။

GDB Documentation

https://sourceware.org/gdb/current/onlinedocs/gdb/

 

1 Trackback / Pingback

  1. [L2H] – Debugging with gdb – Part 2 – Legion of LOL

Comments are closed.