Lab 01: GDB Tutorial

1. Overview
gdb is a debugger for C (and C++). It allows you to do things like running a program up to a certain
point, then stop and print out the values of particular variables at that point, or step through the program
line-by-line, and print out the values of individual variable after executing each line. gdb uses a
command line interface.

2. Objectives
This lab aims to provide students with ability:

a) To compose/edit code in Linux terminal with nano text editor or remotely in VSCode
b) To compile source code with various gcc options for debugging in gdb;
c) To load, set breakpoints, run program step-by-step, examining CPU registers, memory areas.

3. Lab Environment
Students can either practice the labs with Ubuntu linux VM (VirtualBox) or WSL2 (preferable).
On either way, install nasm, gcc, gdb-peda by doing the following commands at linux prompt:
~# sudo apt update
~# sudo apt install git nasm gcc gcc-multilib
~# git clone https://github.com/longld/peda.git ~/peda
~# echo "source ~/peda/peda.py" >> ~/.gdbinit
For writing code, students are recommend to install VSCode with the following extensions:

Extensions Description

nasm x86 syntax highlighting Code highlighting

Remote - WSL Code in WSL remotely

Remote - SSH Connect to VM via ssh to code remotely

Note for Apple computer equipped with Apple silicon processor:

This lab (and all the subsequent ones) only runs on computers with Intel processors. Students
who own the Apple-silicon processor (M1/M2) computers must use a cloud-based VM or
github codespaces (preferable).

4. GDB tutorial
This is a brief description some of the most commonly used features of gdb.

4.1. Compiling

The simplest instruction format to compile a C program to executable code

~# gcc -o test.out test.c // test.out is executable file, test.c is source file

To compile to 32-bit executable code, use -m32 option:

~# gcc -m32 -o test.out test.c // compile to 32-bit executable code

To enable debugging executable code in gdb, compile with the -g flag:

~# gcc -g -m32 -o test.out test.c // compile to 32-bit executable code, embedding symbols for debug

Sometime, to make the machine code easy to read, the flag -mpreferred-stack-boundary=2 is used

~# gcc -g -m32 -o test.out test.c -mpreferred-stack-boundary=2

2.2. Invoking and Quitting GDB

Load your program for debugging in quiet:

~# gdb test.out -q

Reading symbols from test.out . . .

gdb-peda$

To exit gdb, just type q at the gdb prompt.

Summary of commonly used commands in gdb

Command Description Additional information Example

disas Assemble memory bytes into disas <address> disas main
assembly code and display disas func
(disassemble)
start Start debugging program start
run Execute code until breakpoint is
met or till the end
break Set breakpoints break function break main
break <label> break _next
break <line no in source code> break 10
break *address break *0xbffff2d3
info break List breakpoint defined ib
delete remove breakpoints delete breakpoint 2
step Execute one line of source code step – step into
stepi next – step over
finish – continue the execution
until return
continue Continue execute the next
instruction until break point is met
info Display a summary of the current i r [register] ir
register registers and flags
info local Display local variables
info var Display variables/symbols
print Print out the value of a specific options for output format print mem
register or variable /x – hex, /d – signed decimal, /u print $esp
– unsigned decimal, /t – binary, p/x mem
/c – character, /f – floating point p/s mem
number
x Examining memory x/nfu <address> x/20xb &msg
 n – the repeat count x/20xw
f – the display format (x – hex, I x/i $eip
– machine instruction, s - string) x/20xb $eip
u – the unit size x/s &msg
(b - byte, h – two bytes, w – four
bytes, g – eight bytes)
set Change the value of a variable or set a=5
specific memory area

4. Tasks
4.1. Compose a simple C program vscode

Within the Terminal window of VSCode:

~$ code test.c
Enter the following program:

#include <stdio.h>
void func(int x, int y)
{
x = x + y;
printf("%d\n",x);
}
int main()
{
int a=5;
int b=7;
func(a,b);
printf("Hello\n");
return 0;
}
4.2. Compile source code

Compile source code with gcc

~# gcc -g -m32 test.c -o test.out -mpreferred-stack-boundary=2

The executable file test.out now is ready for debugging

4.3. Load, debug, disassemble code

Load program in gdb

gdb test.out -q

display source code of main function:

gdb-peda$ list
Disassemble main function (watch main function in assembly)

gdb-peda$ disas main

Dump of assembler code for function main:

=> 0x5655621f <+0>: endbr32
0x56556223 <+4>: push ebp
0x56556224 <+5>: mov ebp,esp
0x56556226 <+7>: push ebx
0x56556227 <+8>: sub esp,0x8
0x5655622a <+11>: call 0x565560f0 <__x86.get_pc_thunk.bx>
0x5655622f <+16>: add ebx,0x2da5
0x56556235 <+22>: mov DWORD PTR [ebp-0xc],0x5
0x5655623c <+29>: mov DWORD PTR [ebp-0x8],0x7
0x56556243 <+36>: push DWORD PTR [ebp-0x8]
0x56556246 <+39>: push DWORD PTR [ebp-0xc]
0x56556249 <+42>: call 0x565561ed <func>
0x5655624e <+47>: add esp,0x8
0x56556251 <+50>: lea eax,[ebx-0x1fc8]
0x56556257 <+56>: push eax
0x56556258 <+57>: call 0x56556090 <puts@plt>
0x5655625d <+62>: add esp,0x4
0x56556260 <+65>: mov eax,0x0
0x56556265 <+70>: mov ebx,DWORD PTR [ebp-0x4]
0x56556268 <+73>: leave
0x56556269 <+74>: ret

End of assembler dump.

Disassemble func function (watch func function in assembly)

gdb-peda# disas func

0x565561ed <+0>: endbr32

0x565561f1 <+4>: push ebp
0x565561f2 <+5>: mov ebp,esp
0x565561f4 <+7>: push ebx
0x565561f5 <+8>: call 0x5655626a <__x86.get_pc_thunk.ax>
0x565561fa <+13>: add eax,0x2dda
0x565561ff <+18>: mov edx,DWORD PTR [ebp+0xc]
0x56556202 <+21>: add DWORD PTR [ebp+0x8],edx
0x56556205 <+24>: push DWORD PTR [ebp+0x8]
0x56556208 <+27>: lea edx,[eax-0x1fcc]
0x5655620e <+33>: push edx
0x5655620f <+34>: mov ebx,eax
0x56556211 <+36>: call 0x56556080 <printf@plt>
0x56556216 <+41>: add esp,0x8
0x56556219 <+44>: nop
0x5655621a <+45>: mov ebx,DWORD PTR [ebp-0x4]
0x5655621d <+48>: leave
0x5655621e <+49>: ret
4.4. Examine the registers and memory

Insert breakpoints

To examine registers, the program needed to be executed and stop at a particular point. You need to
insert breakpoints to do this.

Set breakpoints at the beginning of main and func functions:

gdb-peda$ break main
Breakpoint 1 at 0x12b5
gdb-peda$ break func
Breakpoint 2 at 0x1276

List all breakpoints defined:

gdb-peda$ i b
Num Type Disp Enb Address What
1 breakpoint keep y 0x000012b5 <main+15>
2 breakpoint keep y 0x00001276 <func+4>
Execute program, the code execution will stop at the first breakpoint which is the first instruction of the
main function:
gdb-peda$ r

Examine the registers (*)

gdb-peda$ info reg

All registers and values will be displayed

Examine the memory (*)
Use the x command (try with various unit size b - byte, h – two bytes, w – four bytes, g – eight bytes):
a) To display 24 bytes the code of main function.
b) To display 24 bytes the code from the current instruction.
c) To display 32 bytes of the stack memory from the top of stack.
4.5. Debug program (*)

a) Execute the program step by step then examine the values of variables a, b in main()
b) Try to set a, b to values other than 5,7 while executing program then check the final result.