Deepaudit/cpp-offensive-security-lab

# 🛡️ C++ 攻防安全实验室：内存与逻辑破坏 本仓库是为渗透测试人员和安全研究人员提供的实用指南，旨在帮助他们理解 C++ 中内存级漏洞的原理。 ## 🏗️ 漏洞结构 以下是最小化的源代码，用于演示关键的安全漏洞。 ### 1. 缓冲区溢出 (基于栈) 当数据超过已分配缓冲区的大小时发生，会覆盖栈上的返回地址。 * **文件：** `01_stack_overflow.cpp` * **风险：** 远程代码执行 (RCE)。 ### 2. 格式化字符串漏洞 当用户输入直接传递给 `printf` 等格式化函数时发生。 * **文件：** `02_format_string.cpp` * **风险：** 内存泄露 (信息泄露) 或写入任意地址。 ### 3. 整数溢出 当算术运算超过整数类型的最大值时发生，导致安全检查出现意外行为。 * **文件：** `03_integer_overflow.cpp` ### 4. 释放后使用 (UAF) 尝试在内存被释放后访问指针，这可能导致程序控制流被劫持。 * **文件：** `04_use_after_free.cpp` ## 🛠️ 示例代码 (PoCs) #### `01_stack_overflow.cpp` ``` #include #include void vuln_function(char* str) { char buffer[16]; // PERIGO: strcpy não verifica o tamanho do input strcpy(buffer, str); std::cout << "Buffer content: " << buffer << std::endl; } int main(int argc, char** argv) { if (argc > 1) vuln_function(argv[1]); return 0; } 02_format_string.cpp #include int main(int argc, char** argv) { if (argc > 1) { // PERIGO: O input do usuário é usado como string de formato printf(argv[1]); } return 0; } 03_integer_overflow.cpp #include void check_access(unsigned short items) { // Se items for 65535 e somarmos 1, ele vira 0 (Overflow) if (items + 1 < 10) { std::cout << "Acesso concedido! Admin Mode." << std::endl; } } int main() { check_access(65535); return 0; } 🔍 Guia de Compilação para Testes Para estudar essas falhas sem as proteções modernas do compilador (GCC), use: Bash g++ -fno-stack-protector -z execstack -no-pie 01_stack_overflow.cpp -o buffer_lab Desenvolvido por Deep Audit - Pesquisa em Segurança Ofensiva. ---------------------------------------------------------------------------------- 1. Stack-Based Buffer Overflow O que é: Ocorre quando um programa escreve mais dados em um buffer (array) na pilha (stack) do que ele pode suportar. A Causa Raiz: O uso de funções inseguras da biblioteca C, como strcpy, gets ou scanf, que não verificam o tamanho do destino. O Impacto: O atacante sobrescreve o Endereço de Retorno (EIP/RIP) da função. Quando a função termina, em vez de voltar para o fluxo normal, o processador pula para um endereço controlado pelo atacante (onde pode haver um shellcode). No seu código: O buffer[16] recebe qualquer tamanho de string via argv[1], permitindo o transbordamento. 2. Format String Vulnerability O que é: Uma falha que ocorre quando o input do usuário é passado como o primeiro argumento de funções da família printf(), sprintf() ou fprintf(). A Causa Raiz: O programador confia que o usuário enviará apenas texto, mas o atacante envia "especificadores de formato" como %x (para ler a pilha) ou %n (para escrever na memória). O Impacto: Vazamento de dados sensíveis da memória (como chaves de criptografia ou endereços de funções) e, em casos avançados, execução de código. No seu código: printf(argv[1]) permite que eu digite %p %p %p %p para ver os endereços reais da sua memória. 3. Integer Overflow O que é: Ocorre quando uma operação aritmética resulta em um valor que excede o limite máximo (ou mínimo) do tipo da variável. A Causa Raiz: Tipos de dados têm tamanhos fixos. Por exemplo, um unsigned short só vai até 65.535. Se você somar 1 a ele, ele "reseta" para 0. O Impacto: Bypass de verificações de segurança. Se um sistema checa se você tem dinheiro suficiente somando taxas, um overflow pode fazer o valor final parecer muito pequeno ou zero, enganando a lógica. No seu código: items + 1 < 10 torna-se verdadeiro se items for 65535, pois o resultado matemático é 0. 4. Use-After-Free (UAF) O que é: Um tipo de corrupção de memória onde uma aplicação continua a usar um ponteiro após a memória ter sido liberada com free ou delete. A Causa Raiz: Falta de gerenciamento de ponteiros "pendentes" (dangling pointers). A memória é liberada, mas o endereço continua gravado na variável. O Impacto: Se um atacante conseguir alocar um novo objeto no mesmo endereço de memória que foi liberado, ele pode controlar os valores que a função original vai ler, levando ao sequestro do fluxo de execução. No seu código: O objeto user é deletado, mas a verificação if (user->is_admin) continua acessando aquele espaço de memória que agora pode pertencer a outro processo. 5. Heap Overflow O que é: Similar ao Stack Overflow, mas ocorre no Heap, a área de memória usada para alocações dinâmicas (via new ou malloc). A Causa Raiz: Manipulação incorreta de memória dinâmica, geralmente ao copiar dados para buffers alocados em tempo de execução. O Impacto: Sobrescrita de metadados do Heap (que o sistema usa para gerenciar a memória) ou de objetos vizinhos. É mais complexo de explorar que o Stack Overflow, mas é a base de ataques contra navegadores e kernels. No seu código: O strcpy(buffer, argv[1]) invade o espaço do ponteiro metadata, que foi alocado logo em seguida no Heap. 6. Null Pointer Dereference O que é: Ocorre quando o programa tenta acessar um endereço de memória através de um ponteiro que é NULL (ou zero). A Causa Raiz: Falta de validação de retornos de funções ou falta de inicialização. Se uma alocação de memória falha e o programa não checa, ele recebe um ponteiro nulo. O Impacto: Geralmente causa o fechamento imediato da aplicação (Crash), resultando em Negação de Serviço (DoS). Em contextos de Kernel, pode ser usado para escalação de privilégios. No seu código: A função process_data tenta ler o valor de *ptr quando ele vale nullptr, o que faz o Sistema Operacional matar o processo para proteger a memória. 🛡️ Resumo de Proteções Modernas Para o seu conhecimento (e para explicar aos alunos), os compiladores modernos usam: ASLR: Randomiza os endereços de memória. Stack Canaries: Pequenos valores inseridos antes do endereço de retorno para detectar transbordamentos. DEP/NX: Marca a pilha como "Não Executável", impedindo que shellcodes rodem nela. ```

标签：C++, PoC, RCE, UAF, Web报告查看器, 二进制安全, 云资产清单, 信息泄露, 内存安全, 内存破坏, 安全测试, 攻击性安全, 数据擦除, 整数溢出, 暴力破解, 栈溢出, 格式化字符串, 概念验证, 漏洞利用开发, 漏洞复现, 缓冲区溢出, 编程安全, 网络安全, 软件漏洞, 逆向工程, 释放后使用, 隐私保护