Reading Time: 5 minutes
Caros seguidores, o objetivo deste 3 tutorial de engenharia reversa é explicar como corrigir (crackar) um executável sem “espiar” o seu código-fonte. A palavra espiar tem algum significado quando aplicada a aplicações construídas sobre .NET, devido sobretudo, ao seu cariz. É possível usar um processo mais simplificado para alterar funções de um executável .NET, mas como neste blog é proposto fazer um review à área de engenharia reversa, esse será um assunto a estudar adiante.

Sumário 

Desta vez, o executável proposto é de origem desconhecida, não se sabe ao certo, em que plataforma foi desenvolvido (.NET), partindo do pressuposto que não era mencionado no artigo. 

Ferramentas de Trabalho

Para o seguinte tutorial existe a necessidade e dependência de duas ferramentas, e nomeadamente, conhecimento de Assembly. Caso procure saber mais sobre o assunto, o seguinte link poderá ser consultado no blog
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
CFF explorer: Esta ferramenta permite a edição de ficheiros PE (Portable Executable, do Inglês), e obter algumas informações relevantes do mesmo. 
(Poderá ser consultada informação referente às ferramentas de trabalho do tutorial na página Tools do blog.)

Correção de binários nativos (Patching Native Binaries)

Mesmo quando o código-fonte dos binários não é disponibilizado, é possível efetuar correções, por forma, a remover várias restrições de segurança impostas pelo fornecedor, bem como, corrigir erros inerentes ao código. 
Um tipo de proteção bastante familiar nos binários nativos é a proteção contra cópia, isto é, todo o utilizador que deseje obter um determinado software, terá antecipadamente de pagar uma licença de uso. Este tipo de licença obriga o utilizador a registar o produto antes de o usar. Por outro lado, o fornecedor estabeleceu previamente um tempo beta de uso, com limitações aplicacionais, de maneira, a cativar o utilizador a obter uma licença. 

Ficheiro Executável (Binário nativo)

Quando é feito o download de ficheiros da Internet, e estes apenas permitem o seu uso durante 30 dias, estamos perante uma versão experimental. Na maioria das vezes, este mecanismo de proteção envolve a verificação da data do sistema.
É neste ponto que entra a engenharia reversa, todos os esforços são mantidos para ultrapassar a licença de uso.

A seguinte imagem mostra a impossibilidade de executar o binário de teste.

Tanto o código-fonte do binário, como o ficheiro .exe, são disponibilizados para download no final do tutorial.
A motivação deste tutorial é sobre tudo, ultrapassar este tipo de proteção em binários nativos no modo GUI (Graphical User Interface).
À partida, quando este tipo de tarefas é realizada, não se tem qualquer tipo de referência sobre a linguagem de programação usada na construção da aplicação a analisar. De tal forma, é necessário descortinar esse primeiro desafio. Para tal, o uso do CFF Explorer é bastante importante, visto que exibe informações cruciais sobre a o binário, tal como, a linguagem ou plataforma de programação que deu à sua origem, Microsoft Visual C++ 8.

Na imagem acima é possível observar essa informação útil (File Info).

Como já mencionado acima, existe outras abordagens para corrigir o binário nativo, mas o objetivo deste tutorial incide no uso do OllyDbg.

Disassembling com o OllyDbg

Quando é desejado carregar o binário, este invoca uma mensagem a informar que o seu tempo de uso expirou. Provavelmente a data de autorização expirou. 
As sessões em seguida, visam esclarecer como corrigir o binário, por forma, a que esta restrição seja corrigida. 

Passos de correção:

  1.Carregar o programa, por forma a perceber o que está a acontecer. 

  2.Fazer debugging ao programa usando o OllyDbg.
  3. Perceber o funcionamento interno do programa (backward of program), isto é, andar para trás.
  4. Modificar o binário de forma a alterar a execução do bloco de código referente à proteção / licença     imposta.
  5 .Por fim, testar as modificações.
Os passos mencionados também podem ser realizados numa outra ferramenta de disassembling, como é o caso do tão poderoso IDA Pro. Uma das principais barreiras é não ser um software free, daí o uso do OllyDbg, que diga-se de passagem, é também uma ferramenta bastante poderosa. 
O primeiro passo a efetuar e como visto nos tutoriais anteriores, é carregar o ficheiro binário e descompilá-lo no OllyDbg.
Como é possível observar, a janela CPU – main thread mostra o código assembly do binário. A solução para corrigir o executável, visto que não existe acesso ao código-fonte, passa por encontrar a string: “A licença expirou”. Isto já foi visto num dos tutoriais anteriores, só que a diferença deste, passa por analisar as chamadas na pilha, pois essa mensagem, a determinado momento, será invocada lá. 
Após o loading do binário no OllyDgb, será necessário definir um break point.
A imagem a seguir demostra esse processo.
Clicando na janela “main thread” com o botão direito do rato, aceder ao menu “Search For / All intermodular calls”. Neste é possível aceder às chamadas na pilha.

Em seguida, procurar pelo destino “USER32.MessageBoxA”. Esta é a chamada de interesse, pois é invocada a msgbox da lib USER32 onde aparecerá o texto relativo à autorização (ou não) da licença de uso.
É necessário colocar um break point (F2), ele ficará assinalado com a cor vermelha
Em seguida, clicar em Run (F9) ou no botão Run, logo abaixo do menu Debug no OllyDbg. Automaticamente a execução será pausada, e vejam o que acontece em seguida.

A chamada à msgbox é feita no local assinalado acima.

Analisando com mais detalhe, o debugging parou na chamada da msgbox. Reparando nas instruções acima, e tendo em conta que os tutoriais anteriores já estão interiorizados, a instrução no offset 00C7141D é de extrema importância, pois ali é definido se é feito ou não o salto. 
Por norma, o tipo de correção habitual, passa por alterar a instrução “JE SHORT”, para que o programa não caía no bloco indesejado, neste caso, a proteção. Uma forma mais elegante de o fazer, é alterar a instrução que dá origem ao salto, nomeadamente a instrução no offset 00C71416 : MOV EAX,1.
Como o valor do EAX na instrução TEST EAX, EAX (comparação) será diferente de zero, então o salto não é consumado
É necessário alterar a instrução: MOV EAX,1 para MOV EAX,0. Desta forma o jump passará a ser válido e consumado.
Os passos para proceder a essa alteração são:
1. Selecionar a instrução MOV EAX , 1
2. Carregar na tecla espaço para que a janela à direita seja aberta. 
3. Alterar o valor para MOV EAX 0
O passo seguinte diz respeito a salvaguarda do binário com a devida correção, para que, no final possa ser testado. 
Após a alteração da instrução acima, a linha ficará seleciona, aproveitando isso, basta clicar no botão direito do rato e aceder ao menu “Copy to executable / Selection”.
Consequentemente, a seguinte janela será apresentada, esta corresponde ao código assembly do binário. Neste ponto, será necessário clicar no botão direito do rato e gravar o ficheiro. O nome dado foi “correcao.exe”.
Por fim, podem-se consultar as alterações de correção. Como se pode comprovar abaixo, estas estão corretas.
Foi referido neste tutorial, que esta forma de corrigir um binário nativo construído sobre .NET, não é a mais elegante, pois, existem outras técnicas e maneiras de o fazer. Esse assunto será abordado nos seguintes tutoriais com mais detalhes.
Código-Fonte do Tutorial
Por forma a melhorar o estudo deste tutorial, o código-fonte e os ficheiros executáveis são disponibilizados. Em seguida, é apresentado o código relativo ao binário.
  1. #include <Windows.h>
  2. int main()
  3. {
  4.         char fail[] = “A licenca expirou”;
  5.         char pass[] = “Cracked”;
  6.         char* text;
  7.         if(true)
  8.                 text = fail;
  9.         else
  10.                 text = pass;
  11.         MessageBoxA(NULL, text, text, MB_OK);
  12.         return 0;
  13. }
É um simples ficheiro com uma mensagem. Nada de muito complexo, mas em relação aos tutoriais anteriores, percebe-se que houve umas pequenas variantes. A espetacularidade da engenharia reversa é isto mesmo, cada problema é um novo desafio. 
Ficam os ficheiros para download.
. main.cpp
. Tuto3.exe
. correcao.exe
Passwordinfptavares.blogspot.pt
Boa continuação e até ao próximo tutorial.
Alguma dúvida,
[email protected]