Caríssimos leitores, o presente tutorial é o primeiro sobre engenharia reversa no blog. É um exercício bastante simples e introdutório ao tema. Não serão abordados detalhes em demasia, visto ser um exercício de grau fácil.
O material usado no tutorial é uma aplicação programada na linguagem C. Esta aplicação consiste num ficheiro executável (EXE) que permite efetuar operações de soma (calculadora de somar). Apenas são permitidas operações com números inteiros iguais ou menores ao valor inteiro 4 na sua versão experimental (trial). Para efetuar cálculos com valores superiores a 4 é necessário ter a aplicação licenciada.

O objetivo será ultrapassar esta limitação através da análise do código assembly do executável. Convém lembrar, que o artigo sobre “Introdução ao Assembly” disponível no blog é imprescindível para este e os restantes tutoriais do tema. (O link no blog para o tutorial é o seguinte: http://infptavares.blogspot.pt/2013/12/introducao-ao-assembly.html .)

-Ferramentas de Trabalho

Aplicação (app.exe) : Esta é a aplicação de trabalho. Faça download da respetiva.

-Ollydbg : Esta ferramenta é um debbugger que será necessário para interpretar o executável e efetuar alterações no código assembly do mesmo. É uma ferramenta bastante completa de disassembling e debugging.

– O que é, e como se faz um crack?

Crackar um software ou uma aplicação não é mais do que modificar o código binário da aplicação para causar ou evitar procedimentos na sua execução. Isto é conseguido através de engenharia reversa do código do programa compilado, utilizando um debugger como o Ollydbg para atingir determinada função ou sub-rotina que possuí o método de proteção do código da aplicação. O binário é então modificado usando o debugger ou um editor hexadecimal, para substituição da ramificação do programa através do seu complemento ou através de um opcode NOP para saltar ou executar uma função ou sub-rotina especifica.

O código da aplicação que é pretendido crackar é o seguinte, compilado no DevC++.

Como é possível perceber este é o código que dá origem ao executável a analisar. Nos próximos tutoriais não haverá acesso ao código-fonte do executável, mas como é importante perceber como as instruções assembly se relacionam com as instruções de código, este é disponibilizado.
Fazendo uma prévia e rápida análise ao código, é possível visualizar que possuí uma instrução condicional (IF). Se as variáveis num1 e num2 forem maiores que o valor inteiro 4, a aplicação dispara um alerta “A versão trial apenas suporta números menores que 4.” e a execução da mesma é terminada. Caso contrário, a soma é consolidada e o resultado é apresentado na janela em execução. Em seguida, segue uma imagem ilustrando a sua execução via linha de comandos (cmd.exe).

Na imagem acima são apresentados os dois cenários possíveis:

1. Soma entre os valores (num1 e num2) menores que 4.
2. Se um dos valores (num1 ou num2) for maior que 4, um alerta é disparado e a execução é terminada.

O objetivo é ultrapassar o cenário 2 e conseguir efetuar somas entre quaisquer valores inteiros. É necessário saltar a condição / método de verificação, neste caso o IF de comparação das variáveis.

Passo 1: Carregar (load) o executável no Ollydbg.


Em seguida uma imagem que demonstra o processo.

Após abrir o ficheiro executável no debugger (é possível arrastá-lo) será necessário clicar no botão executar, como é assinalado na imagem acima. Confuso? Calma. Nos próximos tutoriais a coisa vai ficar pior! Não serão explicados todos os módulos deste debugger, pois eles serão explicados à medida que for necessário.

Passo 2: Procurar por Strings de referência.

Por norma, o primeiro teste que se deve fazer é a pesquisa por strings no código. Por vezes, o executável trás em anexo algumas pistas importantes e que ajuda em muito o engenheiro reverso. Normalmente, isto acontece em pequenas aplicações programadas na linguagem C, sem qualquer tipo de proteção ou ofuscação de código. Para se proceder com tal pesquisa, basta seguir o menu como mostra a seguinte imagem.
Para aceder ao seguinte menu é necessário clicar com o botão direito do rato sobre o código assembly e navegar até ao seguinte menu: Search for > All referenced text strings.
Uma janela foi aberta pelo debugger, esta contém informação sobre as strings ascii em anexo ao código. É possível perceber, que aparecem as strings referentes à mensagem disparada na aplicação.
Por norma, e é comum, esta janela conter imensas strings devido ao tamanho do executável e da aplicação, pois torna-se complicado encontrá-las a olho nu. A solução é:

1. Analisar a aplicação (executável) , isto é, corre-lo, e verificar se alguma string é lançada. Neste caso, a aplicação executada na linha de comandos lança a seguinte mensagem: “A versão trial apenas suporta números menores que 4“.

Este é o tipo de pesquisa que deve ser feito no debugger. Para tal, basta clicar com o botão direito do rato sobre a janela de strings de referência, aceder ao menu, clicar em Search For Text, e digitar palavras chave (key) na caixa de texto. Como é sabido, a string alvo contém a palavra “trial“.

Consequentemente, após o clique em OK, a string alvo será selecionada no debugger. De seguida, é necessário ir ao encontro do endereço onde esta string se encontra no assembly.

Deve ser seguido o fluxo ilustrado acima.

Por consequência as instruções relativas ao método que impede a execução da soma são apresentadas. Em seguida uma imagem que apresenta esses resultados.

Na imagem acima foram marcadas 3 regiões. Com o número 1 a primeira comparação, é feita a comparação através da instrução CMP (comparar) se o valor é maior que 4. Como visto no artigo sobre assembly, após uma instrução de CMP existe sempre um salto (JUMP). O jump é o seguinte. 

JG SHORT app.004012A4

Fazendo uma consulta à listagem apresentada no artigo de assembly é possível ver a especificação deste jump.

Um salto é realizado se AX > BX, neste caso, se a variável num1 > 4.

Voltando ao assembly, uma outra instrução no ponto 2 é apresentada, faz exatamente o mesmo, caso a variável num2 > 4 faz um salto. Este salto é efetuado para o offset 004012A4 que é o endereço correspondente à mensagem “A versão trial apenas suporta números menores que 4.“. 

Qual é a solução? Efetuar um NOP (ignorar) os 2 jumps. Isto é, a instrução JG SHORT app.004012A4 será ignorada no código assembly

Passo 3: NOP no JUMP

Como mostra a seguinte imagem, é necessário selecionar a instrução JG (o jump), clicar com o botão direito do rato, aceder a Binary e aplicar o NOP, (Fill with NOPs).

Após efetuar a alteração é possível verificar as seguintes modificações, como mostra a imagem abaixo.
Os jumps foram substituídos por instruções NOP’s, basicamente foram ignorados. Isto faz com que a aplicação nunca salte para o trecho de código onde é terminada a execução caso uma das variáveis num1 ou num2 fossem maiores que 4.

Passo 4: Gravar as mudanças e exportar o binário (crack).

Para gravar as alterações é necessário clicar com o botão direito do rato na janela e seguir até ao menu “Copy to executable > All modifications“, como mostra a imagem a seguir.

Por fim, uma outra janela será aberta. Esta contém todo o código do executável já alterado, restará gerar o ficheiro executável.

Para o devido efeito, como mostra a imagem, é necessário aceder ao menu Save File, e definir um nome original. e.g., crack.

Por fim, existem 3 ficheiros, o ficheiro de código-fonte, o ficheiro executável de teste e o ficheiro de teste crackado. Finalizando com a execução do programa, é possível comprovar que foi superada a verificação / licença da aplicação, pois já é possível efetuar operações de soma com números inteiros superior a 4.

Espero que não haja dúvidas. Até ao próximo tutorial.
Deixo os ficheiros para download. A password para descompactar o ficheiro é : [email protected]

Boa Continuação!


Próximo Tutorial:  [Tutorial 2] – Crackar um executável (IDA Pro)