046_逆向工程实战进阶：GDB动态调试技术全面详解与二进制程序分析实战指南

目录
├── 第一章：GDB调试器基础概述
├── 第二章：GDB基本命令详解
├── 第三章：断点设置与管理高级技巧
├── 第四章：程序状态检查与内存操作
├── 第五章：多线程与多进程调试
├── 第六章：逆向工程中的GDB高级应用
├── 第七章：GDB脚本自动化
└── 第八章：实战案例分析

GDB工作流程：
1. 启动目标程序（或附加到已运行程序）
2. 插入断点（通过修改内存为断点指令）
3. 程序执行直到断点触发
4. 保存程序状态（寄存器、内存等）
5. 允许用户检查和修改状态
6. 根据用户命令继续执行程序

# Debian/Ubuntu
apt-get install gdb

# RedHat/CentOS
yum install gdb

# Fedora
dnf install gdb

# 创建GDB配置文件
cat > ~/.gdbinit << 'EOF'
# 设置显示格式
set print pretty on
set print array on
set print elements 0

# 设置反汇编格式
set disassembly-flavor intel

# 彩色输出
syntax highlight
EOF

# 安装GEF (GDB Enhanced Features)
git clone https://github.com/hugsy/gef.git ~/.gef
echo "source ~/.gef/gef.py" >> ~/.gdbinit

# 或安装PEDA (Python Exploit Development Assistance for GDB)
git clone https://github.com/longld/peda.git ~/.peda
echo "source ~/.peda/peda.py" >> ~/.gdbinit

GDB调试基本流程：
编译程序 → 启动GDB → 设置断点 → 运行程序 → 检查状态 → 单步执行 → 分析结果

程序执行控制流：
start → 设置断点 → run → 断点触发 → step/next → continue → finish

断点类型层次：
普通断点 → 条件断点 → 硬件断点 → 临时断点 → 观察点

# 在第100行设置断点，当x等于10时触发
break file.c:100 if x == 10

# 在函数foo中设置断点，当y大于100时触发
break foo if y > 100

# 基于寄存器值设置条件断点
break *0x8048450 if $eax == 0x1234

条件断点评估流程：
断点命中 → 评估条件表达式 → 条件为真 → 暂停执行
                         ↓ 条件为假
                         继续执行

# 显示所有寄存器内容
info registers

# 显示特定寄存器
print $eax
print $pc

# 修改寄存器值
set $eax = 0x1234
set $eip = 0x8048500

# 检查内存内容，格式为：x/Nfu 地址
# N: 数量, f: 格式, u: 单位

# 以十六进制查看10个字节
x/10x 0x8048400

# 以字符形式查看20个字节
x/20c 0x8048400

# 以32位整数查看5个值
x/5dw 0x8048400

# 查看栈顶内容
x/20x $esp

# 查看当前指令位置
x/i $eip

# 设置内存值
set {char}0x8048400 = 0x41
set {int}0x8048400 = 1234
set {char[10]}0x8048400 = "hello"

# 使用填充模式修改内存
fill 0x8048400 0x8048500 0x90

# 修改栈上的值
set {int}($esp+4) = 0x1234

# 修改堆内存
set {char*}heap_ptr = "modified"

内存修改应用场景：
1. 绕过密码验证 - 修改比较结果
2. 解锁功能限制 - 修改标志位
3. 修复程序漏洞 - 临时修补代码
4. 模拟边界条件 - 触发特定代码路径
5. 测试输入验证 - 注入恶意数据

# 打印结构体
print struct_var

# 打印结构体成员
print struct_var.member

# 打印数组元素
print array[0]

# 打印指针指向的内容
print *ptr
print *(ptr+1)

# 打印字符串
print string_var
print (char*)buffer

# 显示所有线程
info threads

# 切换到指定线程
thread 2

# 在线程中设置断点
break function thread 2

# 仅在当前线程中单步执行
step thread

多线程调试流程：
启动程序 → 查看线程 → 切换线程 → 设置线程断点 → 检查线程状态 → 继续执行

# 检查线程锁信息
info threads
info thread 1

# 检查线程堆栈
thread apply all bt

# 在所有线程中设置断点
break function thread apply all

# 监控信号处理
info signals

# 允许调试子进程
set follow-fork-mode child

# 同时调试父子进程
set detach-on-fork off

# 查看进程列表
info inferiors

# 切换进程
inferior 2

# 附加到子进程
attach process_id

# 加载符号表
symbol-file /path/to/symbols

# 添加符号文件
add-symbol-file /path/to/library 0x8048000

# 解析内存中的符号
info symbol 0x8048450

# 查找函数地址
print &function_name

# 检查符号类型
whatis variable_name

# 设置LD_PRELOAD环境变量
set environment LD_PRELOAD=/path/to/library.so

# 显示加载的共享库
info shared

# 在共享库中设置断点
break library_func

# 延迟断点（等待库加载）
break -r "^library_func$"]

# 显示所有信号处理
info signals

# 设置信号处理行为
handle SIGSEGV stop print pass

# 在信号处理函数中设置断点
break signal_handler

# 发送信号给程序
signal SIGINT

# 设置反汇编格式
set disassembly-flavor intel

# 反汇编函数
disassemble main

# 反汇编指定地址范围
disassemble 0x8048400,0x8048500

# 反汇编当前指令及其后续指令
x/10i $eip

# 显示混合源码和汇编
disassemble /m main

# 使用gdb内置函数
call printf("Value: %d\n", variable)

# 临时修改指令为nop
set {char}0x8048450 = 0x90

# 插入条件检查
break *0x8048450 commands
  if $eax == 0
    continue
  end
end

# 创建调试脚本 debug.gdb
break main
commands
  print "Program started!"
  continue
end

break *0x8048450
commands
  print "Reached critical point!"
  print $eax
  continue
end

run

gdb -x debug.gdb ./program

# gdb_script.py
import gdb

# 定义自定义命令
class FindFunction(gdb.Command):
    def __init__(self):
        super(FindFunction, self).__init__("find_func", gdb.COMMAND_USER)
    
    def invoke(self, arg, from_tty):
        try:
            # 查找包含特定字符串的函数
            functions = gdb.execute("info functions", to_string=True)
            for line in functions.split('\n'):
                if arg in line:
                    print(line)
        except Exception as e:
            print(f"Error: {e}")

# 注册命令
FindFunction()

gdb -x gdb_script.py ./program
(gdb) find_func encryption

# auto_analyze.py
import gdb

class AutoAnalyze(gdb.Command):
    def __init__(self):
        super(AutoAnalyze, self).__init__("auto_analyze", gdb.COMMAND_USER)
    
    def invoke(self, arg, from_tty):
        # 1. 显示程序信息
        print("=== Program Information ===")
        gdb.execute("info files")
        
        # 2. 查找可能的加密函数
        print("\n=== Potential Crypto Functions ===")
        crypto_funcs = ["encrypt", "decrypt", "hash", "key", "xor"]
        for func in crypto_funcs:
            try:
                output = gdb.execute(f"info functions {func}", to_string=True)
                if output.strip():
                    print(f"\nFunctions containing '{func}':")
                    print(output)
            except:
                pass
        
        # 3. 检查符号表中的可疑函数
        print("\n=== Suspicious Functions ===")
        try:
            symbols = gdb.execute("info functions", to_string=True)
            for line in symbols.split('\n'):
                if any(s in line.lower() for s in ["secret", "hidden", "check"]):
                    print(line)
        except:
            pass

# 注册命令
AutoAnalyze()

# 安装GEF
git clone https://github.com/hugsy/gef.git ~/.gef
echo "source ~/.gef/gef.py" >> ~/.gdbinit

# 安装PEDA
git clone https://github.com/longld/peda.git ~/.peda
echo "source ~/.peda/peda.py" >> ~/.gdbinit

# 安装pwndbg
git clone https://github.com/pwndbg/pwndbg.git ~/.pwndbg
cd ~/.pwndbg
./setup.sh

// password_check.c
#include <stdio.h>
#include <string.h>

int check_password(char *input) {
    char password[] = "secret123";  // 硬编码密码
    return strcmp(input, password) == 0;
}

int main() {
    char input[50];
    printf("Enter password: ");
    gets(input);  // 注意：存在缓冲区溢出漏洞
    
    if (check_password(input)) {
        printf("Access granted!\n");
        // 这里可能有敏感操作
    } else {
        printf("Access denied!\n");
    }
    
    return 0;
}

gcc -g -o password_check password_check.c

# 启动GDB
gdb ./password_check

# 设置断点
(gdb) break check_password
(gdb) break main

# 运行程序
(gdb) run

# 在main函数中检查输入缓冲区
(gdb) break *main+20
(gdb) run
(gdb) print &input

# 单步执行到strcmp函数调用
(gdb) break *check_password+30
(gdb) continue
(gdb) disassemble

# 查看password变量的值
(gdb) x/s password

# 动态修改password变量绕过验证
(gdb) set {char[10]}password = "anything"
(gdb) continue

// obfuscated.c
#include <stdio.h>

int main() {
    int x = 123;
    int y = 456;
    
    // 混淆的控制流
    if ((x ^ 0x12) + (y >> 2) == 0x13A) {
        // 执行一些操作
        printf("Success!\n");
    } else {
        printf("Failed!\n");
    }
    
    return 0;
}

gcc -g -o obfuscated obfuscated.c
gdb ./obfuscated

# 设置断点并分析
(gdb) break main
(gdb) run
(gdb) print (x ^ 0x12) + (y >> 2)
(gdb) print 0x13A

# 跟踪表达式计算过程
(gdb) break *main+40
(gdb) continue
(gdb) print $eax  # 检查计算结果

// network_app.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 模拟网络协议处理函数
void process_packet(char *data, int len) {
    // 简单的协议验证
    if (len > 4 && data[0] == 0xAA && data[1] == 0xBB) {
        // 提取命令类型
        int cmd = data[2];
        // 提取数据长度
        int data_len = data[3];
        
        printf("Valid packet received!\n");
        printf("Command: 0x%02X\n", cmd);
        printf("Data length: %d\n", data_len);
        
        // 处理不同命令
        switch (cmd) {
            case 0x01:
                printf("Executing command 0x01...\n");
                break;
            case 0x02:
                printf("Executing command 0x02...\n");
                break;
            default:
                printf("Unknown command!\n");
        }
    } else {
        printf("Invalid packet!\n");
    }
}

int main() {
    // 模拟接收到的网络数据包
    char packet[] = {0xAA, 0xBB, 0x01, 0x05, 'H', 'e', 'l', 'l', 'o'};
    process_packet(packet, sizeof(packet));
    
    return 0;
}

gcc -g -o network_app network_app.c
gdb ./network_app

# 设置断点分析协议处理
(gdb) break process_packet
(gdb) run
(gdb) print len
(gdb) x/10x data
(gdb) print data[0] == 0xAA && data[1] == 0xBB

# 动态修改数据包内容进行测试
(gdb) set data[2] = 0x02
(gdb) continue

# 构造新的数据包进行测试
(gdb) set $new_packet = malloc(10)
(gdb) set {$new_packet+0} = 0xAA
(gdb) set {$new_packet+1} = 0xBB
(gdb) set {$new_packet+2} = 0x03
(gdb) call process_packet($new_packet, 10)

// malware_sample.c (仅用于教学目的)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 模拟恶意行为的函数
void malicious_function() {
    // 模拟加密或混淆的操作
    char key[] = "XORKEY";
    char data[] = "This is a secret message";
    int i;
    
    // XOR加密
    for (i = 0; i < strlen(data); i++) {
        data[i] ^= key[i % strlen(key)];
    }
    
    // 这里可能有其他恶意行为
    printf("Malicious operation performed!\n");
}

// 伪装成正常函数
int legitimate_function(int x) {
    // 调用恶意函数但隐藏调用关系
    if (x == 42) {
        malicious_function();
    }
    return x * 2;
}

int main() {
    printf("Legitimate program starting...\n");
    
    // 调用看似正常的函数
    legitimate_function(42);
    
    printf("Program completed.\n");
    return 0;
}

gcc -g -o malware_sample malware_sample.c
gdb ./malware_sample

# 分析调用关系
(gdb) break main
(gdb) break legitimate_function
(gdb) break malicious_function
(gdb) run
(gdb) backtrace

# 分析加密过程
(gdb) break *malicious_function+30
(gdb) continue
(gdb) print key
(gdb) print data
(gdb) continue
(gdb) print data

# 跟踪函数调用参数
(gdb) catch throw
(gdb) rwatch data[0]
(gdb) continue