2025年CTF竞赛逆向工程中难度真实题目解析

目录
├── 第一章：高级静态分析技巧
├── 第二章：复杂算法识别与破解
├── 第三章：中级反调试与反逆向绕过
├── 第四章：跨平台程序分析
├── 第五章：复杂数据结构分析
├── 第六章：系统调用与API分析
└── 第七章：逆向工程进阶学习建议

// 假设IDA Pro反编译后的伪代码
int main() {
    int a = 123;
    int b = 456;
    int result = func1(a, b);
    
    if (result == 0x1234) {
        printf("flag{Multi_Level_Function_Call_Analysis}\n");
    }
    
    return 0;
}

// 假设IDA Pro反编译后的伪代码
int func1(int x, int y) {
    int z = x + y;
    return func2(z);
}

// 假设IDA Pro反编译后的伪代码
int func2(int x) {
    int y = x * 2;
    return func3(y);
}

// 假设IDA Pro反编译后的伪代码
int func3(int x) {
    int y = x ^ 0x55;
    return y;
}

int func2(int x) {
    int y = (x << 1) | (x >> 31);  // 带符号的左移，保留符号位
    return func3(y);
}

// 假设IDA Pro反编译后的伪代码
int verify_password(char *input) {
    int len = strlen(input);
    
    if (len != 8) {
        return 0;
    }
    
    if (input[0] != 'a') {
        return 0;
    }
    
    if (input[1] != 'b') {
        return 0;
    }
    
    // 更多的验证条件...
    
    if (input[7] != 'z') {
        return 0;
    }
    
    return 1;
}

int main() {
    char password[32];
    
    printf("请输入密码：");
    scanf("%s", password);
    
    if (verify_password(password)) {
        printf("密码正确！\n");
        printf("flag{Symbolic_Execution_Master}\n");
    } else {
        printf("密码错误！\n");
    }
    
    return 0;
}

import angr

# 创建一个angr项目
p = angr.Project('./symbolic_execution')

# 创建一个初始状态，设置输入为符号变量
state = p.factory.entry_state()

# 创建一个符号执行模拟器
simgr = p.factory.simgr(state)

# 定义我们想要达到的目标地址（即输出flag的代码地址）
# 假设这个地址是0x401234
TARGET_ADDR = 0x401234

# 定义我们想要避开的地址（即输出"密码错误"的代码地址）
# 假设这个地址是0x401245
AVOID_ADDR = 0x401245

# 运行符号执行，寻找能够到达目标地址的路径
simgr.explore(find=TARGET_ADDR, avoid=AVOID_ADDR)

# 检查是否找到了可行的路径
if simgr.found:
    # 获取第一个可行路径的状态
    found_state = simgr.found[0]
    # 获取输入的符号变量的值
    password = found_state.posix.dumps(0).decode('utf-8').strip()
    print(f"找到正确的密码：{password}")
else:
    print("没有找到可行的路径")

./symbolic_execution
请输入密码：abcdefgz
密码正确！
flag{Symbolic_Execution_Master}

// 假设IDA Pro反编译后的伪代码
// 自定义加密函数
void custom_encrypt(char *input, char *output, int key) {
    int len = strlen(input);
    int i;
    
    for (i = 0; i < len; i++) {
        // 自定义的加密逻辑
        output[i] = ((input[i] ^ (key >> 8)) + (key & 0xFF)) % 256;
        // 更新key
        key = (key * 1103515245 + 12345) & 0xFFFFFFFF;
    }
    
    output[i] = '\0';
}

// main函数
int main() {
    char plaintext[] = "flag{Custom_Encryption_Algorithm_Cracked}";
    char encrypted[128];
    int key = 0x12345678;
    
    custom_encrypt(plaintext, encrypted, key);
    
    printf("加密后的数据：");
    for (int i = 0; encrypted[i] != '\0'; i++) {
        printf("%02x ", (unsigned char)encrypted[i]);
    }
    printf("\n");
    
    return 0;
}

# 加密后的数据（十六进制）
encrypted_hex = "..."  # 从程序输出中复制
# 转换为字节列表
encrypted_bytes = bytes.fromhex(encrypted_hex.replace(" ", ""))
# 初始key
key = 0x12345678
# 解密
plaintext = []

for b in encrypted_bytes:
    # 计算原始字符
    # 公式：plain = (encrypted - (key & 0xFF)) ^ (key >> 8)
    plain_char = (b - (key & 0xFF)) ^ (key >> 8)
    # 确保结果在0-255范围内
    plain_char &= 0xFF
    # 添加到明文列表
    plaintext.append(chr(plain_char))
    # 更新key（与加密过程相同）
    key = (key * 1103515245 + 12345) & 0xFFFFFFFF

# 组合明文
plaintext_str = "".join(plaintext)
print(f"解密后的明文：{plaintext_str}")

// 假设IDA Pro反编译后的伪代码（混淆版本）
void obfuscated_encrypt(char *input, char *output, int key) {
    int len = strlen(input);
    int i, j, k;
    int temp1, temp2, temp3;
    
    for (i = 0; i < len; i++) {
        // 混淆代码：复杂的计算和控制流
        temp1 = input[i];
        
        if (key > 1000) {
            temp2 = temp1 * 2;
        } else if (key > 500) {
            temp2 = temp1 * 3;
        } else {
            temp2 = temp1 * 4;
        }
        
        // 更多的混淆代码
        for (j = 0; j < 10; j++) {
            temp3 = temp2 ^ j;
        }
        
        // 真实的加密逻辑，隐藏在混淆代码中
        output[i] = temp1 ^ key;
        
        // 更多的混淆代码
        key = (key + 1) % 256;
    }
    
    output[i] = '\0';
}

// main函数
int main() {
    char plaintext[] = "flag{Obfuscated_Algorithm_Identified}";
    char encrypted[128];
    int key = 0x55;
    
    obfuscated_encrypt(plaintext, encrypted, key);
    
    printf("加密后的数据：");
    for (int i = 0; encrypted[i] != '\0'; i++) {
        printf("%02x ", (unsigned char)encrypted[i]);
    }
    printf("\n");
    
    return 0;
}

# 加密后的数据（十六进制）
encrypted_hex = "..."  # 从程序输出中复制
# 转换为字节列表
encrypted_bytes = bytes.fromhex(encrypted_hex.replace(" ", ""))
# 初始key
key = 0x55
# 解密
plaintext = []

for b in encrypted_bytes:
    # 解密（XOR操作）
    plain_char = b ^ key
    # 添加到明文列表
    plaintext.append(chr(plain_char))
    # 更新key（与加密过程相同）
    key = (key + 1) % 256

# 组合明文
plaintext_str = "".join(plaintext)
print(f"解密后的明文：{plaintext_str}")

gdb ./multi_anti_debug
run

// 假设IDA Pro反编译后的伪代码
// 使用ptrace检测调试器
int check_ptrace() {
    if (ptrace(PTRACE_TRACEME, 0, 1, 0) == -1) {
        return 1;  // 检测到调试器
    }
    return 0;
}

// 检测进程状态（通过读取/proc/self/status文件）
int check_proc_status() {
    FILE *fp = fopen("/proc/self/status", "r");
    if (fp) {
        char buffer[1024];
        while (fgets(buffer, sizeof(buffer), fp)) {
            if (strstr(buffer, "TracerPid:") && atoi(buffer + 10) != 0) {
                fclose(fp);
                return 1;  // 检测到调试器
            }
        }
        fclose(fp);
    }
    return 0;
}

// 检测执行时间（调试时执行速度会变慢）
int check_execution_time() {
    clock_t start = clock();
    // 执行一些计算密集型操作
    for (int i = 0; i < 1000000; i++) {
        volatile int j = i * i;
    }
    clock_t end = clock();
    double elapsed = (double)(end - start) / CLOCKS_PER_SEC;
    if (elapsed > 0.1) {  // 如果执行时间超过阈值，认为被调试
        return 1;
    }
    return 0;
}

// main函数
int main() {
    if (check_ptrace() || check_proc_status() || check_execution_time()) {
        printf("检测到调试器！程序退出。\n");
        return 1;
    }
    
    printf("欢迎使用！\n");
    printf("flag{Multi_Anti_Debug_Bypassed}\n");
    
    return 0;
}

gdb ./multi_anti_debug
# 禁用地址随机化（可选）
set disable-randomization on
# 设置断点在main函数
b main
# 运行程序
run
# 当程序停在main函数处时，找到三个反调试检测函数的调用地址
# 假设它们分别是0x401000、0x401100、0x401200
# 在每个反调试检测函数的返回处设置断点
b *0x401000+0x50  # 假设这是check_ptrace函数返回后的地址
b *0x401100+0x80  # 假设这是check_proc_status函数返回后的地址
b *0x401200+0x60  # 假设这是check_execution_time函数返回后的地址
# 继续执行程序
continue
# 当程序停在第一个断点处时，修改返回值为0（未检测到调试器）
set $eax = 0
continue
# 当程序停在第二个断点处时，修改返回值为0
set $eax = 0
continue
# 当程序停在第三个断点处时，修改返回值为0
set $eax = 0
continue

// 假设IDA Pro反编译后的伪代码（初始状态）
void self_modify() {
    // 获取当前函数的地址
    unsigned char *code = (unsigned char*)self_modify;
    
    // 修改代码的某些字节
    code[0x10] = 0x90;  // NOP指令
    code[0x11] = 0x90;
    code[0x12] = 0x90;
    code[0x13] = 0x90;
}

int main() {
    printf("程序开始执行...\n");
    
    // 调用自修改函数
    self_modify();
    
    // 这里的代码可能已经被修改
    int x = 1;
    int y = 2;
    int z = x + y;
    
    // 输出flag
    printf("flag{Self_Modifying_Code_Analyzed}\n");
    
    return 0;
}

gdb ./self_modifying
# 设置断点在self_modify函数
b self_modify
# 运行程序
run
# 当程序停在self_modify函数处时，查看函数的初始反汇编代码
disassemble self_modify
# 继续执行，直到代码被修改后
break *self_modify+0x20  # 假设这是代码修改后的地址
continue
# 再次查看函数的反汇编代码，观察变化
disassemble self_modify

// 假设IDA Pro反编译后的伪代码
#include <windows.h>

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
    // 隐藏窗口
    HWND hwnd = FindWindowA(NULL, "Hidden Window");
    if (hwnd) {
        ShowWindow(hwnd, SW_HIDE);
    }
    
    // 检查是否运行在Windows平台上
    OSVERSIONINFO osvi;
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    if (!GetVersionEx(&osvi)) {
        return 1;
    }
    
    // 读取资源中的flag
    HRSRC hRes = FindResourceA(NULL, MAKEINTRESOURCEA(101), RT_RCDATA);
    if (!hRes) {
        return 1;
    }
    
    HGLOBAL hResData = LoadResource(NULL, hRes);
    if (!hResData) {
        return 1;
    }
    
    LPVOID lpResData = LockResource(hResData);
    DWORD dwResSize = SizeofResource(NULL, hRes);
    
    // 输出flag
    char flag[128];
    memcpy(flag, lpResData, dwResSize);
    flag[dwResSize] = '\0';
    
    // 创建一个隐藏的对话框来显示flag
    MessageBoxA(NULL, flag, "Flag", MB_OK);
    
    return 0;
}

// 假设IDA Pro反编译后的伪代码
#include <stdio.h>
#include <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 检查是否运行在MacOS平台上
        NSString *osVersion = [[NSProcessInfo processInfo] operatingSystemVersionString];
        if (![osVersion containsString:@"Mac OS X"]) {
            printf("This program only runs on MacOS.\n");
            return 1;
        }
        
        // 从plist文件中读取flag
        NSString *plistPath = [[NSBundle mainBundle] pathForResource:@"Secret" ofType:@"plist"];
        NSDictionary *plistDict = [NSDictionary dictionaryWithContentsOfFile:plistPath];
        NSString *flag = [plistDict objectForKey:@"Flag"];
        
        // 输出flag
        printf("%s\n", [flag UTF8String]);
    }
    return 0;
}

// 假设IDA Pro反编译后的伪代码
// 链表节点结构
typedef struct Node {
    char data;          // 存储一个字符
    struct Node *next;  // 指向下一个节点的指针
} Node;

// 创建链表
Node* create_linked_list(const char *str) {
    Node *head = NULL;
    Node *tail = NULL;
    
    while (*str) {
        Node *new_node = (Node*)malloc(sizeof(Node));
        new_node->data = *str;
        new_node->next = NULL;
        
        if (!head) {
            head = new_node;
            tail = new_node;
        } else {
            tail->next = new_node;
            tail = new_node;
        }
        
        str++;
    }
    
    return head;
}

// 遍历链表
void traverse_linked_list(Node *head) {
    Node *current = head;
    
    while (current) {
        printf("%c", current->data);
        current = current->next;
    }
    
    printf("\n");
}

// main函数
int main() {
    // 创建包含flag的链表
    Node *flag_list = create_linked_list("flag{Linked_List_Structure_Analysis}");
    
    // 这里可能有一些操作来隐藏链表或混淆逻辑
    // ...
    
    // 遍历链表并输出flag
    traverse_linked_list(flag_list);
    
    // 释放链表内存
    Node *current = flag_list;
    while (current) {
        Node *next = current->next;
        free(current);
        current = next;
    }
    
    return 0;
}

gdb ./linked_list
# 设置断点在traverse_linked_list函数
b traverse_linked_list
# 运行程序
run
# 当程序停在traverse_linked_list函数处时，分析链表的内容
# 查看传入的链表头指针
print head
# 查看第一个节点的数据
print head->data
# 查看第一个节点的next指针
print head->next
# 继续查看下一个节点的数据
print head->next->data
# 以此类推，直到遍历完整个链表

// 假设IDA Pro反编译后的伪代码
// 加密数据结构
typedef struct EncryptedData {
    int size;       // 数据大小
    char *data;     // 加密后的数据
    int key;        // 加密密钥
} EncryptedData;

// 加密数据
EncryptedData* encrypt_data(const char *plaintext, int key) {
    EncryptedData *encrypted = (EncryptedData*)malloc(sizeof(EncryptedData));
    encrypted->size = strlen(plaintext);
    encrypted->data = (char*)malloc(encrypted->size + 1);
    encrypted->key = key;
    
    // 加密逻辑
    for (int i = 0; i < encrypted->size; i++) {
        encrypted->data[i] = plaintext[i] ^ (key >> (i % 8));
    }
    encrypted->data[encrypted->size] = '\0';
    
    return encrypted;
}

// 解密数据
void decrypt_data(EncryptedData *encrypted, char *output) {
    // 解密逻辑（与加密逻辑相同，因为XOR操作是可逆的）
    for (int i = 0; i < encrypted->size; i++) {
        output[i] = encrypted->data[i] ^ (encrypted->key >> (i % 8));
    }
    output[encrypted->size] = '\0';
}

// main函数
int main() {
    // 加密flag
    EncryptedData *encrypted_flag = encrypt_data("flag{Encrypted_Data_Structure}", 0x12345678);
    
    // 这里可能有一些操作来隐藏数据结构或混淆逻辑
    // ...
    
    // 解密并输出flag
    char decrypted_flag[128];
    decrypt_data(encrypted_flag, decrypted_flag);
    printf("%s\n", decrypted_flag);
    
    // 释放内存
    free(encrypted_flag->data);
    free(encrypted_flag);
    
    return 0;
}

gdb ./encrypted_structure
# 设置断点在decrypt_data函数
b decrypt_data
# 运行程序
run
# 当程序停在decrypt_data函数处时，分析参数和局部变量
# 查看encrypted参数
print *encrypted
# 查看加密后的数据
x/s encrypted->data
# 查看密钥
print encrypted->key
# 单步执行解密过程，观察数据的变化
stepi

# 假设从程序中提取的加密数据和密钥
encrypted_data = b'...'  # 从程序中提取的加密数据
key = 0x12345678        # 从程序中提取的密钥
size = len(encrypted_data)

# 解密
plaintext = []
for i in range(size):
    # 解密逻辑：与加密逻辑相同
    plain_char = encrypted_data[i] ^ ((key >> (i % 8)) & 0xFF)
    plaintext.append(chr(plain_char))

# 组合明文
plaintext_str = "".join(plaintext)
print(f"解密后的明文：{plaintext_str}")

// 假设IDA Pro反编译后的伪代码
int main() {
    // 使用系统调用打开一个文件
    int fd = syscall(SYS_open, "/tmp/secret_flag.txt", O_RDONLY);
    if (fd == -1) {
        printf("无法打开文件！\n");
        return 1;
    }
    
    // 使用系统调用读取文件内容
    char buffer[128];
    ssize_t bytes_read = syscall(SYS_read, fd, buffer, sizeof(buffer) - 1);
    if (bytes_read > 0) {
        buffer[bytes_read] = '\0';
    }
    
    // 使用系统调用关闭文件
    syscall(SYS_close, fd);
    
    // 这里可能有一些操作来隐藏或混淆flag
    // ...
    
    // 输出flag
    printf("%s\n", buffer);
    
    return 0;
}

strace ./syscall_challenge

read(3, "flag{Syscall_Analysis}", 127) = 21

// 假设IDA Pro反编译后的伪代码
#include <stdio.h>
#include <curl/curl.h>

// 回调函数，处理API响应
size_t write_callback(void *ptr, size_t size, size_t nmemb, void *userdata) {
    // 将响应数据复制到用户提供的缓冲区
    strncpy((char*)userdata, (char*)ptr, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL *curl;
    CURLcode res;
    char buffer[128] = {0};
    
    // 初始化curl
    curl = curl_easy_init();
    if (!curl) {
        printf("无法初始化curl！\n");
        return 1;
    }
    
    // 设置API URL
    curl_easy_setopt(curl, CURLOPT_URL, "http://example.com/api/flag");
    
    // 设置响应处理回调函数
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, buffer);
    
    // 发送API请求
    res = curl_easy_perform(curl);
    
    // 清理curl资源
    curl_easy_cleanup(curl);
    
    // 这里可能有一些操作来隐藏或混淆flag
    // ...
    
    // 输出flag
    printf("%s\n", buffer);
    
    return 0;
}

gdb ./api_call_challenge
# 设置断点在write_callback函数
b write_callback
# 运行程序
run
# 当程序停在write_callback函数处时，分析参数和局部变量
# 查看ptr参数（指向API响应数据）
x/s (char*)ptr