Oficina
Rebelx crackme três (I-1)
|
Seg 21 Ago 2006 17:03 |
- Detalhes
- Categoria: Pilotando o rato I-1
- Atualização: Quarta, 15 Abril 2009 12:49
- Autor: vovó Vicki
- Acessos: 17683
O primeiro desafio do Pilotando o rato é dedicado aos iniciantes da ER, por isto mesmo vem cheio de dicas e com algumas sugestões de como resolvê-lo.
O programa
O crackme se encontra disponível para download na seção downloads > informática > crackme > crackme para iniciantes. Foi escrito em Delphi 7 para a plataforma Windows e publicado por Jules em Outubro de 2004. Apenas para diminuir o tamanho do programa, o autor resolveu encolhê-lo usando UPX. Estas informações estão no arquivo rbx.nfo que acompanha o pacote.
Objetivo do desafio
Digitar um nome e um número de série que seja aceito.
Analisando o programa
Quando o número de série não bate com o nome fornecido, nada acontece. Nem mesmo uma mensagenzinha de erro 
Isto dificulta um pouco as coisas, pois não temos nenhuma string à qual podemos nos apegar.
Planejando o ataque
Sempre é bom confirmar as informações fornecidas pelo autor e, a primeira coisa a fazer é determinar se o executável realmente foi empacotado pelo UPX. Caso isto se confirme, temos que desempacotar o Rebelx. Uma vez aberto, toca procurar algum ponto de apoio para poder começar e, geralmente, a procura de strings acaba revelando um caminho a seguir.
As ferramentas
Tenho algumas sugestões (todas as ferramentas encontram-se disponíveis para download):
- PEid - este identificador de PE é ótimo para confirmar se o programinha está mesmo compactado com UPX. Pode ser usado para descompactar o programa (livrá-lo do UPX), procurar strings e dar uma olhada no código desassemblado. Procure em downloads > informática > utilitários.
- GUiPeX - excelente para descompactar (tirar o UPX) de uma forma bem "limpa". Procure em downloads > informática > compactadores.
- OllyDbg - o debugger para rodar o programa e entender o código desassemblado. Procure em downloads > informática > debuggers.
PILOTANDO O MOUSE
Lá vamos nós! Rode o PEid, clique no botão [...] superior direito e carregue o executável que está na mira. Você deve obter o seguinte resultado:
Vamos por partes: em primeiro lugar, dê uma olhada na área de texto logo acima dos botões inferiores - o recado nos diz "UPX 0.89.6 - 1.02 / 1.05 - 1.24 (Delphi) stub -> Markus & Laszlo". Noooossa, o Jules não enganou ninguém. Não é que o Rebelx está mesmo UPXzado! A vontade é logo partir para a etapa seguinte, mas, antes disto, dê uma olhadinha mais caprichada. Na ER toda e qualquer informação é preciosa e o piloto do rato deve ter a paciência de ir colecionando todas as particularidade que encontrar pelo caminho. Ah, e também anotar tudo, porque nunca se sabe...
Pois bem, clicando no botão à direita de EP Section, podemos verificar que as seções do executável são UPX0, UPX1 e .rsrc. Tudo indica que não é nenhuma enganação, o Rebelx realmente foi empacotado do modo mais tradicional possível com o UPX.
Desempacotando o Rebelx - capítulo I
O UPX é tão feijão com arroz que o PEid consegue descompactá-lo sem problema. Só para ver como funciona o plugin de desempacotamento genérico, clique no botão [->] no canto inferior direito, escolha Plugins e PEiD Generic Unpacker. Depois clique no botão [->] à direita de OEP Detected para encontrar o ponto de entrada do executável e, a seguir, no botão [Unpack]. Isto é tudo. Na mesma pasta onde você colocou o executável que está sendo analisado (Rebelx crackme 3.exe) você vai encontrar o Rebelx crackme 3.exe.unpacked_.exe. Observe que o arquivo original possui 161 Kb e que o arquivo descompactado mostra 448 Kb. É isso aí!
Melhor continuar explorando o que o PEid ainda pode nos oferecer. Clique novamente no botão [...] do canto superior direito e, desta vez, carregue o arquivo descompactado. Xiiiiii, continua dizendo que tem seções UPX. Só que, desta vez, se você clicar no botão [>] ao lado de EP Section, as seções mostradas serão UPX0, UPX1, .rsrc e .snaker. Além disso, a diferença no tamanho... não custa tentar.
O código descompilado
O PEid possui um decompilador simplificado que é uma mão na roda para quem tem alguma noção de Assembly. Se este não é o seu caso, sinto muito... vai ser difícil acompanhar a conversa daqui pra frente. Se você sabe do que eu estou falando, então mãos à obra e vamos lá.
Com o Rebelx descompactado e carregado no PEid, clique no botão [>] ao lado de First Bytes. Você obtém uma janela identificada por PE Disassembler v0.03 :: CADT. No rodapé desta janela clique no botão [Strings] para abrir a janela seguinte. Dê uma procurada até achar a string mostrada abaixo:
Ahá! Se o Rebelx não dá mensagens de erro, pelo menos dá os parabéns quando acertamos o dupla nome-serial! Dê um duplo clique sobre a string Congratulations! The serial is correct. O endereço de e-mail address está sendo protegido de spambots. Você precisa ativar o JavaScript enabled para vê-lo. para abrir uma nova janela cujo nome é PEiD Reference Viewer v0.01 e onde aparece o Offset e o RVA. Não desanime - dê outro duplo clique na única linha mostrada para posicionar o código no desassemblador. Clique no botão [OK] para fechar a janela PEiD Reference e no botão [Close] da janlea PEiD String Viewer v0.02. Agora, a primeira linha do PE Disassembler mostra a string que nos interessa.
A pergunta agora é: como chegamos até esta mensagem? O jeito é dar uma olhada no código que está um pouco antes deste ponto. Como a mensagem é referida no endereço 00453B49 (seu endereço pode ser diferente!), digite na caixa de texto localizada no rodapé e identificada por Start From um endereço um pouco menor - por exemplo, 00453A00 - e depois clique no botão [>] imediatamente ao lado. O código desassemblado é novamente reposicionado. Agora, é um abraço. Localize o seguinte:
00453A81: 33C0 XOR EAX, EAX
00453A83: A0046C4500 MOV AL, [456C04]
00453A88: 85C0 TEST EAX, EAX
00453A8A: 7E0C JLE 453A98
00453A8C: BA056C4500 MOV EDX, 00456C05
00453A91: 803214 XOR BYTE PTR [EDX], 14
00453A94: 42 INC EDX
00453A95: 48 DEC EAX
00453A96: 75F9 JNZ 453A91
00453A98: 33C0 XOR EAX, EAX
00453A9A: A0046D4500 MOV AL, [456D04]
00453A9F: 85C0 TEST EAX, EAX
00453AA1: 7E0C JLE 453AAF
00453AA3: BA056D4500 MOV EDX, 00456D05
00453AA8: 803219 XOR BYTE PTR [EDX], 19
00453AAB: 42 INC EDX
00453AAC: 48 DEC EAX
00453AAD: 75F9 JNZ 453AA8
00453AAF: 33C0 XOR EAX, EAX
00453AB1: A0046E4500 MOV AL, [456E04]
00453AB6: 85C0 TEST EAX, EAX
00453AB8: 7E0C JLE 453AC6
00453ABA: BA056E4500 MOV EDX, 00456E05
00453ABF: 803217 XOR BYTE PTR [EDX], 17
00453AC2: 42 INC EDX
00453AC3: 48 DEC EAX
00453AC4: 75F9 JNZ 453ABF
00453AC6: 33C0 XOR EAX, EAX
00453AC8: A0046F4500 MOV AL, [456F04]
00453ACD: 85C0 TEST EAX, EAX
00453ACF: 7E0C JLE 453ADD
00453AD1: BA056F4500 MOV EDX, 00456F05
00453AD6: 803218 XOR BYTE PTR [EDX], 18
00453AD9: 42 INC EDX
00453ADA: 48 DEC EAX
00453ADB: 75F9 JNZ 453AD6
00453ADD: 8D45EC LEA EAX, [EBP-14]
00453AE0: BA046C4500 MOV EDX, 00456C04
00453AE5: E81A07FBFF CALL 00404204
00453AEA: FF75EC PUSH [EBP-14]
00453AED: 8D45E8 LEA EAX, [EBP-18]
00453AF0: BA046D4500 MOV EDX, 00456D04
00453AF5: E80A07FBFF CALL 00404204
00453AFA: FF75E8 PUSH [EBP-18]
00453AFD: 8D45E4 LEA EAX, [EBP-1C]
00453B00: BA046E4500 MOV EDX, 00456E04
00453B05: E8FA06FBFF CALL 00404204
00453B0A: FF75E4 PUSH [EBP-1C]
00453B0D: 8D45E0 LEA EAX, [EBP-20]
00453B10: BA046F4500 MOV EDX, 00456F04
00453B15: E8EA06FBFF CALL 00404204
00453B1A: FF75E0 PUSH [EBP-20]
00453B1D: B804704500 MOV EAX, 00457004
00453B22: BA04000000 MOV EDX, 00000004
00453B27: E8F407FBFF CALL 00404320
00453B2C: 8D55DC LEA EDX, [EBP-24]
00453B2F: 8B83FC020000 MOV EAX, [EBX+000002FC]
00453B35: E89AF0FDFF CALL 00432BD4
00453B3A: 8B55DC MOV EDX, [EBP-24]
00453B3D: A104704500 MOV EAX, [457004]
00453B42: E86508FBFF CALL 004043AC
00453B47: 750A JNZ 453B53
00453B49: B8983B4500 MOV EAX, 00453B98 -> Congradulations! The serial is correct.
jules@orbit.za.net
Observe as quatro instruções destacadas em vermelho. Será que agora dá para descobrir como é montado o número serial?
Calculando o serial
Na listagem do código desassemblado, observe a primeira sequência de instruções que inclui a destacada em vermelho:
00453A81: 33C0 XOR EAX, EAX 00453A83: A0046C4500 MOV AL, [456C04] 00453A88: 85C0 TEST EAX, EAX 00453A8A: 7E0C JLE 453A98 00453A8C: BA056C4500 MOV EDX, 00456C05 00453A91: 803214 XOR BYTE PTR [EDX], 14 00453A94: 42 INC EDX 00453A95: 48 DEC EAX 00453A96: 75F9 JNZ 453A91
Em 453A81 o registrador EAX foi zerado com a instrução XOR EAX, EAX e, na instrução seguinte, AL recebe um valor que se encontra num endereço de memória. Ao que tudo indica, este valor é usado como contador porque um pouco mais abaixo EAX é decrementado e, se seu valor não for zero, a execução volta para a linha 453A91. Com toda probabilidade o valor guardado em AL de EAX é o comprimento do nome digitado e cada um dos endereços dos caracteres é colocado no registrador EDX para que possam ser tratados neste loop com um XOR 14. Depois do XOR 14, EDX é incrementado (para apontar para o próximo caracter) e EAX é decrementado para testar se o fim do nome foi alcançado.
O que vem a ser um XOR 14? Digamos que a primeira letra do nome seja A, cujo valor ASCII é 65 decimal ou 41 hexadecimal (pegue a sua calculadora favorita e confira). Bem, o valor binário de 41h é 0100 0001 e o valor binário de 14h é 0001 0100. Numa operação XOR, quando os bits são diferentes o resultado é 1 e, quando os bits são iguais, o resultado é zero. Por exemplo, 1 XOR 1 = 0, 0 XOR 0 = 0 e 1 XOR 0 = 1. Veja a operação com os valores 41h e 14h logo a seguir:
0100 0001 (41h)
XOR 0001 0100 (14h)
---------
0101 0101 (55h = 85d = caracter U)
Esta operação XOR transformou o caracter A no caracter U. Acontece que o código mostra quatro operações XOR: com 14h, com 19h, com 17h e com 18h. Isto significa que cada caracter do nome será trocado por quatro caracteres. O primeiro já foi calculado e resultou em U. Os outros três são:
0100 0001 (41h)
XOR 0001 1001 (19h)
---------
0101 1000 (58h = 88d = caracter X)
0100 0001 (41h)
XOR 0001 0111 (17h)
---------
0101 0110 (56h = 86d = caracter V)
0100 0001 (41h)
XOR 0001 1000 (18h)
---------
0101 1001 (59h = 89d = caracter Y)
Ou seja, se o raciocínio estiver certo, o serial do nome A deve ser UXVY. Confira para ver se você recebe a mensagem de congratulação 
Obs: caso você não saiba quais são os caracteres que correspondem aos valores calculados, procure a Tabela ASCII na seção informática > oficina > referências.
Agora deixe a preguiça de lado. Pegue lápis, papel e uma calculadora (a do Windows em modo científico quebra uma galho) e determine na raça o serial para o nome ALDEIA.
Mais algumas dicas
No começo do texto eu falei sobre duas ferramentas que nos ajudariam a quebrar este crackme: o GUiPeX e o OllyDbg. Se você baixou estes programas e já os instalou, siga com a leitura.
GUiPeX - UPX Front-End para Win32
O GUiPeX é um compactador / descompactador para UPX, um algoritmo de compactação de código aberto disponibilizado sob licença GNU General Public License. Como o UPX roda apenas em DOS, a interface gráfica do GUiPeX é muito benvinda. Só tem um porém: o UPX está na versão 2.02 e a versão default do GUiPeX é 1.24. Mas tem uma notícia muito boa. Você pode fazer o download do UPX mais atualizado no site do projeto UPX e configurar o GUiPeX para usar a versão que você deseja. Faça o seguinte:
- Faça o download do UPX atualizado.
- Descompacte o pacote numa pasta própria.
- Rode o GUiPeX.
- Clique no item de menu Tools e escolha Options
- Clique na aba UPX Location e no botão com uma pasta ao lado da caixa de texto identificada por Specify location of UPX.exe.
- Procure e selecione o executável do UPX que você acabou de instalar.
Isto é tudo. Assim que você tiver apontado o upx.exe, os campos abaixo de Installed UPX information serão preenchidos, indicando que o GUiPeX usará o executável desejado. Feche a janela das opções clicando no botão [OK] e o GUiPeX está pronto para compactar ou descompactar executáveis.
Desempacotando o Rebelx - capítulo II
Quando usamos o descompactador genérico do PEid, o Rebelx foi descompactado de uma forma meio estranha: os nomes das seções UPX0, UPX1 e .rsrc não foram alterados e, além disto, foi criada uma nova seção com o nome de .snaker. Será que é assim mesmo, ou será que é possível recuperar a forma original do programa? Esta resposta será dada pela dupla UPX/GUiPeX
- Clique e arraste o programa Rebelx crackme 3.exe para a área identificada por Files to Compress/Decompress da janela principal do GUiPeX.
- Na área UPX Commands, escolha Decompress no caixa de opções identificada por Commands.
- Marque a opção Keep Backup File.
- Clique no botão [Run] na barra de ferramentas.
Na área de texto da parte inferior da janela principal aparece um relatório dizendo que o executável foi descompactado pelo UPX 2.02 em 328 milisegundos etc e tal. Bem, é sinal que funcionou e de que está na hora de ver os resultados. Vá para a pasta onde está o Rebelx e confira: devem existir dois arquivos, o Rebelx crackme 3.exe (que está descompactado) e a cópia que pedimos que fosse feita, cujo nome é Rebelx crackme 3.ex~
Logo de cara a primeira diferença - o tamanho do executável descompactado mostra 394 Kb contra os 448 Kb do arquivo descompactado pelo PEid. Se você tiver a paciência de abrir o novo descompactado com o PEid e der uma olhada nas seções do executável... tchan, tchan, tchan, tchan... as seções originais foram todas recuperadas (CODE, DATA, BSS, .idata, .tls, .rdata, .reloc e .rsrc). Foi isto que eu chamei de uma descompactação mais "limpa" :thumbup:
Tomando contato com o OllyDbg
O OllyDbg é um debugador com o qual podemos acompanhar passo a passo a execução de programas. Além possuir um desassemblador poderoso que nos mostra todas as linhas de comando, podemos observar o conteúdo dos registradores e de posições da memória. É uma delícia para quem está começando e um prato cheio para programadores experientes.
Neste artigo vou dar apenas algumas noções de como se lida com o OllyDbg - o resto vem em outros artigos e com a prática - e mostrar só algumas das muitas capacidades deste debugger.
Imagino que você já tenha instalado o aplicativo e que ele esteja rodando. Clique em File e escolha Open para carregar o Rebelx crackme 3.exe. O OllyDbg processa uma porção de coisas e mostra uma janela com quatro painéis. Clique com o botão direito do mouse na área do código desassemblado (painel superior esquerdo) para obter um menu como mostrado na fig.1:
Neste menu, escolha Search for (procurar por) e depois All referenced text strings. Isto faz com que seja apresentada uma nova janela com todas as strings encontradas no executável.
Para nossa sorte, a string que estamos procurando ("Congratulations...") aparece logo de cara. Para posicionar o código na janela principal de modo que ele mostre a presença desta string, basta dar um duplo clique sobre a mesma.
De volta à janela principal, role o texto do código um pouco para baixo. Você vai reconhecer logo os quatro loops que fazem os cálculos XOR pois o OllyDbg nos faz a gentileza de destacar estes loops! Procure pela linha de código um pouco acima do primeiro loop, onde está a instrução XOR EAX, EAX (na minha execução, esta instrução está na posição 00453A81 - a posição que você encontra pode ser outra). Clique nesta linha para selecioná-la e em seguida clique na mesma linha com o botão direito do mouse para abrir um menu do qual você deve selecionar Breakpoint e depois Toggle. Pronto, você acaba de colocar um ponto de parada que fica destacado em vermelho (aliás, a tecla F2 faz o mesmo serviço - marcar e desmarcar breakpoints).
Observe que no canto inferior direito há uma área de texto destacada em amarelo que diz Paused. Isto quer dizer que preparamos tudo com o programa paradinho da silva... aliás, no canto inferior esquerdo a mensagem é Program entry point, ou seja, a execução está parada e o ponteiro está no ponto de entrada do programa. Muito bom, agora é só rodar o bicho. Clique no item de menu Debug e depois em Run (ou simplesmente F9, ou ainda na seta azul virada para a direita na barra de ferramentas) para dar início à festa.
Como resultado, a janela do Rebelx aparece na tela e a mensagem no canto inferior direito diz Running (executando). Clique na janela do Rebelx e digite ALDEIA na caixa de texto superior. Passe para a caixa de texto inferior e digite qualquer coisa. Logo depois do primeiro caracter digitado, a execução dispara e as instruções vão sendo executadas sem perdão até chegar o breakpoint que colocamos (veja que a mensagem Paused aparece assim que a execução pára). Agora é só ter calma, forçar uma execução passo a passo e prestar atenção nas mensagens e nos registradores.
A tecla de atalho para executar passo a passo é F7. Observe que o registrador EAX mostra o valor 6 e que, pressionando F7, a instrução XOR EAX, EAX é executada e o registrador mostra o valor zero. Mais um passo e o registrador EAX guarda o valor 6 (o comprimento do nome do usuário) depois de executar a instrução MOV AL,BYTE PTR DS:[456C04]. Continue repetindo F7 e observe como o valor em EAX vai diminuindo e como os caracteres da string ALDEIA na linha da instrução
00453A8C |. BA 056C4500 MOV EDX,Rebelx_c.00456C05 ; ASCII "ALDEIA"
vão sendo substituídos um a um em cada passada do loop até a string original ser transformada em UXPQ]U. O segundo loop, que faz um XOR 19, a string original é substituída por XU]\PX; o terceiro, do XOR 17, gera a string VSR[^V; o quarto loop (XOR 18) cria YT\JQY. Agora, é só concatenar as quatro strings para obter o serial para o usuário ALDEIA.
Obs: quando você encontrar uma instrução CALL pelo caminho e não quiser ser desviado para esta subrotina, use a tecla F8 (step over) ao invés da F7... e bom divertimento que por ora é só!