Crackme para iniciantes: resolva o seu primeiro (2026)

O que é um crackme?

O que é um crackme? Um crackme é um pequeno programa escrito especialmente para passar por engenharia reversa como exercício. Ele costuma verificar uma senha, um número de série ou uma chave de licença, e o objetivo é entender essa verificação o suficiente para passar por ela. Como o autor o criou para ser quebrado, resolvê-lo é legal e não viola nenhuma licença.

A tradição vem de décadas. O antigo site comunitário crackmes.de hospedou milhares deles até sair do ar, e o seu sucessor espiritual, o crackmes.one, foi criado para que os iniciantes continuassem tendo um lugar para aprender. A maioria dos crackmes se encaixa em um destes três tipos:

• Crackme: encontrar a senha ou o flag escondido. O mais simples e o melhor ponto de partida.
• Keygenme: descobrir o algoritmo que transforma um nome em um número de série válido e depois escrever um pequeno programa (um keygen) que gera números de série para qualquer nome.
• Patchme: modificar o próprio binário para que ele aceite qualquer entrada. Só vale quando o autor permite.

Esse último ponto engana muitos iniciantes. Trocar um salto condicional para o programa sempre mostrar "Access granted" dá a sensação de vitória, mas as regras do crackmes.one consideram o patch uma solução inválida, a menos que o desafio seja explicitamente um patchme. O motivo é prático: um patch ensina onde está a verificação, enquanto um keygen prova que você entendeu o que ela faz.

Por que crackmes são a melhor porta de entrada para a engenharia reversa

Engenharia reversa é a categoria de CTF que os iniciantes evitam por mais tempo. Você recebe um arquivo compilado sem código-fonte e, na primeira vez que o abre em um disassembler, a parede de instruções parece impossível. Se ainda está conhecendo as categorias de CTF, nosso guia das seis categorias de CTF mostra onde o reversing fica ao lado de web, cripto e pwn.

Os crackmes resolvem esse problema da "parede impossível" de três formas:

• Eles são pequenos. Um crackme para iniciantes muitas vezes tem uma única função que importa. Você aprende a ignorar o código gerado pelo compilador e a focar na verificação.
• Eles são classificados por dificuldade. O crackmes.one dá a cada crackme uma nota de 1 (strings em texto puro, comparações simples) a 6 (máquinas virtuais próprias e ofuscação pesada), então você sobe um degrau de cada vez.
• Eles treinam direto os seus instintos de CTF. Um desafio típico de reversing em CTF é um crackme com um flag no final. O processo é o mesmo, só que com o relógio correndo.

Nossa opinião sincera: se você quer fazer exploração de binários algum dia, não dá para pular esta etapa. Todo buffer overflow começa com a leitura do programa que você vai quebrar.

Monte um ambiente seguro para crackmes

Os crackmes dos sites comunitários são revisados antes de serem publicados, mas continuam sendo executáveis escritos por desconhecidos. Rode-os em uma máquina virtual, nunca no notebook que guarda as suas senhas e fotos. Uma VM com Kali Linux ou Ubuntu é suficiente, e tirar um snapshot antes de cada sessão permite desfazer qualquer coisa estranha em segundos. Crackmes para Windows vão em uma VM Windows separada.

Você precisa de surpreendentemente poucas ferramentas para começar. Estas são as que instalaríamos no primeiro dia:

Qual disassembler escolher? Fique com o Ghidra. Ele é gratuito, open source, mantido pela NSA, e o seu descompilador transforma a maioria dos crackmes para iniciantes em pseudo-C legível. IDA Free e Binary Ninja são excelentes, mas não é preciso gastar dinheiro nem aprender uma segunda interface enquanto o básico ainda é novidade. Se quiser um tour guiado pela interface antes, o capítulo de Ghidra do curso de engenharia reversa da HackerDNA apresenta os painéis que você vai usar de verdade.

Como resolver um crackme: o método em 5 passos

Quase todo crackme para iniciantes cede à mesma rotina. Siga-a na ordem e só passe para o próximo passo quando o atual parar de dar respostas.

1. Execute. Digite uma resposta errada de propósito e anote cada mensagem. "Wrong password." é uma string que você pode procurar depois.
2. Identifique. Rode file para descobrir o formato (ELF no Linux, PE no Windows), a arquitetura (x86-64, ARM64) e se os símbolos foram removidos.
3. Leia as strings. Rode strings e procure as mensagens que você viu, além de qualquer coisa que pareça uma senha, uma string de formato ou um flag.
4. Encontre a verificação. Abra o binário no Ghidra ou com objdump, vá até o código que mostra a mensagem de sucesso e volte até a comparação que decide o resultado.
5. Confirme ao vivo e resolva do jeito certo. Coloque um breakpoint nessa comparação no GDB e observe os valores reais. Depois anote a resposta ou, em um keygenme, reescreva o algoritmo em Python.

O passo 4 é o que assusta, e é aí que o truque de "voltar a partir da mensagem de sucesso" faz toda a diferença. Você nunca precisa entender o programa inteiro. Precisa entender as vinte instruções que escolhem entre duas mensagens.

Exemplo prático: três crackmes de treino para você compilar

O crackme mais seguro é aquele que você mesmo compilou. Abaixo estão três programas curtos em C, cada um um pouco mais difícil que o anterior. Salve-os na sua VM, compile e depois tente esquecer o código-fonte e resolvê-los como se nunca o tivesse visto. Rodamos tudo no Ubuntu 24.04 com GCC 13.3, GNU objdump 2.42 e GDB 15.1 em x86-64, então os seus endereços podem variar um pouco em outra configuração.

// level1.c - the password is in plain sight
#include <stdio.h>
#include <string.h>
int main(void) {
    char input[64];
    printf("Password: ");
    if (!fgets(input, sizeof input, stdin)) return 1;
    input[strcspn(input, "\n")] = 0;
    if (strcmp(input, "s3cr3t_b4nana") == 0) puts("Access granted.");
    else puts("Wrong password.");
    return 0;
}

// level2.c - the password is XOR-encoded
#include <stdio.h>
#include <string.h>
static const unsigned char enc[] = {0x2e,0x70,0x34,0x1f,0x29,0x2e,0x1f,
    0x33,0x34,0x32,0x29,0x2e,0x27,0x33,0x00};
int main(void) {
    char input[64], key[16];
    printf("Password: ");
    if (!fgets(input, sizeof input, stdin)) return 1;
    input[strcspn(input, "\n")] = 0;
    for (int i = 0; enc[i]; i++) key[i] = enc[i] ^ 0x40;
    key[sizeof enc - 1] = 0;
    if (strcmp(input, key) == 0) puts("Access granted.");
    else puts("Wrong password.");
    return 0;
}

// level3.c - a keygenme: the serial depends on your name
#include <stdio.h>
#include <string.h>
int main(void) {
    char name[32], serial[32], want[32];
    unsigned int sum = 0;
    printf("Name: ");   if (!fgets(name, sizeof name, stdin)) return 1;
    printf("Serial: "); if (!fgets(serial, sizeof serial, stdin)) return 1;
    name[strcspn(name, "\n")] = 0; serial[strcspn(serial, "\n")] = 0;
    if (strlen(name) < 4) { puts("Name too short."); return 1; }
    for (size_t i = 0; i < strlen(name); i++) sum += (unsigned char)name[i] * (i + 1);
    snprintf(want, sizeof want, "KEY-%04X", (sum ^ 0x1337) & 0xFFFF);
    if (strcmp(serial, want) == 0) puts("Valid serial. Well done.");
    else puts("Invalid serial.");
    return 0;
}

gcc -O0 -o level1 level1.c
gcc -O0 -o level2 level2.c
gcc -O0 -o level3 level3.c

Nível 1: a senha à vista

Execute, erre e depois identifique:

$ ./level1
Password: test
Wrong password.
$ file level1
level1: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked,
interpreter /lib64/ld-linux-x86-64.so.2, ..., for GNU/Linux 3.2.0, not stripped

"Not stripped" significa que os nomes de funções como main continuam no arquivo, o que facilita os próximos passos. Agora as strings. A saída completa tem umas 90 linhas de nomes de bibliotecas e restos do compilador, mas veja o que aparece bem entre as duas mensagens que você já conhece:

$ strings level1
...
Password:
s3cr3t_b4nana
Access granted.
Wrong password.
...

E está resolvido. O compilador guarda as strings literais juntas em uma seção somente leitura, então uma senha fixa no código costuma cair bem ao lado das mensagens de sucesso e de falha. É exatamente isso que significa dificuldade 1 no crackmes.one, e você vai se surpreender com quantas vezes isso ainda funciona nos desafios de aquecimento de CTFs.

Nível 2: a senha escondida

Mesmas mensagens, mas desta vez o strings não mostra nada parecido com uma senha. Hora de encontrar a verificação. Desmonte a main com a sintaxe Intel, que é a usada na maioria dos tutoriais:

$ objdump -d -M intel --no-show-raw-insn level2 | awk '/<main>:/,/^$/'
    ...
    1263:  mov    eax,DWORD PTR [rbp-0x64]
    1266:  cdqe
    1268:  lea    rdx,[rip+0xd99]        # 2008 <enc>
    126f:  movzx  eax,BYTE PTR [rax+rdx*1]
    1273:  xor    eax,0x40
    1276:  mov    edx,eax
    ...
    1297:  jne    1263 <main+0x7a>
    ...
    12ab:  call   10f0 <strcmp@plt>
    12b0:  test   eax,eax
    12b2:  jne    12c5 <main+0xdc>

Leia de trás para frente. Em 12ab, o programa chama strcmp, e o salto logo depois escolhe a mensagem de sucesso ou de falha. Acima dele há um loop: carregar um byte de algo chamado enc, aplicar XOR com 0x40, guardar e repetir até um byte zero. Ou seja, a senha real é montada em tempo de execução a partir de bytes codificados.

Você poderia decodificar esses bytes à mão. É mais rápido deixar o programa trabalhar e ler o resultado no GDB. Colocar um breakpoint no símbolo strcmp em geral é uma armadilha aqui, porque o carregador dinâmico também o chama antes de a main rodar, então pare exatamente na chamada. 0x12ab - 0x11e9 (o início da main) dá 194:

$ echo AAAA > in.txt
$ gdb -q ./level2
(gdb) break *main+194
(gdb) run < in.txt
Breakpoint 1, 0x00005555555552ab in main ()
(gdb) x/s $rdi
0x7fffffffc400: "AAAA"
(gdb) x/s $rsi
0x7fffffffc3f0: "n0t_in_strings"

No Linux x86-64, os dois primeiros argumentos de uma função passam pelos registradores rdi e rsi. Um guarda a sua entrada, o outro guarda a senha decodificada. O autor até deu a dica no nome ("não está no strings").

Nível 3: o seu primeiro keygen

O nível 3 pede um nome e um número de série. Não existe uma única resposta certa, então um depurador sozinho só daria o número de série de um nome. O objetivo de um keygenme é reconstruir o algoritmo. O strings dá a primeira pista:

$ strings level3 | grep KEY
KEY-%04X

Isso é um formato no estilo printf: o número de série é "KEY-" seguido de quatro dígitos hexadecimais em maiúsculas. Agora o loop que calcula esses dígitos:

    132c:  lea    rdx,[rbp-0x70]
    1330:  mov    rax,QWORD PTR [rbp-0x78]
    1334:  add    rax,rdx
    1337:  movzx  eax,BYTE PTR [rax]       ; c = name[i]
    133a:  movzx  eax,al
    133d:  mov    rdx,QWORD PTR [rbp-0x78]
    1341:  add    rdx,0x1                  ; i + 1
    1345:  imul   eax,edx                  ; c * (i + 1)
    1348:  add    DWORD PTR [rbp-0x7c],eax ; sum += ...
    134b:  add    QWORD PTR [rbp-0x78],0x1 ; i++
    ...
    1362:  mov    eax,DWORD PTR [rbp-0x7c]
    1365:  xor    eax,0x1337               ; sum ^ 0x1337
    136a:  movzx  edx,ax                   ; keep the low 16 bits

Cada caractere é multiplicado pela sua posição (começando em 1), os produtos são somados, a soma passa por um XOR com 0x1337 e só os 16 bits menos significativos são mantidos. Reescreva isso em Python e você tem um keygen:

import sys

name = sys.argv[1]
total = sum(ord(c) * (i + 1) for i, c in enumerate(name))
print(f"KEY-{(total ^ 0x1337) & 0xFFFF:04X}")

$ python3 keygen.py dana
KEY-10C3
$ ./level3
Name: dana
Serial: KEY-10C3
Valid serial. Well done.

Na prática, é nesse momento que os crackmes fazem sentido para a maioria das pessoas. Você não chutou nada. Leu a lógica, reescreveu em uma linguagem que conhece e o programa concordou com você. O Ghidra teria mostrado o mesmo loop em pseudo-C, e é por isso que ele vira a sua ferramenta principal quando os programas passam de algumas dezenas de linhas. Abra o level3 nele e compare a visão do descompilador com o assembly acima.

Onde encontrar crackmes

crackmes.one

O crackmes.one é a principal biblioteca da comunidade e o lugar para ir depois dos seus próprios binários de treino. Quando verificamos em novembro de 2026, a página inicial mostrava 100.861 usuários, 4.834 crackmes e 6.846 writeups. Algumas coisas para saber antes do primeiro download:

• Todo download é um ZIP protegido por senha. A senha é sempre crackmes.one. O arquivo compactado evita que o executável seja aberto por acidente antes de chegar à sua VM.
• Use os filtros de busca. Dá para filtrar por dificuldade (de 1 a 6), nota de qualidade, linguagem, plataforma e número de writeups. Comece pelas dificuldades 1 e 2, Linux ou Windows de acordo com a sua VM, e com pelo menos um writeup para conferir o seu raciocínio depois.
• Alguns crackmes agora valem pontos. Crackmes com validação automática mostram um flag no formato CMO{...}. Enviá-lo registra a sua resolução e rende entre 100 e 600 pontos no ranking.
• Writeups são explicações, não respostas. Um writeup que só contém a senha é rejeitado. Escrever um para cada crackme resolvido é o melhor hábito de estudo que você pode criar, e ainda vira portfólio. O site pede writeups em inglês.

Arquivos de CTF e labs guiados

CTFs para iniciantes e plataformas de treino quase sempre têm uma categoria de reversing, e esses desafios são crackmes com um flag de CTF no final. O pwn.college vai além e ensina assembly e engenharia reversa do zero. Nosso guia do pwn.college para iniciantes explica quais dojos fazer primeiro.

Como livro gratuito para deixar aberto ao lado do Ghidra, o Reverse Engineering for Beginners, de Dennis Yurichev, continua sendo a recomendação padrão. Ele mostra o mesmo código C compilado por compiladores e processadores diferentes, exatamente a habilidade que um crackme treina.

Erros comuns de iniciantes

• Rodar crackmes na máquina principal. Revisado não quer dizer auditado. Use uma VM com snapshots e mantenha as pastas compartilhadas desligadas.
• Pular direto para a dificuldade 4. Um crackme cheio de truques antidepuração vai fazer você desistir. Resolva dez crackmes de dificuldade 1 e 2 antes de subir.
• Ler cada instrução. Comece pela string de sucesso e volte a partir dela. A maior parte de um binário é código de inicialização do compilador que você pode ignorar sem medo.
• Patchear em vez de entender. Trocar um jne por je funciona na sua cópia e ensina muito pouco. Mire na senha ou em um keygen.
• Abrir o writeup depois de cinco minutos. Defina um limite de tempo, cerca de uma hora para um crackme fácil, depois leia um writeup e reescreva a solução sozinho sem olhar.

Considerações legais e éticas

Crackmes são legais porque os autores os criaram para serem quebrados e os publicaram com esse propósito. As habilidades que você desenvolve são as mesmas que analistas de malware e pesquisadores de vulnerabilidades usam todos os dias. Isso não transforma qualquer binário em alvo liberado.

• O próprio crackmes.one proíbe trapaças de jogos, cracks de software comercial e malware real.
• Não publique o crackme ou o writeup de outra pessoa como se fosse seu.
• Respeite as regras de cada plataforma sobre a publicação de soluções, principalmente em CTFs ao vivo.

Perguntas frequentes