พื้นฐานเครื่องมือดีบัก (GDB, WinDbg)

Welcome to dynamic analysis! Here, we'll learn about debuggers, powerful tools that let you see a program in action.

A debugger allows you to pause a running program, inspect its internal state (like memory and registers), and even change its execution path. It's like having X-ray vision for software!

In reverse engineering, debuggers are crucial for understanding how a program behaves at runtime. While static analysis (looking at code without running it) gives you clues, dynamic analysis shows you the truth.

• See actual data values as they change.
• Observe which code paths are taken.
• Understand interactions with the operating system.

We'll focus on two primary debuggers:

• GDB (GNU Debugger): The standard debugger for Linux, macOS, and other Unix-like systems. It's command-line based and highly versatile.
• WinDbg: A powerful debugger for Windows, often used for kernel-mode debugging and complex user-mode issues. It has both a GUI and a command-line interface.

Regardless of the debugger, you'll perform a few fundamental actions:

• Loading a Binary: Starting a program directly under the debugger's control.
• Attaching to a Process: Connecting the debugger to a program that is already running.
• Inspecting State: Examining memory, registers, stack, and other program data.

To load a program with GDB, you typically specify the executable on the command line. Let's compile a tiny C program first:

After compiling the C code (e.g., gcc -o hello hello.c), you can load it into GDB. Then, use the run command to start its execution.

GDB Commands:
gdb ./hello
(gdb) run

This will execute the program, and GDB will show you its output and then return to the GDB prompt.

Sometimes, a program is already running, and you need to debug it on the fly. This is where attaching comes in. You'll need the program's Process ID (PID).

First, get the PID (e.g., using ps aux | grep on Linux). Then, use GDB with the -p flag:

Run the previous C program in a terminal. Note its PID. Then, in another terminal, you can attach GDB to it:

GDB Command:
gdb -p <PID_OF_YOUR_PROGRAM>

Once attached, the program will pause. You can then use GDB commands to inspect its state, set breakpoints, and continue execution.

WinDbg offers similar functionalities for Windows. To load a binary, you can launch WinDbg and use File > Open Executable, or use the command line: windbg.exe -o myprogram.exe.

To attach to a running process, navigate to File > Attach to a Process. You'll then see a list of running processes by name and PID, allowing you to select the target.

You've learned about loading and attaching programs to debuggers. Which GDB command is used to start a program that has already been loaded into GDB?

Great job! You've grasped the fundamental ways to get a debugger connected to a program:

• Loading: Starting a new program directly under debugger control (e.g., gdb ./program then run).
• Attaching: Connecting to an already active program (e.g., gdb -p <PID>).

These techniques are your entry points into dynamic analysis, allowing you to observe and manipulate programs in real-time. Next, we'll explore how to pause execution and step through code!