Writeups de CTF

Olá, sou o Sean e gosto de resolver problemas de CTF no meu tempo livre. A minha posição atual envolve muita exploração binária e engenharia reversa de software, por isso costumo focar nessas categorias. A maioria dos writeups que vejo online são uma porcaria e espero que estes façam um trabalho melhor ao explicar alguns dos conceitos fundamentais.

Em todas as minhas soluções, faço o meu melhor para incluir uma solução reproduzível escrita com pwntools. Não se trata das flags, mas da jornada que nos levou até à flag.

Espero que isto não envelheça mal, mas também tentei fazer alguns vídeos a explicar alguns desses problemas de CTF. Podes vê-los no YouTube.

A seguir está uma lista de tópicos comuns de acesso ao Unix e os desafios de CTF relacionados.

Conhecimento de Acesso ao Unix

Classes de Vulnerabilidade

Demonstrar a capacidade de explorar classes de vulnerabilidade

• Escrever shellcode funcional a partir do zero e mostrar todos os passos para escrever o shellcode:
  • level-0, level-1
• Buffer overflow na stack com e sem as seguintes mitigações: randomização do layout do espaço de endereçamento (ASLR), memória Não-Executável (NX) e canários de stack:
  • clutter-overflow
  • heres-a-libc
  • stack-cache
  • hidden-flag-function
  • hidden-flag-function-parameters
• Buffer overflow na heap usando heap grooming e objetos com ponteiros para funções:
  • are-you-root
• Buffer overflow na heap ao corromper estruturas de dados da heap:
  • unsubscriptions-are-free
• UAF com objetos que contêm ponteiros para funções:
  • are-you-root
• UAF com objetos que permitem uma primitiva arbitrária de leitura/escrita:
  • cache-me-outside
• Vulnerabilidades de confusão de tipos de dados
• Vulnerabilidades de format string para primitiva arbitrária de leitura/escrita:
  • stonks
  • got_hax
  • flag-leak
• Como variáveis não inicializadas podem ser usadas para exploração:
  • are-you-root
  • stack-cache

Demonstrar a capacidade de implementar primitivas de exploração

• Primitiva de escrita arbitrária:
  • got_hax
• Primitiva de escrita relativa:
  • cache-me-outside
• Primitiva de leitura arbitrária:
  • got_hax
• Como primitivas podem ser encadeadas para construir um exploit
• Como uma primitiva de escrita pode ser usada para escalar privilégios/executar código arbitrário:
  • got_hax

Descrever o propósito e a estrutura das seguintes estruturas de ligação ELF e como podem ser abusadas na exploração binária

• Procedural Linkage Table:
  • got_hax
• Global Offset Table:
  • got_hax

Descrever os seguintes modos de relocação dinâmica em termos da interação entre as estruturas de dados PLT/GOT e como as primitivas de exploração diferem entre eles

• Partial RELRO:
  • got_hax
• Full RELRO:
  • got_hax

Demonstrar a capacidade de implementar ROP/JOP para

• Encontrar gadgets ROP/JOP:
  • guessing-game-1
• Chamar funções da libc e chamadas de sistema:
  • heres-a-libc
  • guessing-game-1
• Encadear gadgets para executar código:
  • guessing-game-1
• Executar shellcode arbitrário

Descrever o propósito e a implementação de mitigações de exploração

• ASLR
• Data Execution Prevention (DEP)/NX:
  • heres-a-libc
  • guessing-game-1
• Position Independent Executables (PIEs)
• Como os PIEs afetam a exploração
• Canários de stack:
  • guessing-game-1
• Safe list unlinking

Engenharia Reversa de Software

Comparar e contrastar técnicas e casos de uso de

• Engenharia reversa estática:
  • baby-c
  • wizardlike
• Engenharia reversa dinâmica:
  • heres-a-libc
  • wizardlike

Demonstrar familiaridade no uso dos seguintes tipos de ferramentas para realizar engenharia reversa estática e dinâmica

• Desassembladores estáticos
  • baby-c
  • wizardlike
• Depuradores
  • wizardlike
• Técnicas de automação usando as ferramentas acima

Técnicas de fuzzing

• Técnicas de fuzzing cego
• Fuzzing baseado em cobertura de código
• Execução simbólica
  • sum-o-primes

Posts de Blog de CTF que Considero Úteis

• Executable Stacks